@sigloch/contracts 10.13.0 → 11.0.0

package/dist/se/analysis-freshness-rules.d.ts

@@ -1,64 +1,98 @@
 /**
- * CR-SM-227: Analysis-Freshness-Legs — the third leg-kind a review gate checks
- * (rule legs, layer-presence legs [R-28, entfallen mit CR-SM-247], now analysis-freshness legs).
- * Presence/Resolution-Split (wie R-19/R-20/R-26/R-27 vs. RC-01..05): these five
- * rules are the PRÜFBARE FORM only — does a `graphVersion` stamp exist for the
- * artifact, as a graph attribute. They never compare the stamp against the
- * live graphVersion (that staleness/currency check is I/O — a consumer
- * concern, `CreationCurrencyProvider` in `@sigloch/graphcode-client`).
+ * CR-SM-227: the analysis rules — was each judgment-work artifact carried out?
+ *
+ * AF-01..04 ask for the stamp `SYS.attributes.analysisFreshness.<artifact>`: its presence is the
+ * only record that the analysis was done (an FMEA may legitimately end without a single risk, so
+ * the result cannot stand in for it). They never compare the stamp against the live graphVersion.
+ *
+ * AF-05 is different since CR-SM-395: the implementation plan is not a stamp but the set of open
+ * CRs. The rule reads "there is something unbuilt, but no open order" and falls due again with
+ * every change — which a one-time stamp could not express.
  */
 import type { OntologyGraph } from './ontology.js';
-import type { RuleViolation } from './rules.js';
+import { type RuleViolation } from './rules.js';
+/**
+ * AF-05 (CR-SM-395): es gibt Ungebautes, aber keinen offenen Auftrag → der Bauplan ist faellig.
+ *
+ * Ungebaut ist, woran die Bindungsregeln melden wuerden (`unbuiltElementIds`: TEST, FUNC, SCHEMA
+ * ohne Bindung, `external` und Zerlegungs-Eltern ausgenommen wie dort). Es reicht, dass EIN offener
+ * Auftrag existiert; er muss nicht auf die Elemente zeigen — ob er die richtigen trifft, zeigt der
+ * Git-Diff. Mit dem Auftrag verstummt diese Regel, und die Bindungsregeln der Stufe 11 werden
+ * faellig: ihre Befunde sind die Arbeitsliste. Beim ersten Bau sind das alle Elemente, bei einer
+ * Aenderung die neuen.
+ *
+ * EIN Befund je Graph, am SYS: dort wird er abgenommen („Bau nicht beauftragt"), und eine Abnahme
+ * je Element waere mit jedem neuen Element wieder offen. Die Meldung nennt die ungebauten Elemente.
+ */
+declare function buildPlanDue(graph: OntologyGraph): RuleViolation[];
 export declare const AF_RULES: readonly [{
     readonly id: "AF-01";
     readonly name: "ConOps freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 3;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-02";
     readonly name: "Trade Study freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 7;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-03";
     readonly name: "Assumption Review freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 7;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-04";
     readonly name: "FMEA freshness stamp present";
     readonly severity: "warning";
+    readonly stage: 8;
+    readonly role: "analysis";
     readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "AF-05";
-    readonly name: "Implementation Plan freshness stamp present";
+    readonly name: "Unbuilt elements have an open CR";
     readonly severity: "warning";
-    readonly evaluate: (graph: OntologyGraph) => RuleViolation[];
+    readonly stage: 10;
+    readonly role: "existence";
+    readonly evaluate: typeof buildPlanDue;
     readonly domain: readonly ["graph"];
 }];
 /** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
 export declare function tradeDecisionRecorded(graph: OntologyGraph): RuleViolation[];
-/** IR-01: every CR named by a stamped assumption review exists; an empty list is a legitimate outcome. */
-export declare function assumptionReviewPromoted(graph: OntologyGraph): RuleViolation[];
-/** CR-SM-355: the task-outcome rules — owned by trade / irr (TASK_OWNED_RULES), never in the kern focus. */
+/**
+ * IR-01 (CR-SM-397): every REQ named by a stamped assumption review exists; an empty list is a
+ * legitimate outcome. That the REQ carries a verifying TEST is R-01's finding, not repeated here.
+ */
+export declare function assumptionReviewRequirementsExist(graph: OntologyGraph): RuleViolation[];
+/** CR-SM-355: the outcome rules of trade / irr — silent until the analysis is stamped. */
 export declare const TASK_OUTCOME_RULES: readonly [{
     readonly id: "TR-01";
     readonly name: "Trade decision recorded as CR";
     readonly severity: "warning";
+    readonly stage: 7;
+    readonly role: "analysis";
     readonly evaluate: typeof tradeDecisionRecorded;
     readonly domain: readonly ["graph"];
 }, {
     readonly id: "IR-01";
-    readonly name: "Assumption review promoted to CR";
+    readonly name: "Assumption review requirements exist";
     readonly severity: "warning";
-    readonly evaluate: typeof assumptionReviewPromoted;
+    readonly stage: 7;
+    readonly role: "analysis";
+    readonly evaluate: typeof assumptionReviewRequirementsExist;
     readonly domain: readonly ["graph"];
 }];
 /** Evaluate the task-outcome rules (CR-SM-355). */
 export declare function evaluateTaskOutcomeRules(graph: OntologyGraph): RuleViolation[];
 /** Evaluate all analysis-freshness-presence rules. */
 export declare function evaluateAFRules(graph: OntologyGraph): RuleViolation[];
