@sigloch/contracts 10.12.0 → 10.14.0

package/dist/se/analysis-freshness-rules.js

@@ -6,6 +6,44 @@ const ARTIFACT_LABEL = {
     fmea: 'FMEA',
     implplan: 'Implementation Plan',
 };
+/**
+ * CR-SM-382: was der Hinweis nennt — den Task, seinen Skill und den ersten Arbeitsschritt.
+ *
+ * Bis hierher lautete der fix_hint "Set attributes.analysisFreshness.<id>.graphVersion …". Gemessen im
+ * lokalen AgentDiary-Lauf (local-1, 2026-09-30): das Modell setzte fuenf Stempel in einem Zug, ohne ein
+ * einziges Artefakt, und meldete die Analysen als erledigt — der Hinweis nannte die Metrik als Handlung.
+ * Dazu wich die Artefakt-id vom Task-Namen ab (`implplan` gegen `plan`), der Aufruf
+ * `graph_generate {task:'implplan'}` schlug fehl. Der Hinweis nannte darauf den Aufruf woertlich und die
+ * Arbeit; den Stempel schreibt der letzte Schritt des Skills, zusammen mit den Funden.
+ *
+ * CR-SM-387: der Hinweis nennt keinen Werkzeugnamen mehr. `graph_generate` hat nur der Autopilot; der
+ * interaktive Agent (todo-local, 2026-10-03) zitierte den Aufruf zweimal als fehlendes Werkzeug und
+ * liess die Analyse liegen. Der Skill fuehrt die Analyse in beiden Betriebsarten — er ist der Name, der
+ * stimmen muss (`skill` folgt RULE_HELP[…].prompt, der Test haelt beide zusammen); damit entfaellt auch
+ * die Fehlerquelle `task` gegen Artefakt-id.
+ */
+const ANALYSIS_WORK = {
+    conops: {
+        skill: 'se-conops',
+        firstStep: 'walk configuration, credentials, user management, deployment, observability and data lifecycle, and write each concern the system must satisfy as a non-functional REQ with its TEST at SYS scope',
+    },
+    trade: {
+        skill: 'se-trade',
+        firstStep: 'name the open decision with its options and criteria, then record the chosen option as a CR with relation(label: decides) edges to what it decides',
+    },
+    'assumption-review': {
+        skill: 'se-irr',
+        firstStep: 'list every unproven assumption the model rests on (unmeasured numbers, unverified external dependencies) in a record under docs/records/, then promote the load-bearing ones to CRs',
+    },
+    fmea: {
+        skill: 'se-fmea',
+        firstStep: 'for each FCHAIN name its failure modes and add each one as a REQ with role risk (severity, occurrence, detection) plus a mitigation REQ and its TEST',
+    },
+    implplan: {
+        skill: 'se-plan',
+        firstStep: 'cut one CR per leaf REQ at its carrier and group the CRs into MS milestones in dependency order',
+    },
+};
 /** Presence-check for one analysis artifact's freshness stamp, anchored on SYS. */
 function analysisFreshnessPresence(ruleId, artifactId) {
     return (graph) => {
@@ -16,12 +54,13 @@ function analysisFreshnessPresence(ruleId, artifactId) {
         if (AnalysisFreshnessStampSchema.safeParse(stamp).success)
             return [];
         const label = ARTIFACT_LABEL[artifactId];
+        const work = ANALYSIS_WORK[artifactId];
         return [{
                 rule_id: ruleId,
                 severity: 'warning',
                 element_id: sys.id,
-                message: `${label} (${artifactId}) has no freshness stamp — was it ever written with a graphVersion stamp?`,
-                fix_hint: `Set attributes.analysisFreshness.${artifactId}.graphVersion to the current graphVersion() when writing/refreshing the ${label} artifact`,
+                message: `${label} has not been carried out — no analysis is on record for this system`,
+                fix_hint: `Carry out the ${label}: work through the skill ${work.skill} step by step. First step: ${work.firstStep}. The closing step of the skill records the analysis as done, in the same batch as its findings`,
                 context: { element_type: sys.type, element_name: sys.name },
             }];
     };

package/dist/se/conformance-rules.js

@@ -104,7 +104,7 @@ function codeRefMustResolve(graph, facts) {
                 severity: 'warning',
                 element_id: el.id,
                 message: `${el.id} realRef.file '${ref.file}' does not exist on disk`,
-                fix_hint: 'Re-realize the FUNC (graph_realize) against the current source tree, or fix the moved/renamed file path',
+                fix_hint: `Re-bind the FUNC to the current source tree via graph_mutate Format-E \`~ ${el.id} @realRef {"file":…,"symbol":…}\` — or restore the moved/renamed file`,
                 context: { element_type: el.type, element_name: el.name },
             });
             continue;
@@ -148,7 +148,7 @@ function testRefMustResolve(graph, facts) {
                     severity: 'warning',
                     element_id: el.id,
                     message: `${el.id} testRefs entry file '${ref.file}' does not exist on disk`,
-                    fix_hint: 'The test file was moved or deleted — rebind the TEST (graph_realize) to the current file, or drop the entry',
+                    fix_hint: `The test file was moved or deleted — rebind the TEST via graph_mutate Format-E \`~ ${el.id} @testRefs [{"file":…,"tool":…}]\` (the patch replaces the whole list — carry the other entries), or drop the entry`,
                     context: { element_type: el.type, element_name: el.name },
                 });
                 continue;
