@sigloch/contracts 10.14.0 → 12.0.0

package/dist/se/chain-metrics.js

@@ -0,0 +1,311 @@
+/**
+ * CR-SM-404 — Kennzahlen der Wirkkette: je FCHAIN eine Zahl, oder der Grund, warum es keine gibt.
+ *
+ * Die Leitlinie verlangt, die Realisierungsarchitektur AUF DER WIRKKETTE zu bewerten (graphcode
+ * `docs/graphcode_architektur_konzept.md`, „Kennzahlen der Wirkkette"). Bis hierher rechnete das
+ * nur ein Spike in graphcode (`scripts/spike-kettenkennzahlen.mjs`); von dort ist die Rechnung
+ * portiert, nicht neu erfunden. Gemessen 2026-10-09 ueber 10 Familie-Graphen: 76 Ketten, 31
+ * bewertbar.
+ *
+ * ## Diese Datei URTEILT NICHT
+ *
+ * Keine Regel, keine Schwelle, kein Katalogeintrag — dieselbe Trennung wie `moduleMetrics` und
+ * `functionCriticality`. Ob eine Laenge von 6 gut ist, sagt erst ein Profil.
+ *
+ * ## Nicht bewertbar heisst: KEINE Zahl
+ *
+ * Eine FCHAIN ist grammatisch eine Menge; die Reihenfolge entsteht erst aus Erzeuger ->
+ * Verbraucher (`FUNC -io-> FLOW -io-> FUNC`, beide Enden Glied). Zerfaellt die Kette, beschriebe
+ * jede Kennzahl etwas, das es nicht gibt. Eine solche Kette traegt deshalb ihre Gruende und kein
+ * einziges Zahlenfeld — das Schema laesst es nicht zu. Sie zaehlt im NENNER der Quote
+ * (`measurability`), die neben jedem Wert stehen muss wie die Bindungsquote neben RC-*.
+ *
+ * ## Wer urteilt, ob eine Kette eine Kette ist
+ *
+ * - `FC-05`: die Regel FC-05, aufgerufen, nicht nachgebaut. Ursache (fehlendes Glied, Sack) und
+ *   die Nebenkomponenten stehen in ihrem Befund (`context.side_components`), nicht hier.
+ * - `loose-member`: ein Glied ohne io-Eingang oder -Ausgang. Das ist die Bedingung, unter der
+ *   FC-05 sich ENTHAELT (R-31 meldet das Glied) — ohne diesen Grund haette eine solche Kette weder
+ *   einen FC-05-Befund noch einen Grund und bekaeme Zahlen.
+ * - `no-entry` / `no-exit`: kein FLOW von bzw. zu einem Knoten AUSSERHALB der Kette. Weiter als
+ *   FC-04, das nur einen ACTOR gelten laesst: eine Kette, die eine andere fortsetzt, ist messbar.
+ * - `empty`: keine FUNC (R-15).
+ *
+ * ## Ein Kettenbegriff, ein Modulbegriff
+ *
+ * Glied = direkte `FCHAIN -compose-> FUNC`-Kante, ueber `chainsByFunc` (R-30s Definition).
+ * Modul einer FUNC = direkte `allocate`-Kante, wie `module-crossings.ts` und `moduleMetrics`.
+ * Der Spike erbte das Modul ueber compose-Vorfahren; gemessen sind 326 von 326 Kettengliedern
+ * des Korpus direkt alloziert — die Vererbung kauft nichts und waere eine zweite Vorstellung von
+ * Zugehoerigkeit im selben Paket.
+ *
+ * ## CR-SM-406 — die ORTE je Kette, nur erkannt
+ *
+ * Neben jeder Zahl steht, WO sie herkommt: die Mitglieder je Rueckkopplung, die geteilten
+ * Funktionen, die Grenzen je gerichtetem Modulpaar mit ihren Vertraegen, dazu Zulauf, Importe und
+ * Uebergaben. Reine Zusatzfelder — die Zahlen aus CR-SM-404 bleiben und sind die Laenge ihrer
+ * Liste. Weiter kein Urteil.
+ *
+ * - Import und Uebergabe zaehlen nur an Gliedern, die ALLEIN dieser Kette gehoeren. Was an einer
+ *   geteilten Funktion haengt, steht an der geteilten Funktion — sie ist ein eigener Ort. Ohne
+ *   diese Grenze meldete jede Kette durch Gate und Store deren Zufluesse als ihre eigenen
+ *   (gemessen am graphcode-Modell 2026-10-10: 333 statt 16).
+ * - Ein ACTOR als Erzeuger oder Verbraucher ist der Ein- und Ausgang der Kette, kein Ort.
+ * - Vertrag = `contractsOfFlow` aus `module-crossings.ts` (SCHEMA, sonst `UNBOUND:<flow>`), hier je
+ *   Kettenkante gelesen. `moduleCrossings().pairs` selbst traegt die Vertraege des GANZEN Graphen
+ *   je ungerichtetem Paar und kann „elf Kanten auf einem Vertrag" in EINER Kette nicht zeigen.
+ *
+ * @author andreas@siglochconsulting
+ */
+import { z } from 'zod/v4';
+import { indexOf } from './graph-index.js';
+import { chainsByFunc } from './function-criticality.js';
+import { fc05ChainConnected } from './fchain-quality-rules.js';
+import { contractsOfFlow } from './module-crossings.js';
+const count = z.number().int().nonnegative();
+const identity = { chainId: z.string(), chainName: z.string() };
+/** CR-SM-406: ein Fluss an der Kettengrenze und das Glied der Kette, an dem er haengt. */
+const FlowAtFunc = z.strictObject({ flow: z.string(), func: z.string() });
+/**
+ * Eine bewertbare Kette: die fuenf heute rechenbaren Kennzahlen plus die Engstellen-Schranke,
+ * dazu die Orte (CR-SM-406). Jede Liste ist uid-sortiert.
+ */
+const MeasuredChain = z.strictObject({
+    ...identity,
+    measurable: z.literal(true),
+    /** Gesamtlaenge: FUNC-Schritte auf dem laengsten Pfad; eine Schleife zaehlt als EIN Schritt. */
+    length: count,
+    /** Verzweigungsgrad: groesster Ausgangsgrad eines Glieds INNERHALB der Kette. */
+    branching: count,
+    /**
+     * Modulgrenzen: Kettenkanten, deren Enden in verschiedenen MOD liegen.
+     * `null`, sobald ein Glied kein Modul hat (R-22 meldet es) — keine geratene Zahl.
+     */
+    moduleBoundaries: count.nullable(),
+    /** Rueckkopplungen: nicht-triviale starke Komponenten ueber die Kettenkanten. */
+    feedbackLoops: count,
+    /** Geteilte Knoten: Glieder, die in mehr als einer Kette liegen. */
+    sharedFuncs: count,
+    /**
+     * Engstellen — OBERE SCHRANKE: geteilte Glieder mit Ein- UND Ausgang in der Kette. Der
+     * Konzeptbegriff verlangt „synchron durchlaufen"; ohne `FLOW.sync` zaehlt jeder Durchgang.
+     */
+    bottlenecks: count,
+    /** Synchrone Tiefe — in dieser Stufe nie berechnet: braucht den Leser von `FLOW.sync` (CR-SM-364). */
+    syncDepth: z.null(),
+    /** Fehlerpfad-Tiefe — nicht berechenbar: Fehlerfluesse traegt kein Attribut (CR-SM-364, `kind` verworfen). */
+    errorPathDepth: z.null(),
+    /** Zahl der Glieder. */
+    memberCount: count,
+    /** Zulauf: groesster Eingangsgrad eines Glieds INNERHALB der Kette — das Gegenstueck zu `branching`. */
+    fanIn: count,
+    /**
+     * Die Rueckkopplungen, die `feedbackLoops` zaehlt. `id` entsteht allein aus den Mitgliedern
+     * (uids mit `+` verbunden) — dieselbe Schleife traegt in jeder Kette dieselbe Kennung.
+     */
+    loops: z.array(z.strictObject({ id: z.string(), members: z.array(z.string()).min(2) })),
+    /** Die geteilten Glieder, die `sharedFuncs` zaehlt. */
+    shared: z.array(z.string()),
+    /**
+     * Die Modulgrenzen je GERICHTETEM Modulpaar: `edges` Kettenkanten von `from` nach `to` (ihre
+     * Summe ist `moduleBoundaries`) auf den verschiedenen Vertraegen `contracts`. `null` wie dort.
+     */
+    boundaries: z.array(z.strictObject({
+        from: z.string(), to: z.string(), edges: count.min(1), contracts: z.array(z.string()).min(1),
+    })).nullable(),
+    /**
+     * Importe: ein Glied, das NUR in dieser Kette liegt, verbraucht einen Fluss, den mindestens
+     * eine FUNC erzeugt und kein Glied der Kette.
+     */
+    imports: z.array(FlowAtFunc),
+    /**
+     * Uebergaben, gespiegelt: ein Glied, das nur in dieser Kette liegt, erzeugt einen Fluss, den
+     * mindestens eine FUNC verbraucht und kein Glied der Kette.
+     */
+    handovers: z.array(FlowAtFunc),
+});
+/** Eine nicht bewertbare Kette: der Grund statt der Zahl. Reihenfolge der Gruende ist fest. */
+const UnmeasurableChain = z.strictObject({
+    ...identity,
+    measurable: z.literal(false),
+    reasons: z.array(z.enum(['FC-05', 'loose-member', 'no-entry', 'no-exit', 'empty'])).min(1),
+});
+// CR-SM-361: ein Zod-Vertrag, kein Typ — der Erzeuger prueft sein Ergebnis.
+export const ChainMetrics = z.object({
+    /** Eine Zeile je FCHAIN, in GRAPH-Reihenfolge — keine Rangfolge, die Zahl ist kein Urteil. */
+    chains: z.array(z.discriminatedUnion('measurable', [MeasuredChain, UnmeasurableChain])),
+    /** Die Reichweite der Aussage. `ratio` ist `null` ohne Ketten — kein Ersatzwert. */
+    measurability: z.object({ chains: count, measurable: count, ratio: z.number().min(0).max(1).nullable() }),
+});
+/** Die Kennzahlen aller FCHAINs dieses Graphen und die Quote der bewertbaren. */
+export function chainMetrics(graph) {
+    const idx = indexOf(graph);
+    const chainsOf = chainsByFunc(graph);
+    // FC-05 ist der EINE Leser fuer „gerichtet zusammenhaengend" — hier zaehlt nur, ob er meldet.
+    const fc05 = new Set(fc05ChainConnected(graph).map((v) => v.element_id));
+    const flowsInto = (id) => idx.in(id, 'io').map((t) => t.source).filter((s) => idx.typeOf(s) === 'FLOW');
+    const flowsOutOf = (id) => idx.out(id, 'io').map((t) => t.target).filter((s) => idx.typeOf(s) === 'FLOW');
+    const moduleOf = (func) => idx.out(func, 'allocate').map((t) => t.target).find((m) => idx.typeOf(m) === 'MOD');
+    const chains = idx.elementsOfType('FCHAIN').map((fc) => {
+        const who = { chainId: fc.id, chainName: fc.name };
+        const members = [...new Set(idx.out(fc.id, 'compose').map((t) => t.target).filter((id) => idx.typeOf(id) === 'FUNC'))].sort();
+        if (members.length === 0)
+            return { ...who, measurable: false, reasons: ['empty'] };
+        const inChain = new Set(members);
+        // Kettenkanten Erzeuger -> Verbraucher; dazu, wo die Kette von aussen gespeist wird und wo sie hinausliefert.
+        const next = new Map(members.map((m) => [m, new Set()]));
+        const carriers = new Map(); // Kettenkante `a b` -> die FLOWs, die sie tragen
+        let entry = false;
+        let exit = false;
+        let loose = false;
+        for (const m of members) {
+            const ins = flowsInto(m);
+            const outs = flowsOutOf(m);
+            if (ins.length === 0 || outs.length === 0)
+                loose = true;
+            for (const flow of ins)
+                if (idx.in(flow, 'io').some((t) => !inChain.has(t.source)))
+                    entry = true;
+            for (const flow of outs) {
+                for (const t of idx.out(flow, 'io')) {
+                    if (t.target === m)
+                        continue;
+                    if (!inChain.has(t.target)) {
+                        exit = true;
+                        continue;
+                    }
+                    next.get(m).add(t.target);
+                    const edge = `${m} ${t.target}`;
+                    (carriers.get(edge) ?? carriers.set(edge, new Set()).get(edge)).add(flow);
+                }
+            }
+        }
+        const reasons = [];
+        if (fc05.has(fc.id))
+            reasons.push('FC-05');
+        if (loose)
+            reasons.push('loose-member');
+        if (!entry)
+            reasons.push('no-entry');
+        if (!exit)
+            reasons.push('no-exit');
+        if (reasons.length > 0)
+            return { ...who, measurable: false, reasons };
+        // Rueckkopplungen: Tarjan — jede starke Komponente mit mehr als einem Glied ist eine Schleife.
+        const order = new Map();
+        const low = new Map();
+        const onStack = new Set();
+        const stack = [];
+        const sccOf = new Map();
+        const loops = [];
+        const visit = (v) => {
+            order.set(v, order.size);
+            low.set(v, order.get(v));
+            stack.push(v);
+            onStack.add(v);
+            for (const w of next.get(v)) {
+                if (!order.has(w)) {
+                    visit(w);
+                    low.set(v, Math.min(low.get(v), low.get(w)));
+                }
+                else if (onStack.has(w))
+                    low.set(v, Math.min(low.get(v), order.get(w)));
+            }
+            if (low.get(v) !== order.get(v))
+                return;
+            const comp = [];
+            let w;
+            do {
+                w = stack.pop();
+                onStack.delete(w);
+                comp.push(w);
+            } while (w !== v);
+            if (comp.length > 1)
+                loops.push({ id: comp.sort().join('+'), members: comp });
+            for (const c of comp)
+                sccOf.set(c, v);
+        };
+        for (const m of members)
+            if (!order.has(m))
+                visit(m);
+        loops.sort((a, b) => (a.id < b.id ? -1 : 1));
+        // Gesamtlaenge: laengster Pfad auf dem Kondensat — eine Schleife ist dort ein Knoten.
+        const condensed = new Map();
+        for (const [a, targets] of next) {
+            for (const b of targets) {
+                const ca = sccOf.get(a);
+                const cb = sccOf.get(b);
+                if (ca !== cb)
+                    (condensed.get(ca) ?? condensed.set(ca, new Set()).get(ca)).add(cb);
+            }
+        }
+        const longestFrom = new Map();
+        const longest = (c) => {
+            const known = longestFrom.get(c);
+            if (known !== undefined)
+                return known;
+            let best = 1;
+            for (const n of condensed.get(c) ?? [])
+                best = Math.max(best, 1 + longest(n));
+            longestFrom.set(c, best);
+            return best;
+        };
+        const length = Math.max(...members.map((m) => longest(sccOf.get(m))));
+        const allocated = members.every((m) => moduleOf(m) !== undefined);
+        let branching = 0;
+        const inDegree = new Map();
+        const pairs = new Map();
+        for (const [a, targets] of next) {
+            branching = Math.max(branching, targets.size);
+            for (const b of targets) {
+                inDegree.set(b, (inDegree.get(b) ?? 0) + 1);
+                const from = moduleOf(a);
+                const to = moduleOf(b);
+                if (from === undefined || to === undefined || from === to)
+                    continue;
+                const key = `${from} ${to}`;
+                const pair = pairs.get(key) ?? pairs.set(key, { from, to, edges: 0, contracts: new Set() }).get(key);
+                pair.edges++;
+                for (const flow of carriers.get(`${a} ${b}`))
+                    for (const c of contractsOfFlow(idx, flow))
+                        pair.contracts.add(c);
+            }
+        }
+        const boundaries = [...pairs.entries()].sort(([a], [b]) => (a < b ? -1 : 1))
+            .map(([, p]) => ({ ...p, contracts: [...p.contracts].sort() }));
+        const shared = members.filter((m) => (chainsOf.get(m)?.size ?? 0) > 1);
+        // Importe und Uebergaben: nur an Gliedern, die allein dieser Kette gehoeren; die andere Seite
+        // des Flusses ist mindestens eine FUNC und kein Glied (ein ACTOR ist Ein-/Ausgang, kein Ort).
+        const own = members.filter((m) => !shared.includes(m));
+        const foreign = (ends) => {
+            const funcs = ends.filter((id) => idx.typeOf(id) === 'FUNC');
+            return funcs.length > 0 && !funcs.some((f) => inChain.has(f));
+        };
+        const at = (flows, farEnds) => own.flatMap((func) => [...new Set(flows(func))].sort()
+            .filter((flow) => foreign(farEnds(flow))).map((flow) => ({ flow, func })));
+        return {
+            ...who,
+            measurable: true,
+            length,
+            branching,
+            moduleBoundaries: allocated ? boundaries.reduce((n, p) => n + p.edges, 0) : null,
+            feedbackLoops: loops.length,
+            sharedFuncs: shared.length,
+            bottlenecks: shared.filter((m) => inDegree.has(m) && next.get(m).size > 0).length,
+            syncDepth: null,
+            errorPathDepth: null,
+            memberCount: members.length,
+            fanIn: Math.max(0, ...inDegree.values()),
+            loops,
+            shared,
+            boundaries: allocated ? boundaries : null,
+            imports: at(flowsInto, (flow) => idx.in(flow, 'io').map((t) => t.source)),
+            handovers: at(flowsOutOf, (flow) => idx.out(flow, 'io').map((t) => t.target)),
+        };
+    });
+    const measurable = chains.filter((c) => c.measurable).length;
+    return ChainMetrics.parse({
+        chains,
+        measurability: { chains: chains.length, measurable, ratio: chains.length > 0 ? measurable / chains.length : null },
+    });
+}