+export {};

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

@@ -1,10 +1,45 @@
-import { AnalysisFreshnessStampSchema } from './ontology.js';
+import { readAnalysisStamp } from './ontology.js';
+import { unbuiltElementIds } from './rules.js';
+import { hasOpenOrder } from './rule-due.js';
 const ARTIFACT_LABEL = {
     conops: 'Concept of Operations',
     trade: 'Trade Study',
     'assumption-review': 'Assumption Review',
     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 write each load-bearing one as a REQ with its verifying TEST',
+    },
+    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',
+    },
 };
 /** Presence-check for one analysis artifact's freshness stamp, anchored on SYS. */
 function analysisFreshnessPresence(ruleId, artifactId) {
@@ -12,16 +47,16 @@ function analysisFreshnessPresence(ruleId, artifactId) {
         const sys = graph.elements.find(e => e.type === 'SYS');
         if (!sys)
             return []; // nothing to anchor on yet (vacuous-complete exemption)
-        const stamp = sys.attributes?.analysisFreshness?.[artifactId];
-        if (AnalysisFreshnessStampSchema.safeParse(stamp).success)
+        if (readAnalysisStamp(graph, artifactId).state === 'bound')
             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 },
             }];
     };
@@ -30,36 +65,73 @@ const conopsFreshnessPresent = analysisFreshnessPresence('AF-01', 'conops');
 const tradeFreshnessPresent = analysisFreshnessPresence('AF-02', 'trade');
 const assumptionReviewFreshnessPresent = analysisFreshnessPresence('AF-03', 'assumption-review');
 const fmeaFreshnessPresent = analysisFreshnessPresence('AF-04', 'fmea');