@@ -192,7 +192,7 @@ function schemaRefMustResolve(graph, facts) {
                 severity: 'warning',
                 element_id: el.id,
                 message: `${el.id} realRef.file '${ref.file}' does not exist on disk`,
-                fix_hint: 'Re-bind the SCHEMA (graph_realize) to the current source tree, or fix the moved/renamed file path',
+                fix_hint: `Re-bind the SCHEMA to the current source tree via graph_mutate Format-E \`~ ${el.id} @realRef {"file":…,"symbol":…}\` — or restore the moved/renamed file`,
                 context: { element_type: el.type, element_name: el.name },
             });
             continue;
@@ -653,6 +653,42 @@ function schemaParsedOnlyAtInterface(graph, facts) {
     }
     return violations;
 }
+// ---------------------------------------------------------------------------
+// RC-10 (CR-SM-344): a MOD must be resolvable — carry a `path`, or have at least one
+// allocated FUNC with a bound realRef. Those are the only two ways `buildModResolver`
+// maps a file to a MOD; a MOD with neither can never own a file, so RC-05 and the
+// boundary measurement are blind to it BY CONSTRUCTION. Measured at sigllm: 0 RC-05
+// findings at 19 % import coverage, 8 at 81 % — the zero was the absence of a question.
+// The cost in the message comes from `importCoverage` (the same resolution), not from a
+// second count. `concept`/`external` are exempt — the same exemptions as R-20.
+// ABSENT `importEdges` = silence, like RC-05: without an import graph RC-05 has nothing to
+// judge, so there is no blindness to report — and the cost could not be named.
+// ---------------------------------------------------------------------------
+function modMustBeResolvable(graph, facts) {
+    if (facts.importEdges === undefined)
+        return []; // extractor supplied no import graph — silence
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const boundFuncs = new Set(graph.elements.filter(e => e.type === 'FUNC' && readRealRef(e.attributes).state === 'bound').map(e => e.id));
+    const resolvedByFunc = new Set(graph.traces
+        .filter(t => t.type === 'allocate' && boundFuncs.has(t.source) && typeOf.get(t.target) === 'MOD')
+        .map(t => t.target));
+    const blind = graph.elements.filter(e => e.type === 'MOD' &&
+        e.attributes?.concept !== true && e.attributes?.external !== true &&
+        !(typeof e.attributes?.path === 'string' && e.attributes.path.length > 0) &&
+        !resolvedByFunc.has(e.id));
+    if (blind.length === 0)
+        return [];
+    const coverage = importCoverage(graph, facts);
+    const cost = `${coverage.unassigned.length} of ${coverage.endpoints} import endpoints stay unassigned in this repo`;
+    return blind.map(el => ({
+        rule_id: 'RC-10',
+        severity: 'warning',
+        element_id: el.id,
+        message: `${el.id} has neither a path nor an allocated FUNC with a realRef — no file can resolve to it, RC-05 is blind here (${cost})`,
+        fix_hint: `Set the module's source directory via graph_mutate Format-E \`~ ${el.id} @path <dir>\` — or bind one of its allocated FUNCs (\`~ FUNC-x @realRef {"file":…,"symbol":…}\`); mark it concept:true if no code realizes it yet`,
+        context: { element_type: el.type, element_name: el.name },
+    }));
+}
 export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-01', name: 'FUNC realRef resolves to a declared symbol', severity: 'warning', domain: ['FUNC'], evaluate: codeRefMustResolve },
     { id: 'RC-02', name: 'testRefs entries resolve to runnable tests', severity: 'warning', domain: ['TEST'], evaluate: testRefMustResolve },