package/dist/se/conformance-rules.d.ts

@@ -17,6 +17,7 @@
 import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
 import type { RuleSeverity, RuleViolation } from './rules.js';
+import type { RuleRole, RuleStage } from './readiness.js';
 /** Parser facts about one source file (extracted by the executor). */
 export declare const FileFactsSchema: z.ZodObject<{
     exists: z.ZodBoolean;
@@ -67,6 +68,9 @@ export interface ConformanceRuleDefinition {
     id: string;
     name: string;
     severity: RuleSeverity;
+    /** CR-SM-395: Stufe und Rolle wie an jeder Katalogregel (`RuleDefinition`). */
+    stage: RuleStage;
+    role?: RuleRole;
     /**
      * CR-SM-305: die Grundgesamtheit, ueber die die Regel meldet — dieselbe Bedeutung wie an
      * jeder Katalogregel (CR-SM-235), damit RC in `ALL_RULE_DEFS` stehen kann, ohne dass ein

package/dist/se/conformance-rules.js

@@ -17,6 +17,7 @@
 import { z } from 'zod/v4';
 import { readTestRefs, readRealRef } from './ontology.js';
 import { CLOSED_STATUS } from './cr-quality-rules.js';
+import { whenDue } from './rule-due.js';
 /** Parser facts about one source file (extracted by the executor). */
 export const FileFactsSchema = z.object({
     /** File exists on disk (repo-relative path). */
@@ -83,7 +84,7 @@ export const CodeFactsSchema = z.object({
 });
 const missingFile = (facts, file) => facts.files[file]?.exists !== true;
 // RC-01: every valid FUNC realRef must resolve — file on disk, symbol declared in
-// it. Presence is R-20's concern (incl. concept/external/decomposition-parent
+// it. Presence is R-20's concern (incl. external/decomposition-parent
 // exemptions, CR-GC-244); RC-01 only judges bindings that exist. `lang:'prompt'`
 // is realized by a skill file — file-exists is the whole binding. A realRef with
 // no `symbol` (CR-228) is also file-only: resolution stops at file-exists.
@@ -92,7 +93,7 @@ function codeRefMustResolve(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'FUNC')
             continue;
-        if (el.attributes?.concept === true || el.attributes?.external === true)
+        if (el.attributes?.external === true)
             continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound')
@@ -136,8 +137,6 @@ function testRefMustResolve(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'TEST')
             continue;
-        if (el.attributes?.concept === true)
-            continue;
         const parsed = readTestRefs(el.attributes);
         if (parsed.state !== 'bound')
             continue; // no/invalid binding → R-19 territory
@@ -172,7 +171,7 @@ function testRefMustResolve(graph, facts) {
 }
 // RC-03: every valid SCHEMA realRef must resolve — file on disk, symbol declared
 // in it (CR-211, unified CR-228). Presence (a SCHEMA with NO realRef) is the
-// concern of the R-26 presence rule, not RC-03; concept/external SCHEMAs are exempt
+// concern of the R-26 presence rule, not RC-03; external SCHEMAs are exempt
 // there and here. Severity error, like RC-01: a bound-but-broken schema IS a defect.
 // A symbol-less realRef stops at file-exists. Fires 0× until realRefs exist.
 function schemaRefMustResolve(graph, facts) {
@@ -180,7 +179,7 @@ function schemaRefMustResolve(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'SCHEMA')
             continue;
-        if (el.attributes?.concept === true || el.attributes?.external === true)
+        if (el.attributes?.external === true)
             continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound')
@@ -274,7 +273,7 @@ function boundToNonZod(facts, ref) {
 // but NONE of their realRef files import AND parse (`.parse`/`.safeParse`) the
 // schema symbol, the modelled validation is missing. Severity warn (the parse may
 // legitimately sit in a framework layer, not the FUNC's own file). Skips when the
-// SCHEMA is concept-only, has no realRef (or a symbol-less one), or no io-connected
+// SCHEMA has no realRef (or a symbol-less one), or no io-connected
 // realized FUNC. `external` is NOT exempt (CR-SM-318, ITEM-2026-064): an external SCHEMA
 // with a realRef is a foreign-API contract held as a Zod schema in OUR code — the
 // boundary to the foreign system is exactly where that parse belongs.
@@ -284,8 +283,6 @@ function schemaRefMustBeUsed(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'SCHEMA')
             continue;
-        if (el.attributes?.concept === true)
-            continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
             continue;
@@ -308,7 +305,7 @@ function schemaRefMustBeUsed(graph, facts) {
                     (actual.length > 0 ? ` — it is parsed in: ${actual.join(', ')}` : ''),
                 fix_hint: actual.length > 0
                     ? `The parse sits in ${actual.join(', ')}: point the FUNC realRef at that file, or move the parse into the modelled FUNC`
-                    : `Import and call ${ref.symbol}.parse()/.safeParse() in one of the io-connected FUNC's code files — or mark the SCHEMA concept:true if no code realizes it yet`,
+                    : `Import and call ${ref.symbol}.parse()/.safeParse() in one of the io-connected FUNC's code files`,
                 context: { element_type: el.type, element_name: el.name },
             });
         }
@@ -490,8 +487,7 @@ function externalRefMustNameDependency(graph, facts) {
     const known = new Set(declared);
     const violations = [];
     for (const el of graph.elements) {
-        // `concept: true` has no binding that could rot — a concept node claims nothing about code.
-        if (el.attributes?.external !== true || el.attributes?.concept === true)
+        if (el.attributes?.external !== true)
             continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound')
@@ -523,8 +519,12 @@ function externalRefMustNameDependency(graph, facts) {
 //      directory;
 //   2. an OPEN file with no node — an open CR the graph cannot see. The missing node has no
 //      element to carry the finding, so it anchors at the first SYS (sorted, Gate 5); without
-//      a SYS the branch is silent — R-17 already reports that graph.
+//      a SYS the branch is silent — R-33 already reports that graph.
 // A node WITHOUT a file is not reported: that is history (archived CRs, pre-docs/cr numbering).
+//
+// CR-SM-396: stage 10 (plan), not 12. The rule needs the ORDERS and the directory, not a binding —
+// it holds always, also in a draft: an open CR file without a node must be reported before the
+// build is opened, not after. Its findings hold the mark Bau like every finding of stages 10–12.
 // ---------------------------------------------------------------------------
 function crNodeMatchesFile(graph, facts) {
     const crFiles = facts.crFiles;
@@ -585,8 +585,6 @@ function schemaRefMustBeZod(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'SCHEMA')
             continue;
-        if (el.attributes?.concept === true)
-            continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
             continue;
@@ -620,8 +618,6 @@ function schemaParsedOnlyAtInterface(graph, facts) {
     for (const el of graph.elements) {
         if (el.type !== 'SCHEMA')
             continue;
-        if (el.attributes?.concept === true)
-            continue;
         const parsed = readRealRef(el.attributes);
         if (parsed.state !== 'bound' || parsed.value.symbol === undefined)
             continue;
@@ -660,7 +656,7 @@ function schemaParsedOnlyAtInterface(graph, facts) {
 // 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.
+// second count. `external` is exempt — the same exemption 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.
 // ---------------------------------------------------------------------------
@@ -673,7 +669,7 @@ function modMustBeResolvable(graph, facts) {
         .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 &&
+        e.attributes?.external !== true &&
         !(typeof e.attributes?.path === 'string' && e.attributes.path.length > 0) &&
         !resolvedByFunc.has(e.id));
     if (blind.length === 0)
@@ -685,22 +681,31 @@ function modMustBeResolvable(graph, facts) {
         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`,
+        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":…}\`)`,
         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 },
-    { id: 'RC-03', name: 'SCHEMA realRef resolves to a declared export', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaRefMustResolve },
-    { id: 'RC-04', name: 'SCHEMA realRef is parsed at its interface', severity: 'warning', domain: ['SCHEMA'], evaluate: schemaRefMustBeUsed },
-    { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', domain: ['MOD'], evaluate: importDriftConformance },
-    { id: 'RC-06', name: 'external realRef names a declared dependency', severity: 'warning', domain: ['FUNC', 'MOD', 'SCHEMA'], evaluate: externalRefMustNameDependency },
-    { 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 },
-];
+// CR-SM-395: Stufe 12 — der Abgleich ist faellig, sobald der Bau eroeffnet ist (s. rule-due.ts).
+// Zwei Regeln warten nicht auf den Bau und liegen deshalb auf Stufe 10, der letzten Stufe, deren
+// Faelligkeit die `domain` ist; ihre Befunde halten weiter die Marke Bau:
+//   - RC-07 (CR-SM-396) braucht die Auftraege und `docs/cr`, keine Bindung.
+//   - RC-05 (CR-SM-397, Entscheidung des Autors 2026-10-06) braucht Module und den Import-Graphen.
+//     Ein Modul ist schon ueber `path` aufloesbar, ohne Bindung und ohne Auftrag. Die Stufenregel
+//     ergaebe 7 (Modul) — dort hielte eine Warnung KEINE Marke mehr (nur Fehler und Existenz-Regeln
+//     halten vor TRR). Stufe 10 ist die benannte Ausnahme: der Befund bleibt ein Befund des Baus.
+//     Ohne `importEdges` und ohne aufloesbares Modul schweigt die Regel von selbst.
+export const CODE_CONFORMANCE_RULES = whenDue([
+    { id: 'RC-01', name: 'FUNC realRef resolves to a declared symbol', severity: 'warning', stage: 12, domain: ['FUNC'], evaluate: codeRefMustResolve },
+    { id: 'RC-02', name: 'testRefs entries resolve to runnable tests', severity: 'warning', stage: 12, domain: ['TEST'], evaluate: testRefMustResolve },
+    { id: 'RC-03', name: 'SCHEMA realRef resolves to a declared export', severity: 'warning', stage: 12, domain: ['SCHEMA'], evaluate: schemaRefMustResolve },
+    { id: 'RC-04', name: 'SCHEMA realRef is parsed at its interface', severity: 'warning', stage: 12, domain: ['SCHEMA'], evaluate: schemaRefMustBeUsed },
+    { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', stage: 10, domain: ['MOD'], evaluate: importDriftConformance },
+    { id: 'RC-06', name: 'external realRef names a declared dependency', severity: 'warning', stage: 12, domain: ['FUNC', 'MOD', 'SCHEMA'], evaluate: externalRefMustNameDependency },
+    { id: 'RC-07', name: 'CR node agrees with docs/cr', severity: 'warning', stage: 10, domain: ['CR', 'SYS'], evaluate: crNodeMatchesFile },
+    { id: 'RC-08', name: 'SCHEMA realRef is a Zod schema', severity: 'warning', stage: 12, domain: ['SCHEMA'], evaluate: schemaRefMustBeZod },
+    { id: 'RC-09', name: 'SCHEMA is parsed only at its modelled interface', severity: 'warning', stage: 12, domain: ['SCHEMA'], evaluate: schemaParsedOnlyAtInterface },
+    { id: 'RC-10', name: 'MOD has resolvable files', severity: 'warning', stage: 12, domain: ['MOD'], evaluate: modMustBeResolvable },
+]);
 /** Run all RC rules against a graph + extracted code facts. */
 export function evaluateConformanceRules(graph, facts) {
     return CODE_CONFORMANCE_RULES.flatMap((rule) => rule.evaluate(graph, facts));

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

@@ -1,4 +1,3 @@
-import { readRealRef } from './ontology.js';
 // ---------------------------------------------------------------------------
 // CR-R01: ein offener CR nennt, WAS er aendert (CR-SM-295)
 //
@@ -179,89 +178,18 @@ 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 = [
-    { id: 'CR-R01', name: 'CR must track', severity: 'warning', evaluate: crMustTrack, domain: ['CR'] },
-    { id: 'CR-R02', name: 'Done requires commit', severity: 'warning', evaluate: crDoneRequiresCommit, domain: ['CR'] },
+    { id: 'CR-R01', name: 'CR must track', severity: 'warning', stage: 10, evaluate: crMustTrack, domain: ['CR'] },
+    { id: 'CR-R02', name: 'Done requires commit', severity: 'warning', stage: 10, evaluate: crDoneRequiresCommit, domain: ['CR'] },
     // CR-SM-243: domain ist 'all', nicht CR — die Regel meldet am getrackten ZIELKNOTEN
     // ("dieser Knoten wird von 2 offenen CRs angefasst"), und der kann jeden Typ haben. Eine
     // Aufzaehlung waere eine Momentaufnahme der heute getrackten Typen, kein Modell; 'all'
     // (= alle Elemente) ist die einzige Menge, aus der der Zielknoten garantiert stammt.
     // 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'] },
+    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', stage: 'immer', evaluate: noConcurrentMutation, domain: ['all'] },
+    { id: 'MS-03', name: 'CR without milestone', severity: 'info', stage: 10, evaluate: crShouldHaveMilestone, domain: ['CR'] },
 ];
 // 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

@@ -5,13 +5,13 @@
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation } from './rules.js';
 import type { MetricPolicy } from './policy.js';
+import { type MarkType, type RuleRole, type RuleStage } from './readiness.js';
 /**
  * All prescribed rule definitions (single source of truth for the catalog).
  *
  * CR-SM-235: `domain` reicht mit durch — die Grundgesamtheit, ueber die eine Regel feuert.
- * Konsumenten, die einen Anteil bilden (`se-steering`s `computeApplicable`), lesen den Nenner
- * hier statt eine eigene Tabelle zu fuehren. Eine zweite Tabelle kann nicht hinterherhinken,
- * wenn es keine zweite gibt.
+ * Die Faelligkeit (`isDue`) liest sie hier statt eine eigene Tabelle zu fuehren. Eine zweite
+ * Tabelle kann nicht hinterherhinken, wenn es keine zweite gibt.
  */
 /** Profile groupings — see CATALOGS. */
 export type ProfileId = 'default' | 'se' | 'coding' | 'conformance';
@@ -22,6 +22,10 @@ export declare const ALL_RULE_DEFS: ReadonlyArray<{
     domain: readonly string[];
     /** CR-SM-285: das Profil reist mit der Regel, statt aus ihrer ID geraten zu werden. */
     profile: Exclude<ProfileId, 'default'>;
+    /** CR-SM-395: Stufe und Rolle von der Regeldefinition; `mark` ist daraus BERECHNET (`null` bei `'immer'`). */
+    stage: RuleStage;
+    role?: RuleRole;
+    mark: MarkType | null;
 }>;
 export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RULE_DEFS;
 /**