-const implplanFreshnessPresent = analysisFreshnessPresence('AF-05', 'implplan');
+/**
+ * AF-05 (CR-SM-395): es gibt Ungebautes, aber keinen offenen Auftrag → der Bauplan ist faellig.
+ *
+ * Ungebaut ist, woran die Bindungsregeln melden wuerden (`unbuiltElementIds`: TEST, FUNC, SCHEMA
+ * ohne Bindung, `external` und Zerlegungs-Eltern ausgenommen wie dort). Es reicht, dass EIN offener
+ * Auftrag existiert; er muss nicht auf die Elemente zeigen — ob er die richtigen trifft, zeigt der
+ * Git-Diff. Mit dem Auftrag verstummt diese Regel, und die Bindungsregeln der Stufe 11 werden
+ * faellig: ihre Befunde sind die Arbeitsliste. Beim ersten Bau sind das alle Elemente, bei einer
+ * Aenderung die neuen.
+ *
+ * EIN Befund je Graph, am SYS: dort wird er abgenommen („Bau nicht beauftragt"), und eine Abnahme
+ * je Element waere mit jedem neuen Element wieder offen. Die Meldung nennt die ungebauten Elemente.
+ */
+function buildPlanDue(graph) {
+    const sys = graph.elements.find(e => e.type === 'SYS');
+    if (!sys)
+        return []; // kein Anker — R-33 meldet das fehlende System
+    if (hasOpenOrder(graph))
+        return [];
+    const unbuilt = unbuiltElementIds(graph);
+    if (unbuilt.length === 0)
+        return [];
+    const shown = unbuilt.slice(0, 3).join(', ') + (unbuilt.length > 3 ? ` and ${unbuilt.length - 3} more` : '');
+    return [{
+            rule_id: 'AF-05',
+            severity: 'warning',
+            element_id: sys.id,
+            message: `${unbuilt.length} ${unbuilt.length === 1 ? 'element is' : 'elements are'} not built yet (${shown}) and no open CR orders the work — the implementation plan is due`,
+            fix_hint: 'Carry out the Implementation Plan: work through the skill se-plan step by step. First step: cut one CR per leaf REQ at its carrier and group the CRs into MS milestones in dependency order. The open CRs are the plan — with the first one the binding rules list what to build',
+            context: { element_type: sys.type, element_name: sys.name },
+        }];
+}
+// CR-SM-396: AF-01 liegt auf Stufe 3, HINTER den Anforderungen — eine Ausnahme von „Stufe = spaeteste
+// Menge, die die Regel braucht" (das Einsatzkonzept braucht nur die Anwendungsfaelle, Stufe 2).
+// Entscheidung des Autors 2026-10-06: zuerst sagt der Anwendungsfall, was verlangt ist (UC-01), dann
+// folgt die Analyse des Betriebs. In einer Stufe steht die Existenz-Regel vor der Analyse.
 export const AF_RULES = [
-    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', evaluate: conopsFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', evaluate: tradeFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', evaluate: assumptionReviewFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', evaluate: fmeaFreshnessPresent, domain: ['graph'] },
-    { id: 'AF-05', name: 'Implementation Plan freshness stamp present', severity: 'warning', evaluate: implplanFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-01', name: 'ConOps freshness stamp present', severity: 'warning', stage: 3, role: 'analysis', evaluate: conopsFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-02', name: 'Trade Study freshness stamp present', severity: 'warning', stage: 7, role: 'analysis', evaluate: tradeFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-03', name: 'Assumption Review freshness stamp present', severity: 'warning', stage: 7, role: 'analysis', evaluate: assumptionReviewFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-04', name: 'FMEA freshness stamp present', severity: 'warning', stage: 8, role: 'analysis', evaluate: fmeaFreshnessPresent, domain: ['graph'] },
+    { id: 'AF-05', name: 'Unbuilt elements have an open CR', severity: 'warning', stage: 10, role: 'existence', evaluate: buildPlanDue, domain: ['graph'] },
 ];
 /**
- * CR-SM-355: Task-Ausgangsregeln fuer trade und irr — die aus dem Task entstandenen Massnahmen sind
- * als CR dokumentiert. Traeger ist `crRefs` im Frischestempel. Ohne Stempel feuern sie nicht (dann
- * feuert der Eintritt AF-02/AF-03, und der Task ist nicht durch). `label` wird als `Trace.label`
- * gelesen wie bei MS-02 — `decides` ist kein TraceType, sondern das SP-1-Label einer relation-Kante.
+ * Task-Ausgangsregeln fuer trade und irr (CR-SM-355, CR-SM-397): was der Task hinterlassen hat, ist
+ * im Frischestempel genannt und existiert. Ein Variantenvergleich hinterlaesst Entscheidungs-CRs
+ * (`crRefs`, TR-01), ein Annahmen-Review Anforderungen (`reqRefs`, IR-01) — eine Analyse legt keinen
+ * Bauauftrag an. Ohne Stempel feuern die Regeln nicht (dann feuert der Eintritt AF-02/AF-03).
+ * `label` wird als `Trace.label` gelesen wie bei MS-02 — `decides` ist kein TraceType, sondern das
+ * SP-1-Label einer relation-Kante.
  */