@@ -663,6 +699,7 @@ export const CODE_CONFORMANCE_RULES = [
     { id: 'RC-07', name: 'CR node agrees with docs/cr', severity: 'warning', domain: ['CR', 'SYS'], evaluate: crNodeMatchesFile },
     { id: 'RC-08', name: 'SCHEMA realRef is a Zod schema', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaRefMustBeZod },
     { id: 'RC-09', name: 'SCHEMA is parsed only at its modelled interface', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaParsedOnlyAtInterface },
+    { id: 'RC-10', name: 'MOD has resolvable files', severity: 'warning', domain: ['MOD'], evaluate: modMustBeResolvable },
 ];
 /** Run all RC rules against a graph + extracted code facts. */
 export function evaluateConformanceRules(graph, facts) {

package/dist/se/cr-quality-rules.js

@@ -1,3 +1,4 @@
+import { readRealRef } from './ontology.js';
 // ---------------------------------------------------------------------------
 // CR-R01: ein offener CR nennt, WAS er aendert (CR-SM-295)
 //
@@ -178,6 +179,76 @@ function crShouldHaveMilestone(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// CR-R05: kein Blatt-REQ ohne Bauauftrag (CR-SM-343) — die REQ-Seite von CR-R01.
+//
+// RD-01 fragt nach einem Traeger, R-01 nach einer Verifikation; ob ein REQ einen BAUAUFTRAG
+// hat, fragte niemand. Gemessen am Fremdlauf sigllm: `se-plan` meldete „20 von 20 geordnet",
+// im selben Graphstand hatten 24 von 64 Blatt-REQ keinen Auftrag — genau die, die alle 16
+// offenen FM-03-Risiken mildern.
+//
+// Beauftragt ist ein Blatt-REQ (kein `compose`→REQ-Kind), wenn ein CR eine `relation` (a)
+// direkt darauf traegt oder (b) auf eine FUNC, die es `satisfy`t. **MOD und SYS zaehlen
+// nicht:** ein Modul ist ein Behaelter — mitgerechnet las sigllm 55/64 statt 40/64 und sah
+// gesund aus. Wer ein REQ an einem MOD-/SYS-Traeger beauftragt, zieht die `relation` direkt
+// auf das REQ. FCHAIN ist kein Weg: `CR -relation-> FCHAIN` ist kein TRACE_PATTERN, eine
+// solche Kante waere R-18 — ein FCHAIN-getragenes REQ braucht also ebenfalls die direkte Kante.
+//
+// Jeder CR zaehlt, auch ein abgeschlossener: gebaut ist beauftragt.
+//
+// **Eine gebaute FUNC deckt ohne CR** (CR-SM-375): traegt die FUNC eine gueltige `realRef`
+// oder ist sie `external`, ist der Bauauftrag erledigt — Bestand vor der CR-Disziplin braucht
+// keinen nachgetragenen Auftrag. `concept: true` ist nicht gebaut, auch mit realRef. Fuer
+// MOD/SYS/FCHAIN aendert das nichts: dort deckt nur die direkte `CR -relation-> REQ`.
+//
+// **Ohne CR-Knoten schweigt die Regel** und zaehlt weder im Zaehler noch im Nenner
+// (`RULE_PRECONDITION`, readiness.ts). Ein Repo ohne Plan im Graphen (`cr: docs`) bekaeme
+// sonst auf jedem REQ einen Befund — die Regel wuerde abgeschaltet und waere danach ueberall
+// still (Fail-open-Klasse ND-01/ND-02 vor CR-SM-286).
+// ---------------------------------------------------------------------------
+function funcIsBuilt(e) {
+    if (e.attributes?.concept === true)
+        return false;
+    return e.attributes?.external === true || readRealRef(e.attributes).state === 'bound';
+}
+function leafReqNeedsBuildOrder(graph) {
+    const crIds = new Set(graph.elements.filter(e => e.type === 'CR').map(e => e.id));
+    if (crIds.size === 0)
+        return [];
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const ordered = new Set(); // CR -relation-> X, oder eine bereits gebaute FUNC
+    for (const t of graph.traces) {
+        if (t.type === 'relation' && crIds.has(t.source))
+            ordered.add(t.target);
+    }
+    for (const e of graph.elements) {
+        if (e.type === 'FUNC' && funcIsBuilt(e))
+            ordered.add(e.id);
+    }
+    const covered = new Set();
+    const parents = new Set();
+    for (const t of graph.traces) {
+        if (t.type === 'relation' && crIds.has(t.source) && typeOf.get(t.target) === 'REQ')
+            covered.add(t.target);
+        if (t.type === 'satisfy' && typeOf.get(t.source) === 'FUNC' && ordered.has(t.source))
+            covered.add(t.target);
+        if (t.type === 'compose' && typeOf.get(t.source) === 'REQ' && typeOf.get(t.target) === 'REQ')
+            parents.add(t.source);
+    }
+    return graph.elements
+        .filter(e => e.type === 'REQ' && !parents.has(e.id) && !covered.has(e.id))
+        .map(req => ({
+        rule_id: 'CR-R05',
+        severity: 'warning',
+        element_id: req.id,
+        message: `${req.id} is a leaf REQ with no build order (no CR relation to it or to a FUNC that satisfies it, and no built FUNC satisfies it)`,
+        fix_hint: `Add a CR relation through graph_mutate Format-E \`CR-x -relation-> ${req.id}\` — or to the FUNC that satisfies it; a CR on its MOD/SYS carrier does not count`,
+        context: {
+            element_type: req.type,
+            element_name: req.name,
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
 // Exports
 // ---------------------------------------------------------------------------
 export const CR_RULES = [
@@ -190,6 +261,7 @@ export const CR_RULES = [
     // Damit ist sie nach R-08/R-18 die dritte 'all'-Regel — bewusst, nicht vergessen.
     { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation, domain: ['all'] },
     { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone, domain: ['CR'] },
+    { id: 'CR-R05', name: 'Leaf REQ has a build order', severity: 'warning', evaluate: leafReqNeedsBuildOrder, domain: ['REQ'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
 // ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.

package/dist/se/evaluate-all.d.ts

@@ -30,5 +30,12 @@ export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RU
  * CR-SM-233: `policy` ist **Pflicht und ohne Fallback** — ein Aufruf ohne Policy ist ein
  * Typfehler, keine stille 0.7. Wer keine eigene Quelle hat (Konfiguration, Host), nimmt
  * `DEFAULT_METRIC_POLICY` sichtbar an der Aufrufstelle.
+ *
+ * CR-SM-378: `only` ist ein REGELFILTER, kein zweiter Auswerter — dieselbe Normalisierung,
+ * dieselbe Reihenfolge, dieselben `evaluate`-Aufrufe; eine Regel ausserhalb des Filters laeuft nur
+ * nicht. Das Ergebnis ist gleich dem Vollergebnis, nachtraeglich auf `only` gefiltert. Grund:
+ * der Steuer-Operator (se-engine `bestBySteer`) bewertete jeden Kandidaten mit dem ganzen
+ * Katalog, inklusive des quadratischen ND-01 — 8,9 von 17,1 s bei 2000 Knoten fuer Befunde, die
+ * er nie las. Ohne `only` laeuft der ganze Katalog.
  */
-export declare function evaluateAllRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];
+export declare function evaluateAllRules(graph: OntologyGraph, policy: MetricPolicy, only?: ReadonlySet<string>): RuleViolation[];

package/dist/se/evaluate-all.js

@@ -1,16 +1,16 @@
-import { V3_RULES, evaluateRules } from './rules.js';
-import { SC_RULES, evaluateSCRules } from './schema-quality-rules.js';
-import { UC_RULES, evaluateUCRules } from './uc-quality-rules.js';
-import { FC_RULES, evaluateFCRules } from './fchain-quality-rules.js';
-import { MT_RULES, evaluateMTRules } from './metric-rules.js';
+import { V3_RULES } from './rules.js';
+import { SC_RULES } from './schema-quality-rules.js';
+import { UC_RULES } from './uc-quality-rules.js';
+import { FC_RULES } from './fchain-quality-rules.js';
+import { MT_RULES } from './metric-rules.js';
 import { toEvaluableGraph } from './flat-graph.js';
-import { FM_RULES, evaluateFMRules } from './fmea-rules.js';
-import { VIEW_RULES, evaluateViewRules } from './view-rules.js';
-import { CR_RULES, evaluateCRRules } from './cr-quality-rules.js';
-import { ND_RULES, evaluateNDRules } from './near-duplicate-rules.js';
-import { AO_RULES, evaluateAORules } from './ao-rules.js';
-import { BQ_RULES, evaluateBQRules } from './quality-rules.js';
-import { AF_RULES, evaluateAFRules, TASK_OUTCOME_RULES, evaluateTaskOutcomeRules } from './analysis-freshness-rules.js';
+import { FM_RULES } from './fmea-rules.js';
+import { VIEW_RULES } from './view-rules.js';
+import { CR_RULES } from './cr-quality-rules.js';
+import { ND_RULES } from './near-duplicate-rules.js';
+import { AO_RULES } from './ao-rules.js';
+import { BQ_RULES } from './quality-rules.js';
+import { AF_RULES, TASK_OUTCOME_RULES } from './analysis-freshness-rules.js';
 import { CODE_CONFORMANCE_RULES } from './conformance-rules.js';
 /**
  * CR-SM-285: das Profil haengt am KATALOG, nicht am ID-Praefix.
@@ -67,14 +67,31 @@ export function getRuleDefsForProfile(profile) {
         return ALL_RULE_DEFS;
     return ALL_RULE_DEFS.filter(r => r.profile === profile);
 }
+/**
+ * Die ausgewerteten Kataloge in der Reihenfolge der kanonischen Befund-Sequenz (CR-SM-240).
+ * Ohne `CODE_CONFORMANCE_RULES` — die brauchen `CodeFacts` (s. CATALOGS). Die Reihenfolge ist
+ * Vertrag: das Golden (`se-rule-output-identity.test.ts`) pinnt sie.
+ */
+const EVALUATED_CATALOGS = [
+    V3_RULES, BQ_RULES, UC_RULES, FC_RULES, SC_RULES, ND_RULES, MT_RULES, CR_RULES, AO_RULES,
+    FM_RULES, VIEW_RULES, AF_RULES,
+    TASK_OUTCOME_RULES, // CR-SM-355
+];
 /**
  * Evaluate all rules against a graph. Single call replaces the individual evaluator calls.
  *
  * CR-SM-233: `policy` ist **Pflicht und ohne Fallback** — ein Aufruf ohne Policy ist ein
  * Typfehler, keine stille 0.7. Wer keine eigene Quelle hat (Konfiguration, Host), nimmt
  * `DEFAULT_METRIC_POLICY` sichtbar an der Aufrufstelle.
+ *
+ * CR-SM-378: `only` ist ein REGELFILTER, kein zweiter Auswerter — dieselbe Normalisierung,
+ * dieselbe Reihenfolge, dieselben `evaluate`-Aufrufe; eine Regel ausserhalb des Filters laeuft nur
+ * nicht. Das Ergebnis ist gleich dem Vollergebnis, nachtraeglich auf `only` gefiltert. Grund:
+ * der Steuer-Operator (se-engine `bestBySteer`) bewertete jeden Kandidaten mit dem ganzen
+ * Katalog, inklusive des quadratischen ND-01 — 8,9 von 17,1 s bei 2000 Knoten fuer Befunde, die
+ * er nie las. Ohne `only` laeuft der ganze Katalog.
  */
-export function evaluateAllRules(graph, policy) {
+export function evaluateAllRules(graph, policy, only) {
     // CR-SM-284: die Hebung der flach committeten SSOT laeuft HIER, nicht beim Aufrufer.
     //
     // `toEvaluableGraph` gibt es seit CR-SM-258 — und sie wurde von keinem Produktionspfad und
@@ -84,20 +101,6 @@ export function evaluateAllRules(graph, policy) {
     //
     // Idempotent und identitaetserhaltend (s. dort), also eine Normalisierung am einzigen Eingang
     // und kein Fallback: ein bereits genesteter Graph geht unveraendert und uneingepackt durch.
-    graph = toEvaluableGraph(graph);
-    return [
-        ...evaluateRules(graph, policy),
-        ...evaluateBQRules(graph, policy),
-        ...evaluateUCRules(graph, policy),
-        ...evaluateFCRules(graph, policy),
-        ...evaluateSCRules(graph, policy),
-        ...evaluateNDRules(graph),
-        ...evaluateMTRules(graph, policy),
-        ...evaluateCRRules(graph, policy),
-        ...evaluateAORules(graph, policy),
-        ...evaluateFMRules(graph, policy),
-        ...evaluateViewRules(graph, policy),
-        ...evaluateAFRules(graph),
-        ...evaluateTaskOutcomeRules(graph), // CR-SM-355
-    ];
+    const evaluable = toEvaluableGraph(graph);
+    return EVALUATED_CATALOGS.flatMap((rules) => rules.flatMap((rule) => (only === undefined || only.has(rule.id) ? rule.evaluate(evaluable, policy) : [])));
 }

package/dist/se/fchain-quality-rules.d.ts

@@ -1,5 +1,5 @@
 /**
- * FC-01..FC-03 — FCHAIN quality rules (CR-121 Phase 1).
+ * FC-02..FC-05 — FCHAIN quality rules (CR-121 Phase 1; FC-05 CR-SM-363).
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
@@ -7,5 +7,6 @@ import type { MetricPolicy } from './policy.js';
 export declare function fc02LeafUcHasFchain(graph: OntologyGraph): RuleViolation[];
 export declare function fc03FchainFlat(graph: OntologyGraph): RuleViolation[];
 export declare function fc04ActorBounded(graph: OntologyGraph): RuleViolation[];
+export declare function fc05ChainConnected(graph: OntologyGraph): RuleViolation[];
 export declare const FC_RULES: RuleDefinition[];
 export declare function evaluateFCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/fchain-quality-rules.js

@@ -96,6 +96,137 @@ export function fc04ActorBounded(graph) {
     }));
 }
 // ---------------------------------------------------------------------------
+// FC-05: FCHAIN ist gerichtet zusammenhaengend (CR-SM-363).
+//
+// Eine FCHAIN ist grammatisch eine Menge (`FCHAIN -compose-> FUNC`); die Reihenfolge entsteht
+// erst aus Erzeuger -> Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Bilden die
+// Glieder darueber mehr als EINE (schwache) Komponente, beschreibt jede Kettenkennzahl etwas,
+// das es nicht gibt. IO-01 sieht das nicht: es verbindet zwei Glieder schon, wenn beide
+// denselben FLOW konsumieren. Gemessen (graphcode spike-kettenkennzahlen, 76 Ketten): 20
+// zerfallen ohne jede Regel.
+//
+// Je Nebenkomponente (alles ausser der groessten; Gleichstand nach kleinster ID — Gate 5) die
+// Ursache:
+//   - `missing-link`: Haupt- und Nebenteil sind ueber eine FUNC AUSSERHALB der Kette verbunden
+//     (Glied -> FLOW -> X -> FLOW -> Glied) — der verbindende Schritt gehoert in die Kette.
+//     Nur eine FUNC ist ein fehlendes Glied: ein Weg ueber einen ACTOR geht ueber die
+//     Systemgrenze, und einen ACTOR kann keine Kette aufnehmen.
+//   - `bag`: sonst — keine FUNC verbindet die Teile: ein fehlender FLOW zwischen Gliedern oder
+//     parallele Dienste an einer gemeinsamen Quelle (dann ist die Kette zu teilen).
+// Traegt die Kette ein Glied ohne io-Eingang oder -Ausgang, gehoert sie zuerst R-31 — FC-05
+// schweigt, bis alle Glieder verdrahtet sind (keine Doppelmeldung, s. u.). Eingang/Ausgang der Kette fragt FC-04 (streng: ACTOR) — eine Kette ohne
+// jeden Eingang hat auch keinen ACTOR-Eingang, FC-05 schweigt deshalb dazu (eine Ursache, ein
+// Befund). EIN Befund je Kette, die Komponenten im Kontext (CR-SM-242).
+// ---------------------------------------------------------------------------
+export function fc05ChainConnected(graph) {
+    const idx = indexOf(graph);
+    // Erzeuger/Verbraucher je FLOW — ueber alle Typen (FUNC oder ACTOR).
+    const producers = new Map();
+    const consumers = new Map();
+    const wiredIn = new Set();
+    const wiredOut = new Set();
+    for (const t of idx.tracesOfType('io')) {
+        if (idx.typeOf(t.target) === 'FLOW') {
+            (producers.get(t.target) ?? producers.set(t.target, []).get(t.target)).push(t.source);
+            wiredOut.add(t.source);
+        }
+        if (idx.typeOf(t.source) === 'FLOW') {
+            (consumers.get(t.source) ?? consumers.set(t.source, []).get(t.source)).push(t.target);
+            wiredIn.add(t.target);
+        }
+    }
+    const successors = new Map();
+    for (const [flow, ps] of producers) {
+        for (const p of ps) {
+            const set = successors.get(p) ?? successors.set(p, new Set()).get(p);
+            for (const c of consumers.get(flow) ?? [])
+                if (c !== p)
+                    set.add(c);
+        }
+    }
+    const succ = (id) => successors.get(id) ?? new Set();
+    const violations = [];
+    for (const fc of idx.elementsOfType('FCHAIN')) {
+        const members = [...new Set(idx.out(fc.id, 'compose').map(t => t.target).filter(id => idx.typeOf(id) === 'FUNC'))].sort();
+        if (members.length < 2)
+            continue;
+        // Ein Glied ohne io-Eingang oder -Ausgang ist R-31s Befund — und er kann genau die Bruecke
+        // sein, die fehlt. Solange eines da ist, urteilt FC-05 nicht (eine Ursache, ein Befund):
+        // gemessen an graphcode FCHAIN-capture, wo `FUNC-decode` ohne Ausgang sonst einen Sack vortaeuscht.
+        if (members.some(f => !wiredIn.has(f) || !wiredOut.has(f)))
+            continue;
+        const inChain = new Set(members);
+        // Schwache Komponenten ueber Glied -> Glied.
+        const adj = new Map(members.map(m => [m, new Set()]));
+        for (const a of members) {
+            for (const b of succ(a))
+                if (inChain.has(b)) {
+                    adj.get(a).add(b);
+                    adj.get(b).add(a);
+                }
+        }
+        const seen = new Set();
+        const comps = [];
+        for (const m of members) {
+            if (seen.has(m))
+                continue;
+            const comp = [m];
+            seen.add(m);
+            for (let i = 0; i < comp.length; i++) {
+                for (const n of adj.get(comp[i]))
+                    if (!seen.has(n)) {
+                        seen.add(n);
+                        comp.push(n);
+                    }
+            }
+            comps.push(comp.sort());
+        }
+        if (comps.length < 2)
+            continue;
+        comps.sort((a, b) => b.length - a.length || a[0].localeCompare(b[0]));
+        const main = new Set(comps[0]);
+        // Aussen-FUNCs X mit from -> X -> to.
+        const bridges = (from, to) => {
+            const via = new Set();
+            for (const a of from) {
+                for (const x of succ(a)) {
+                    if (inChain.has(x) || idx.typeOf(x) !== 'FUNC')
+                        continue;
+                    if ([...succ(x)].some(b => to.has(b)))
+                        via.add(x);
+                }
+            }
+            return [...via];
+        };
+        const side = [];
+        for (const comp of comps.slice(1)) {
+            const set = new Set(comp);
+            const via = [...new Set([...bridges(main, set), ...bridges(set, main)])].sort();
+            side.push({ members: comp, cause: via.length > 0 ? 'missing-link' : 'bag', via });
+        }
+        if (side.length === 0)
+            continue;
+        const missing = [...new Set(side.flatMap(c => c.via))].sort();
+        const hints = [];
+        if (missing.length > 0)
+            hints.push(`add the missing link(s) as members: ${missing.map(f => `\`${fc.id} -compose-> ${f}\``).join(', ')}`);
+        // `bag` sagt nur: KEINE Aussen-FUNC verbindet die Teile. Das ist entweder ein fehlender FLOW
+        // zwischen zwei Gliedern (gemessen: graphcode FCHAIN-generation-states, Uebergabe an
+        // graph_suggest nicht modelliert) oder ein Sack paralleler Dienste — der Hinweis nennt beides.
+        if (side.some(c => c.cause === 'bag'))
+            hints.push('connect the parts with a FLOW from a producer member to a consumer member if they are one chain of effects — otherwise split the chain, one FCHAIN per chain of effects');
+        violations.push({
+            rule_id: 'FC-05',
+            severity: 'warning',
+            element_id: fc.id,
+            message: `${fc.id} falls apart into ${comps.length} unconnected parts along producer -> consumer (${side.map(c => `${c.members.join('+')}: ${c.cause}`).join('; ')})`,
+            fix_hint: `Via graph_mutate Format-E, ${hints.join('; or ')}`,
+            context: { element_type: fc.type, element_name: fc.name, side_components: side },
+        });
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
 // Aggregated
 // ---------------------------------------------------------------------------
 export const FC_RULES = [
@@ -105,6 +236,7 @@ export const FC_RULES = [
     // eine Kette mit n verschachtelten FUNCs erzeugt n Verstoesse gegen einen Beitrag von 1.
     { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat, domain: ['FUNC'] },
     { id: 'FC-04', name: 'FCHAIN actor-bounded (trigger+consumer)', severity: 'warning', evaluate: fc04ActorBounded, domain: ['FCHAIN'] },
+    { id: 'FC-05', name: 'FCHAIN is connected (producer -> consumer)', severity: 'warning', evaluate: fc05ChainConnected, domain: ['FCHAIN'] },
 ];
 // CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
 // ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.

package/dist/se/fmea-rules.js

@@ -1,13 +1,16 @@
 /**
  * CR-182: FMEA/FTA Risk Rules + NFR Budget Overshoot Detection.
  * FM-01: Risk-REQ missing FMEA attributes (severity, occurrence, detection).
- * FM-02: Risk-REQ without mitigation (compose→REQ(kinds∋mitigation)).
+ * FM-02: Risk-REQ without mitigation (compose→REQ(role=mitigation)).
+ * CR-SM-365: "Risk-REQ" heisst `attributes.role === 'risk'` (Leser `readReqRole`), nicht mehr
+ *   `kinds ∋ risk` — die Rolle ist die Motivation der Anforderung, nicht ihre Art. Kein
+ *   zweiter Pfad ueber `kinds`: ein Altgraph faellt hier still, bis er migriert ist.
  * FM-03: risk REQ with Action Priority High and no passed verification.
  * NFR-01: measured exceeds budget for an NFR dimension. CR-228 splits the target
  *   by dimension nature: physical budgets (weight/power/cost) live on the part
  *   (MOD); behavioral budgets (timing/memory-throughput) on the FCHAIN/FUNC.
  */
-import { readTestRefs } from './ontology.js';
+import { readReqRole, readTestRefs } from './ontology.js';
 import { actionPriority, apMethod } from './action-priority.js';
 const PHYSICAL_BUDGET_PAIRS = [
     ['costBudget', 'measuredCost', 'cost'],
@@ -20,12 +23,19 @@ const BEHAVIORAL_BUDGET_PAIRS = [
 ];
 const PHYSICAL_BUDGET_TYPES = ['MOD'];
 const BEHAVIORAL_BUDGET_TYPES = ['FUNC', 'FCHAIN'];
+/** Traegt das Element die FMEA-Rolle `role`? Einziger Weg der FM-Regeln (CR-SM-365). */
+const hasRole = (e, role) => {
+    if (e.type !== 'REQ')
+        return false;
+    const r = readReqRole(e.attributes);
+    return r.state === 'bound' && r.value === role;
+};
 // ---------------------------------------------------------------------------
 // FM-01: Risk-REQ without FMEA attributes
 // ---------------------------------------------------------------------------
 export function fm01MissingFmeaAttributes(graph) {
     return graph.elements
-        .filter(e => e.type === 'REQ' && e.kinds?.includes('risk'))
+        .filter(e => hasRole(e, 'risk'))
         .filter(e => {
         const a = e.attributes ?? {};
         return a['severity'] == null || a['occurrence'] == null || a['detection'] == null;
@@ -52,20 +62,20 @@ export function fm01MissingFmeaAttributes(graph) {
 // FM-02: Risk-REQ without mitigation
 // ---------------------------------------------------------------------------
 export function fm02MissingMitigation(graph) {
-    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    const riskReqs = graph.elements.filter(e => hasRole(e, 'risk'));
     return riskReqs
         .filter(riskReq => {
-        // Check: compose trace from riskReq to a REQ with kinds∋mitigation
+        // Check: compose trace from riskReq to a REQ with role=mitigation
         return !graph.traces.some(t => t.source === riskReq.id &&
             t.type === 'compose' &&
-            graph.elements.some(el => el.id === t.target && el.type === 'REQ' && el.kinds?.includes('mitigation')));
+            graph.elements.some(el => el.id === t.target && hasRole(el, 'mitigation')));
     })
         .map(e => ({
         rule_id: 'FM-02',
         severity: 'warning',
         element_id: e.id,
-        message: `${e.id} is a risk REQ without a mitigation REQ (compose→REQ[mitigation])`,
-        fix_hint: 'Create a mitigation REQ and link via compose trace',
+        message: `${e.id} is a risk REQ without a mitigation REQ (compose→REQ[role=mitigation])`,
+        fix_hint: 'Create a REQ with attributes.role="mitigation" (kinds functional or non-functional) and link it via compose trace',
     }));
 }
 // ---------------------------------------------------------------------------
@@ -80,7 +90,7 @@ export function fm03HighRiskUnverified(graph, policy) {
     const threshold = policy.riskRpn;
     if (threshold === null)
         return [];
-    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    const riskReqs = graph.elements.filter(e => hasRole(e, 'risk'));
     return riskReqs
         .filter(riskReq => {
         const a = riskReq.attributes ?? {};