-function stampedCrRefs(graph, artifactId) {
+function stampedOutcome(graph, artifactId) {
     const sys = graph.elements.find(e => e.type === 'SYS');
     if (!sys)
         return null;
-    const raw = sys.attributes?.analysisFreshness?.[artifactId];
-    const parsed = AnalysisFreshnessStampSchema.safeParse(raw);
-    if (!parsed.success)
+    const stamp = readAnalysisStamp(graph, artifactId);
+    if (stamp.state !== 'bound')
         return null;
-    return { sys, crRefs: parsed.data.crRefs ?? [] };
+    return { sys, stamp: stamp.value };
 }
 /** TR-01: a stamped trade study names >=1 existing CR, each carrying a relation(label: decides) edge. */
 export function tradeDecisionRecorded(graph) {
-    const stamped = stampedCrRefs(graph, 'trade');
+    const stamped = stampedOutcome(graph, 'trade');
     if (!stamped)
         return [];
-    const { sys, crRefs } = stamped;
+    const { sys } = stamped;
+    const crRefs = stamped.stamp.crRefs ?? [];
     const base = { rule_id: 'TR-01', severity: 'warning', context: { element_type: sys.type, element_name: sys.name } };
     if (crRefs.length === 0) {
         return [{
@@ -82,28 +154,31 @@ export function tradeDecisionRecorded(graph) {
         return [];
     });
 }
-/** IR-01: every CR named by a stamped assumption review exists; an empty list is a legitimate outcome. */
-export function assumptionReviewPromoted(graph) {
-    const stamped = stampedCrRefs(graph, 'assumption-review');
+/**
+ * IR-01 (CR-SM-397): every REQ named by a stamped assumption review exists; an empty list is a
+ * legitimate outcome. That the REQ carries a verifying TEST is R-01's finding, not repeated here.
+ */
+export function assumptionReviewRequirementsExist(graph) {
+    const stamped = stampedOutcome(graph, 'assumption-review');
     if (!stamped)
         return [];
-    const { sys, crRefs } = stamped;
+    const { sys } = stamped;
     const byId = new Map(graph.elements.map(e => [e.id, e]));
-    return crRefs
-        .filter(id => byId.get(id)?.type !== 'CR')
+    return (stamped.stamp.reqRefs ?? [])
+        .filter(id => byId.get(id)?.type !== 'REQ')
         .map(id => ({
         rule_id: 'IR-01',
         severity: 'warning',
         element_id: sys.id,
-        message: `Assumption Review names ${id} as a promoted assumption, but no CR with that id exists`,
-        fix_hint: 'Point analysisFreshness.assumption-review.crRefs at an existing CR, or add the CR through graph_mutate (se-irr)',
+        message: `Assumption Review names ${id} as the requirement of a load-bearing assumption, but no REQ with that id exists`,
+        fix_hint: 'Point analysisFreshness.assumption-review.reqRefs at an existing REQ, or add the REQ with its verifying TEST through graph_mutate (se-irr)',
         context: { element_type: sys.type, element_name: sys.name },
     }));
 }
-/** CR-SM-355: the task-outcome rules — owned by trade / irr (TASK_OWNED_RULES), never in the kern focus. */
+/** CR-SM-355: the outcome rules of trade / irr — silent until the analysis is stamped. */
 export const TASK_OUTCOME_RULES = [
-    { id: 'TR-01', name: 'Trade decision recorded as CR', severity: 'warning', evaluate: tradeDecisionRecorded, domain: ['graph'] },
-    { id: 'IR-01', name: 'Assumption review promoted to CR', severity: 'warning', evaluate: assumptionReviewPromoted, domain: ['graph'] },
+    { id: 'TR-01', name: 'Trade decision recorded as CR', severity: 'warning', stage: 7, role: 'analysis', evaluate: tradeDecisionRecorded, domain: ['graph'] },
+    { id: 'IR-01', name: 'Assumption review requirements exist', severity: 'warning', stage: 7, role: 'analysis', evaluate: assumptionReviewRequirementsExist, domain: ['graph'] },
 ];
 /** Evaluate the task-outcome rules (CR-SM-355). */
 export function evaluateTaskOutcomeRules(graph) {

package/dist/se/ao-rules.js

@@ -260,12 +260,12 @@ export function io01CrossModuleCompleteness(graph) {
     return violations;
 }
 export const AO_RULES = [
-    { id: 'BW-02', name: 'Whitebox boundary width', severity: 'warning', evaluate: bw02WhiteboxWidth, domain: ['FUNC'] },
-    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
+    { id: 'BW-02', name: 'Whitebox boundary width', severity: 'warning', stage: 5, evaluate: bw02WhiteboxWidth, domain: ['FUNC'] },
+    { id: 'CR-01', name: 'CrossingFlowCount', severity: 'warning', stage: 7, evaluate: cr01CrossingFlowCount, domain: ['MOD'] },
     // CR-SM-242: domain ist FUNC, nicht MOD — die Regel laeuft ueber FUNC-Paare in FCHAINs und
     // meldet am FUNC. Mit ['MOD'] uebertraf ihr Zaehler (21) ihren eigenen Nenner-Beitrag (10);
     // nur der Clamp verhinderte einen negativen Score.
-    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', evaluate: io01CrossModuleCompleteness, domain: ['FUNC'] },
+    { id: 'IO-01', name: 'FuncPairIOCompleteness', severity: 'warning', stage: 5, evaluate: io01CrossModuleCompleteness, domain: ['FUNC'] },
 ];
 export function evaluateAORules(graph, policy) {
     return AO_RULES.flatMap(r => r.evaluate(graph, policy));

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