@sigloch/contracts 10.9.0 → 10.12.0

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

@@ -2,6 +2,7 @@
  * CR-121 P3: Architecture Metrics MT-01..MT-03.
  * Module-level metrics computed from graph structure.
  */
+import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation } from './rules.js';
 import type { MetricPolicy } from './policy.js';
@@ -82,66 +83,24 @@ export interface AllocationCohesion {
  * is deferred (CR-SM-223).
  */
 /** Per-module architecture metrics — the numbers behind MT-01/MT-02 (CR-SM-232). */
-export interface ModuleMetrics {
-    moduleId: string;
-    moduleName: string;
-    /** FUNCs allocated to this module (`FUNC —allocate→ MOD`). */
-    allocatedFuncs: number;
-    /** MT-01 core: coupling. `instability = fanOut / (fanIn + fanOut)`. */
-    fanIn: number;
-    fanOut: number;
-    /** null when fanIn + fanOut === 0 — no signal, no substitute value. */
-    instability: number | null;
-    /**
-     * MT-02 core: connected-component count ueber die BOXEN dieser Modul-Whitebox (CR-SM-326).
-     * `null`, wo nichts zu messen ist: unter zwei Boxen, oder wenn keine einzige Box einen
-     * Vertrag traegt — dann meldet R-31 die unverdrahteten Funktionen am Element, und eine Zahl
-     * hier waere keine Aussage ueber Kohaesion, sondern dieselbe Aussage ein zweites Mal.
-     */
-    lcom4: number | null;
-    /**
-     * CR-SM-326: die Zahl der BOXEN, ueber die `lcom4` gerechnet wurde — Sub-MODs
-     * (`MOD -compose-> MOD`) plus die direkt allozierten FUNC. Sie ist der Nenner der MT-02-Meldung
-     * und NICHT `allocatedFuncs`: ein Eltern-MOD hat Boxen ohne eine einzige eigene Allokation.
-     */
-    lcom4Boxes: number;
-    /**
-     * CR-SM-263: JEDE allozierte FUNC ist ein zerlegter Block (Rollup), das MOD also ein
-     * Container statt eines Implementierungsmoduls.
-     * `false` unterhalb von 2 allozierten FUNCs (kein Container, nur zu klein zum Messen).
-     *
-     * CR-SM-326: seither eine reine MESSUNG. Das Urteil haengt nicht mehr daran — eine Box erbt
-     * die Vertraege ihres Teilbaums, also ist LCOM4 an einem Container genauso aussagekraeftig
-     * wie an einem Implementierungsmodul. Der Wert steht hier, weil er die Lesart der Zeile
-     * erklaert (Bloecke statt Blaetter), nicht weil er etwas stilllegt.
-     */
-    rollupContainer: boolean;
-    /** The CR-SM-223 measurement, deliberately threshold-free. null where contracts omits it. */
-    cohesion: {
-        internal: number;
-        external: number;
-        ratio: number;
-    } | null;
-    /**
-     * CR-SM-301 — Martins *Stable Dependencies Principle*, als MESSUNG und ausdruecklich als
-     * KEINE Regel: die Zahl der Vertraege, die dieses Modul von einem WENIGER stabilen Lieferanten
-     * bezieht (`I_Lieferant > I_Bezieher`). Abhaengigkeiten „bergauf".
-     *
-     * Warum keine Regel: CR-SM-298 hat genau das versucht und ist an Gate 7 gescheitert. Ueber
-     * 19 Familiengraphen laufen 25 von 250 Abhaengigkeiten bergauf, aber der MEDIAN der
-     * Stabilitaetsluecke ist **0.10** — bei einer Vertragsmasse von im Mittel 5 ist das ein
-     * Vertrag Unterschied, also Rauschen. Filtert man auf Luecke > 0.2 und beide Enden >= 3
-     * Vertraege, bleiben 3 von 25, davon zwei in einem Wegwerf-Trial und einer Demo. Eine Regel
-     * haette zwei erfundene Schwellen gebraucht, um EINEN Befund zu produzieren.
-     *
-     * Was bleibt, ist die Zahl. `graph_metrics` traegt sie in jeder Modulzeile, ein Mensch liest
-     * sie neben `instability` und deutet sie — Praezedenz MT-03 (CR-SM-223) und `cohesion` eine
-     * Zeile weiter oben: messen, nicht urteilen, ohne Katalogeintrag und ohne Nenner-Anteil.
-     *
-     * `null`, wo `instability` es auch ist — ohne Kopplung gibt es keine Richtung.
-     */
-    uphillDependencies: number | null;
-}
+export declare const ModuleMetrics: z.ZodObject<{
+    moduleId: z.ZodString;
+    moduleName: z.ZodString;
+    allocatedFuncs: z.ZodNumber;
+    fanIn: z.ZodNumber;
+    fanOut: z.ZodNumber;
+    instability: z.ZodNullable<z.ZodNumber>;
+    lcom4: z.ZodNullable<z.ZodNumber>;
+    lcom4Boxes: z.ZodNumber;
+    rollupContainer: z.ZodBoolean;
+    cohesion: z.ZodNullable<z.ZodObject<{
+        internal: z.ZodNumber;
+        external: z.ZodNumber;
+        ratio: z.ZodNumber;
+    }, z.core.$strip>>;
+    uphillDependencies: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ModuleMetrics = z.infer<typeof ModuleMetrics>;
 /**
  * Per-module architecture metrics as NUMBERS — one row per MOD, threshold or not
  * (CR-SM-232).
@@ -166,7 +125,7 @@ export declare const MT_RULES: readonly [{
 }, {
     readonly id: "MT-02";
     readonly name: "Module cohesion (LCOM4)";
-    readonly severity: "info";
+    readonly severity: "warning";
     readonly evaluate: typeof mt02Lcom4;
     readonly domain: readonly ["MOD"];
 }, {

package/dist/se/metric-rules.js

@@ -1,3 +1,8 @@
+/**
+ * CR-121 P3: Architecture Metrics MT-01..MT-03.
+ * Module-level metrics computed from graph structure.
+ */
+import { z } from 'zod/v4';
 import { decomposedFuncs } from './rules.js';
 import { indexOf } from './graph-index.js';
 import { moduleCrossings, subtreeFuncs, funcSubtree, boxContracts } from './module-crossings.js';
@@ -185,6 +190,87 @@ function connectionPairs(graph) {
     }
     return pairs;
 }
+/**
+ * Allocation cohesion — a **measurement, not a rule** (CR-SM-223, decision 2026-07-29).
+ *
+ * It used to be MT-03 with an 80 % threshold, and it fired on nearly every module of
+ * every real graph: 6 of 7 on graphcode, 4 of 4 on graph-view-edit, 10 of 11 on the
+ * family graph. `CR-SM-221` first suspected the edge definition and made it
+ * FLOW-transitive — the hit rate did not move. The threshold was the miscalibration:
+ * in a flow-routed layered architecture, module interaction crosses boundaries by
+ * design, so "80 % of interaction is internal" describes a monolith, not a healthy
+ * module.
+ *
+ * Rather than fit a cut-off to 11 data points, this reports the number and lets the
+ * architect judge. Returned worst-first, so the head of the list is where to look.
+ * Modules with fewer than two allocated FUNCs, or with no external connection at all,
+ * carry no signal and are omitted.
+ *
+ * Deliberately NOT a `RuleDefinition`: `computeReadiness` counts every violation into
+ * its dimension score regardless of severity, so a per-module advisory would depress
+ * the `alloc` score permanently. A measurement must not masquerade as a defect.
+ *
+ * Validation of this metric — and of MT-01/MT-02, which are thresholded the same way —
+ * is deferred (CR-SM-223).
+ */
+/** Per-module architecture metrics — the numbers behind MT-01/MT-02 (CR-SM-232). */
+// CR-SM-361: ein Zod-Vertrag, kein Typ — gemessen wird einmal je Graph, dort wird geprueft.
+export const ModuleMetrics = z.object({
+    moduleId: z.string(),
+    moduleName: z.string(),
+    /** FUNCs allocated to this module (`FUNC —allocate→ MOD`). */
+    allocatedFuncs: z.number(),
+    /** MT-01 core: coupling. `instability = fanOut / (fanIn + fanOut)`. */
+    fanIn: z.number(),
+    fanOut: z.number(),
+    /** null when fanIn + fanOut === 0 — no signal, no substitute value. */
+    instability: z.number().nullable(),
+    /**
+     * MT-02 core: connected-component count ueber die BOXEN dieser Modul-Whitebox (CR-SM-326).
+     * `null`, wo nichts zu messen ist: unter zwei Boxen, oder wenn keine einzige Box einen
+     * Vertrag traegt — dann meldet R-31 die unverdrahteten Funktionen am Element, und eine Zahl
+     * hier waere keine Aussage ueber Kohaesion, sondern dieselbe Aussage ein zweites Mal.
+     */
+    lcom4: z.number().nullable(),
+    /**
+     * CR-SM-326: die Zahl der BOXEN, ueber die `lcom4` gerechnet wurde — Sub-MODs
+     * (`MOD -compose-> MOD`) plus die direkt allozierten FUNC. Sie ist der Nenner der MT-02-Meldung
+     * und NICHT `allocatedFuncs`: ein Eltern-MOD hat Boxen ohne eine einzige eigene Allokation.
+     */
+    lcom4Boxes: z.number(),
+    /**
+     * CR-SM-263: JEDE allozierte FUNC ist ein zerlegter Block (Rollup), das MOD also ein
+     * Container statt eines Implementierungsmoduls.
+     * `false` unterhalb von 2 allozierten FUNCs (kein Container, nur zu klein zum Messen).
+     *
+     * CR-SM-326: seither eine reine MESSUNG. Das Urteil haengt nicht mehr daran — eine Box erbt
+     * die Vertraege ihres Teilbaums, also ist LCOM4 an einem Container genauso aussagekraeftig
+     * wie an einem Implementierungsmodul. Der Wert steht hier, weil er die Lesart der Zeile
+     * erklaert (Bloecke statt Blaetter), nicht weil er etwas stilllegt.
+     */
+    rollupContainer: z.boolean(),
+    /** The CR-SM-223 measurement, deliberately threshold-free. null where contracts omits it. */
+    cohesion: z.object({ internal: z.number(), external: z.number(), ratio: z.number() }).nullable(),
+    /**
+     * CR-SM-301 — Martins *Stable Dependencies Principle*, als MESSUNG und ausdruecklich als
+     * KEINE Regel: die Zahl der Vertraege, die dieses Modul von einem WENIGER stabilen Lieferanten
+     * bezieht (`I_Lieferant > I_Bezieher`). Abhaengigkeiten „bergauf".
+     *
+     * Warum keine Regel: CR-SM-298 hat genau das versucht und ist an Gate 7 gescheitert. Ueber
+     * 19 Familiengraphen laufen 25 von 250 Abhaengigkeiten bergauf, aber der MEDIAN der
+     * Stabilitaetsluecke ist **0.10** — bei einer Vertragsmasse von im Mittel 5 ist das ein
+     * Vertrag Unterschied, also Rauschen. Filtert man auf Luecke > 0.2 und beide Enden >= 3
+     * Vertraege, bleiben 3 von 25, davon zwei in einem Wegwerf-Trial und einer Demo. Eine Regel
+     * haette zwei erfundene Schwellen gebraucht, um EINEN Befund zu produzieren.
+     *
+     * Was bleibt, ist die Zahl. `graph_metrics` traegt sie in jeder Modulzeile, ein Mensch liest
+     * sie neben `instability` und deutet sie — Praezedenz MT-03 (CR-SM-223) und `cohesion` eine
+     * Zeile weiter oben: messen, nicht urteilen, ohne Katalogeintrag und ohne Nenner-Anteil.
+     *
+     * `null`, wo `instability` es auch ist — ohne Kopplung gibt es keine Richtung.
+     */
+    uphillDependencies: z.number().nullable(),
+});
 /**
  * The one per-module computation (CR-SM-232) — in GRAPH ORDER, unsorted.
  *
@@ -312,6 +398,7 @@ function measureModulesUncached(graph) {
         }
         row.uphillDependencies = uphill;
     }
+    z.array(ModuleMetrics).parse(rows); // CR-SM-361: der Erzeuger prueft seinen Vertrag (einmal je Graph, gecacht)
     return rows;
 }
 /**
@@ -451,7 +538,9 @@ export function allocationCohesion(graph) {
 }
 export const MT_RULES = [
     { id: 'MT-01', name: 'Module instability', severity: 'warning', evaluate: mt01Instability, domain: ['MOD'] },
-    { id: 'MT-02', name: 'Module cohesion (LCOM4)', severity: 'info', evaluate: mt02Lcom4, domain: ['MOD'] },
+    // CR-SM-357: warning — MT-02 ist Steuerregel (STEER_RULES), und eine Steuerregel darf nicht info sein.
+    // Die info-Stufe unterhalb der Schwelle bleibt als Vorwarnung (Masse 0), das Urteil der Regel ist warning.
+    { id: 'MT-02', name: 'Module cohesion (LCOM4)', severity: 'warning', evaluate: mt02Lcom4, domain: ['MOD'] },
     // CR-SM-327: dieselbe Masszahl an der FUNC-Whitebox. Eigene ID, weil die Grundgesamtheit
     // die Readiness-Dimension bestimmt (Begruendung an `mt04WhiteboxLcom4`).
     { id: 'MT-04', name: 'Whitebox cohesion (LCOM4)', severity: 'info', evaluate: mt04WhiteboxLcom4, domain: ['FUNC'] },

package/dist/se/near-duplicate-rules.d.ts

@@ -17,20 +17,20 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleViolation } from './rules.js';
-/** ND-01: FUNC pairs with similarity >= 0.85 -> error. */
+/** ND-01: FUNC pairs with similarity >= 0.85 -> warning. */
 export declare function nd01FuncNearDuplicate(graph: OntologyGraph): RuleViolation[];
-/** ND-02: SCHEMA pairs with similarity >= 0.85 -> error. */
+/** ND-02: SCHEMA pairs with similarity >= 0.85 -> warning. */
 export declare function nd02SchemaNearDuplicate(graph: OntologyGraph): RuleViolation[];
 export declare const ND_RULES: readonly [{
     readonly id: "ND-01";
     readonly name: "FuncNearDuplicate";
-    readonly severity: "error";
+    readonly severity: "warning";
     readonly evaluate: typeof nd01FuncNearDuplicate;
     readonly domain: readonly ["FUNC"];
 }, {
     readonly id: "ND-02";
     readonly name: "SchemaNearDuplicate";
-    readonly severity: "error";
+    readonly severity: "warning";
     readonly evaluate: typeof nd02SchemaNearDuplicate;
     readonly domain: readonly ["SCHEMA"];
 }];

package/dist/se/near-duplicate-rules.js

@@ -9,7 +9,7 @@ function nearDuplicates(graph, sim, ruleId, what, fixHint) {
         const pct = Math.round(similarity * 100);
         return {
             rule_id: ruleId,
-            severity: 'error',
+            severity: 'warning',
             element_id: b,
             message: `${b}${elB?.name ? ' (' + elB.name + ')' : ''} is ${pct}% similar to ${a}${elA?.name ? ' (' + elA.name + ')' : ''} — potential duplicate ${what}`,
             fix_hint: fixHint,
@@ -17,17 +17,17 @@ function nearDuplicates(graph, sim, ruleId, what, fixHint) {
         };
     });
 }
-/** ND-01: FUNC pairs with similarity >= 0.85 -> error. */
+/** ND-01: FUNC pairs with similarity >= 0.85 -> warning. */
 export function nd01FuncNearDuplicate(graph) {
     return nearDuplicates(graph, funcSimilarity(graph), 'ND-01', 'function', 'Merge into single FUNC or differentiate responsibilities');
 }
-/** ND-02: SCHEMA pairs with similarity >= 0.85 -> error. */
+/** ND-02: SCHEMA pairs with similarity >= 0.85 -> warning. */
 export function nd02SchemaNearDuplicate(graph) {
     return nearDuplicates(graph, schemaSimilarity(graph), 'ND-02', 'schema', 'Merge schemas or differentiate field sets');
 }
 export const ND_RULES = [
-    { id: 'ND-01', name: 'FuncNearDuplicate', severity: 'error', evaluate: nd01FuncNearDuplicate, domain: ['FUNC'] },
-    { id: 'ND-02', name: 'SchemaNearDuplicate', severity: 'error', evaluate: nd02SchemaNearDuplicate, domain: ['SCHEMA'] },
+    { id: 'ND-01', name: 'FuncNearDuplicate', severity: 'warning', evaluate: nd01FuncNearDuplicate, domain: ['FUNC'] },
+    { id: 'ND-02', name: 'SchemaNearDuplicate', severity: 'warning', evaluate: nd02SchemaNearDuplicate, domain: ['SCHEMA'] },
 ];
 /** Evaluate all near-duplicate rules. */
 export function evaluateNDRules(graph) {

package/dist/se/ontology.d.ts

@@ -196,6 +196,32 @@ export declare const RealRefSchema: z.ZodObject<{
     lang: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type RealRef = z.infer<typeof RealRefSchema>;
+/**
+ * Was ein Attributvertrag an einem Element aussagt — dreiwertig (CR-SM-360).
+ *
+ * `absent`  : das Attribut fehlt (auch als `null`-Grabstein — Attribute sind nur mergebar).
+ * `invalid` : es ist da, aber verletzt den Vertrag; `error` sagt wie.
+ * `bound`   : es ist da und gueltig.
+ *
+ * Bis hierher parste jeder Leser selbst (25 Stellen in contracts und graphcode), und die Leser
+ * wichen ab: einer meldete ungueltige testRefs, die anderen behandelten „ungueltig" still wie
+ * „fehlt" — die Klasse aus CR-GC-338. Ein Aufrufer, der beides gleich behandeln will, tut das jetzt
+ * sichtbar (`state !== 'bound'`), statt dass der Unterschied beim Parsen verloren geht.
+ */
+export type BindingRead<T> = {
+    state: 'absent';
+} | {
+    state: 'invalid';
+    error: string;
+} | {
+    state: 'bound';
+    value: T;
+};
+type Attributes = Record<string, unknown> | undefined;
+/** Der EINE Leser von `attributes.testRefs` (CR-SM-360). */
+export declare function readTestRefs(attributes: Attributes): BindingRead<TestRefs>;
+/** Der EINE Leser von `attributes.realRef` (CR-SM-360). */
+export declare function readRealRef(attributes: Attributes): BindingRead<RealRef>;
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -222,6 +248,7 @@ export type AnalysisArtifactId = z.infer<typeof AnalysisArtifactId>;
  */
 export declare const AnalysisFreshnessStampSchema: z.ZodObject<{
     graphVersion: z.ZodNumber;
+    crRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type AnalysisFreshnessStamp = z.infer<typeof AnalysisFreshnessStampSchema>;
 /**
@@ -408,3 +435,4 @@ export interface AttributeSpec {
  * the prescribed keys that rules, views, and extractors rely on.
  */
 export declare const ELEMENT_ATTRIBUTES: Partial<Record<ElementType, AttributeSpec[]>>;
+export {};

package/dist/se/ontology.js

@@ -167,6 +167,22 @@ export const RealRefSchema = z.object({
     symbol: z.string().optional(),
     lang: z.string().optional(),
 });
+/** Der EINE Leser von `attributes.testRefs` (CR-SM-360). */
+export function readTestRefs(attributes) {
+    const raw = attributes?.testRefs;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = TestRefsSchema.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
+/** Der EINE Leser von `attributes.realRef` (CR-SM-360). */
+export function readRealRef(attributes) {
+    const raw = attributes?.realRef;
+    if (raw === undefined || raw === null)
+        return { state: 'absent' };
+    const r = RealRefSchema.safeParse(raw);
+    return r.success ? { state: 'bound', value: r.data } : { state: 'invalid', error: r.error.message };
+}
 /**
  * The five judgment-work artifact ids (CR-GC-221's creation keys) that graphcode's
  * skills produce and that a phase gate checks for presence+freshness (CR-SM-227).
@@ -186,6 +202,13 @@ export const AnalysisArtifactId = z.enum(['conops', 'fmea', 'trade', 'implplan',
  */
 export const AnalysisFreshnessStampSchema = z.object({
     graphVersion: z.number().int().nonnegative(),
+    /**
+     * CR-SM-355: die CRs, die aus dem Task hervorgegangen sind (Trade: die Entscheidungs-CRs,
+     * Assumption Review: die promovierten Annahmen). Der Verweis liegt dort, wo der Task endet,
+     * atomar mit dem Stempel; TR-01 / IR-01 pruefen ihn. Optional, weil conops/fmea/implplan keine
+     * Massnahmen-CRs erzeugen.
+     */
+    crRefs: z.array(z.string()).optional(),
 });
 /**
  * Eine benannte Abweichung (CR-SM-349): ein Fund, den der Mensch bewusst offen laesst.

package/dist/se/readiness.js

@@ -151,7 +151,7 @@ export const RULE_TO_DIMENSION = {
     // req
     'BQ-01': 'req', 'BQ-02': 'req', 'BQ-04': 'req',
     'BQ-06': 'req', 'BQ-07': 'req',
-    'RD-01': 'req', 'RD-02': 'req', 'RD-03': 'req',
+    'RD-01': 'req', 'RD-02': 'req',
     // RD-04 is decomposition *breadth* — an architecture concern, not a requirement one
     'RD-04': 'arch',
     // CR-SM-311: die Untergrenze derselben Breite — ebenfalls Architektur
@@ -168,7 +168,6 @@ export const RULE_TO_DIMENSION = {
     'R-30': 'arch', 'R-31': 'arch',
     // uc
     'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': 'uc',
-    'UC-05': 'uc', 'UC-06': 'uc',
     'R-15': 'uc', 'R-16': 'uc', 'R-17': 'uc',
     // FC-04 (CR-SM-226): FCHAIN actor-bounded (trigger+consumer) — same dimension as FC-01..03.
     'FC-02': 'uc', 'FC-03': 'uc', 'FC-04': 'uc',
@@ -206,7 +205,9 @@ export const RULE_TO_DIMENSION = {
     'FM-01': 'req', 'FM-02': 'req', 'FM-03': 'ver',
     // CR-SM-227: analysis-artifact freshness presence — closest topical fit per artifact.
     'AF-01': 'req', 'AF-03': 'req', // ConOps/Assumption-Review: requirements-adjacent judgment work
+    'IR-01': 'req', // CR-SM-355: Annahmen-Review promoviert zu CR — Task-Ausgang von irr
     'AF-02': 'arch', // Trade Study: architecture decision record
+    'TR-01': 'arch', // CR-SM-355: Trade-Entscheidung als CR — Task-Ausgang von trade
     'AF-04': 'ver', // FMEA: risk/verification, same bucket as FM-03
     'AF-05': 'ms', // Implementation Plan: milestone/planning
     // NFR budget
@@ -237,16 +238,19 @@ export const PhaseGate = z.enum(['SRR', 'PDR', 'CDR', 'TRR']);
  * single-owner convention as RULE_TO_DIMENSION.
  */
 export const RULE_TO_PHASE = {
-    // CR-SM-227: Analysis-Freshness-Legs (AF-01..05) — Familie-Review 2026-08-05
-    // gate assignment, final: ConOps/Trade/Assumption-Review → PDR, FMEA → CDR,
-    // Implementation Plan → TRR. SRR gets no analysis-freshness leg.
-    'AF-01': 'PDR', 'AF-02': 'PDR', 'AF-03': 'PDR', // ConOps, Trade Study, Assumption Review
+    // CR-SM-227: Analysis-Freshness-Legs (AF-01..05) — Familie-Review 2026-08-05; revidiert durch
+    // CR-SM-354 (2026-09-22) gegen NASA NPR 7123.1D Appendix G: das Operations Concept ist ein
+    // SRR-Eintrittskriterium (AF-01 → SRR), Integrationsplan und Master Schedule werden zur PDR
+    // baselined (AF-05 → PDR). Trade / Assumption Review PDR und FMEA CDR bleiben.
+    'AF-01': 'SRR', // ConOps
+    'AF-02': 'PDR', 'AF-03': 'PDR', // Trade Study, Assumption Review
     'AF-04': 'CDR', // FMEA
-    'AF-05': 'TRR', // Implementation Plan
+    'AF-05': 'PDR', // Implementation Plan
+    'TR-01': 'PDR', 'IR-01': 'PDR', // CR-SM-355: Task-Ausgaenge von trade / irr — dasselbe Gate wie ihr Eintritt
     // SRR — requirements/scope clarity, system+UC boundary definition.
     'BQ-01': 'SRR', 'BQ-02': 'SRR', 'BQ-04': 'SRR', 'BQ-06': 'SRR', 'BQ-07': 'SRR',
-    'RD-01': 'SRR', 'RD-02': 'SRR', 'RD-03': 'SRR',
-    'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR', 'UC-05': 'SRR', 'UC-06': 'SRR',
+    'RD-01': 'SRR', 'RD-02': 'SRR',
+    'UC-01': 'SRR', 'UC-02': 'SRR', 'UC-03': 'SRR', 'UC-04': 'SRR',
     'R-16': 'SRR', 'R-17': 'SRR',
     'FC-02': 'SRR',
     'CL-01': 'SRR',
@@ -266,11 +270,12 @@ export const RULE_TO_PHASE = {
     'ND-01': 'PDR',
     'BW-02': 'PDR', 'CR-01': 'PDR', 'IO-01': 'PDR', 'IO-02': 'PDR', // CR-SM-226: extended to all FCHAIN FUNC-pairs, added to the phase axis.
     // CDR — critical design/schema completeness.
-    'R-26': 'CDR', 'SC-02': 'CDR', // SC-04 entfiel mit CR-SM-271 — der FLOW-ohne-SCHEMA-Fall haengt an R-18/PDR
+    'SC-02': 'CDR', // SC-04 entfiel mit CR-SM-271 — der FLOW-ohne-SCHEMA-Fall haengt an R-18/PDR
     'ND-02': 'CDR',
     'NFR-01': 'CDR',
     // TRR — test readiness.
     'R-01': 'TRR', 'R-05': 'TRR', 'R-32': 'TRR', 'R-19': 'TRR', 'R-20': 'TRR', 'R-21': 'TRR',
+    'R-26': 'TRR', // CR-SM-354: dieselbe Aussage wie R-20 (Praesenz von Code) — as-built ist TRR, nicht CDR
     // CR-SM-231: eine doppelt beanspruchte Testdatei laesst den TRR-Gate dieselbe Evidenz
     // doppelt zaehlen — der Befund gehoert genau an dieses Gate.
     'R-29': 'TRR',
@@ -294,13 +299,13 @@ export const RULE_TASKS = ['kern', 'conops', 'trade', 'irr', 'fmea', 'plan', 'an
 /** Die Regeln je Task (ohne Kern). Jede Regel hoechstens einmal — der Test haelt das fest. */
 export const TASK_OWNED_RULES = {
     conops: ['CL-01'],
-    trade: [],
-    irr: [],
+    trade: ['TR-01'], // CR-SM-355: Trade-Entscheidung als CR
+    irr: ['IR-01'], // CR-SM-355: Annahmen-Review promoviert zu CR
     fmea: ['FM-01', 'FM-02', 'FM-03'],
     plan: ['MS-01', 'MS-02', 'MS-03', 'CR-R01', 'CR-R02', 'CR-R03'],
     // Annahme (CR-SM-350): BQ bekommt einen eigenen Task, vorerst ohne automatischen Eintrittspunkt.
     anforderungsqualitaet: ['BQ-01', 'BQ-02', 'BQ-04', 'BQ-06', 'BQ-07'],
-    realisierung: ['R-19', 'R-20', 'R-26', 'R-27', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07'],
+    realisierung: ['R-19', 'R-20', 'R-26', 'R-29', 'R-32', 'VR-01', 'RC-01', 'RC-02', 'RC-03', 'RC-04', 'RC-05', 'RC-06', 'RC-07', 'RC-08', 'RC-09'],
 };
 /**
  * Der Eintrittspunkt eines Tasks im Kern: die Regel, die "dieses Artefakt fehlt" sagt. `null` = der

package/dist/se/rule-help.js

@@ -300,7 +300,15 @@ export const RULE_HELP = {
     },
     'RC-07': {
         plain: "A change request is marked done in the model but still open in the folder (or the other way round), or an open change request has no entry in the model → the folder decides; fix the model.",
-        se: "`CR` node whose `status` (closed = done/dropped/rejected) contradicts `docs/cr/open|done/`, or an OPEN CR file with no `CR` node (anchored at the first `SYS`). Nodes without a file are not reported — history. Absent `crFiles` is SILENCE (CR-SM-329).",
+        se: "`CR` node whose `status` (closed = done; CR-SM-362) contradicts `docs/cr/open|done/`, or an OPEN CR file with no `CR` node (anchored at the first `SYS`). Nodes without a file are not reported — history. Absent `crFiles` is SILENCE (CR-SM-329).",
+    },
+    'RC-08': {
+        plain: "A data contract in the model points at a type, which vanishes at runtime → write it as a Zod schema, so whoever produces the data can prove it and whoever reads it can check it.",
+        se: "`SCHEMA` whose `realRef` symbol is declared but is not a Zod schema (extractor field `zodSymbols`). Every producer needs a checkable schema — \"nobody parses it\" only means the reader is not known yet. Absent `zodSymbols` is SILENCE. Owns the type-binding cause: RC-04 stays quiet on such a SCHEMA (CR-SM-358).",
+    },
+    'RC-09': {
+        plain: "Code somewhere reads a data contract on its own, but the model does not know that place → go through the one translator the model names, or add the new translator to the model.",
+        se: "Zod-bound `SCHEMA` parsed (import + `.parse`/`.safeParse`) in a file that is neither its definition nor the `realRef` of a `FUNC` io-connected to a `FLOW` of this SCHEMA. The first code → model check: a second translator of one contract is a parallel path (spike CR-GC-637 — such paths share a contract, they are not similar). One finding per SCHEMA; test files exempt; runs only with `fileScope: 'all'` (CR-SM-358).",
     },
     'RD-01': {
         plain: "A smallest-piece feature has nothing built to fulfil it → add what implements it.",
@@ -311,10 +319,6 @@ export const RULE_HELP = {
         plain: "You split a feature into smaller features but you're also building the big one directly → build only the small pieces, not both.",
         se: "Parent `REQ` (has `compose`→`REQ` children) carrying a direct `FUNC` `satisfy`; the satisfy belongs on the children.",
     },
-    'RD-03': {
-        plain: "You split a feature into pieces, but all the pieces are handled by the same one thing — the split may be pointless → consider merging them.",
-        se: "Parent `REQ` whose children all share one satisfier.",
-    },
     'RD-04': {
         plain: "One thing has more than 9 parts directly under it → group them, so each level stays readable.",
         se: "Decomposition breadth above `metricPolicy.decompositionBreadth.warning` children on one level — `FUNC` `compose` `FUNC`, `SYS` `compose` `MOD`, a `MOD`'s sub-`MOD`s plus its own leaf `FUNC` (`allocate`), and the root `FUNC` forest anchored at `SYS` (CR-SM-282). Default 9, the upper end of 7±2 (CR-SM-296). CR-SM-311: a module level counts its own functions again — breadth, not size; module coupling is R-04. The lower bound is RD-05.",
@@ -347,16 +351,19 @@ export const RULE_HELP = {
         se: "`UC` description shorter than 10 characters or containing TBD/TODO/FIXME/placeholder/XXX. Description IS the goal (CR-150).",
         prompt: "se:author-uc",
     },
-    'UC-05': {
-        plain: "A scenario does not say what must be true once it has finished → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"postcondition\"]`.",
-    },
-    'UC-06': {
-        plain: "A scenario does not say what must be true before it can start → add that as a requirement.",
-        se: "`UC` with no `compose`d `REQ` carrying `kinds:[\"precondition\"]`.",
-    },
     'VR-01': {
         plain: "A test exists but no result was ever recorded, so nobody knows if it passed → record the outcome.",
         se: "`TEST` with no `testResult` attribute — assumed pending, never assumed green.",
     },
+    // CR-SM-355: Task-Ausgaenge — sichtbar nur im Task trade / irr.
+    'TR-01': {
+        plain: "The trade study is stamped, but the decision it produced is not on record as a CR (or the CR it names is missing or carries no decides edge) → record the decision as a CR and list its id in the stamp.",
+        se: "Task outcome rule (CR-SM-355): `analysisFreshness.trade.crRefs` names existing CR elements, each carrying a `relation` edge labelled `decides` (the SP-1 decision record).",
+        prompt: "se-trade",
+    },
+    'IR-01': {
+        plain: "The assumption review names a CR that does not exist → fix the reference or add the CR; an empty list is fine when no assumption was load-bearing.",
+        se: "Task outcome rule (CR-SM-355): every id in `analysisFreshness.assumption-review.crRefs` resolves to a CR element; empty is a legitimate outcome (low-risk assumptions stay in the record).",
+        prompt: "se-irr",
+    },
 };

package/dist/se/rules.js

@@ -4,7 +4,7 @@
  * @sigloch/contracts/se — single source of truth for SE validation rules.
  */
 import { z } from 'zod/v4';
-import { ElementType, TraceType, TestRefsSchema, RealRefSchema } from './ontology.js';
+import { ElementType, TraceType, readTestRefs, readRealRef } from './ontology.js';
 import { traceRejection, admittingAlternatives, isValidTrace, BOUNDED_PATTERNS, REQUIRED_PATTERNS, maxOccurs } from './meta-model.js';
 import { indexOf } from './graph-index.js';
 import { moduleCrossings, subtreeFuncs } from './module-crossings.js';
@@ -663,35 +663,6 @@ function decompositionConsistency(graph) {
         context: { element_type: req.type, element_name: req.name },
     }));
 }
-// ---------------------------------------------------------------------------
-// RD-03: No premature decomposition (all children same satisfy target)
-// ---------------------------------------------------------------------------
-function noPrematureDecomposition(graph) {
-    const idx = indexOf(graph);
-    const reqs = idx.elementsOfType('REQ');
-    const parentReqs = reqs.filter(req => idx.out(req.id, 'compose').some(t => idx.typeOf(t.target) === 'REQ'));
-    return parentReqs
-        .filter(parent => {
-        const childIds = graph.traces
-            .filter(t => t.source === parent.id && t.type === 'compose' &&
-            idx.typeOf(t.target) === 'REQ')
-            .map(t => t.target);
-        if (childIds.length < 2)
-            return false;
-        const satisfyTargets = childIds.map(cid => idx.in(cid, 'satisfy').filter(t => t.source !== cid).map(t => t.source));
-        // All children satisfied by the same single source
-        const allSame = satisfyTargets.every(targets => targets.length === 1 && targets[0] === satisfyTargets[0]?.[0]);
-        return allSame && satisfyTargets[0]?.length === 1;
-    })
-        .map(req => ({
-        rule_id: 'RD-03',
-        severity: 'info',
-        element_id: req.id,
-        message: `${req.id} children all have the same satisfy target — decomposition may be unnecessary`,
-        fix_hint: 'Consider merging sub-REQs back into parent if they share the same verifiable level',
-        context: { element_type: req.type, element_name: req.name },
-    }));
-}
 function breadthCounts(graph) {
     const idx = indexOf(graph);
     // CR-SM-264: `typeOf` und `byId` baute diese Regel je Aufruf selbst — der Index hat beide.
@@ -919,7 +890,7 @@ function msDanglingDependency(graph) {
         .filter(t => !msIds.has(t.target))
         .map(t => ({
         rule_id: 'MS-02',
-        severity: 'error',
+        severity: 'warning',
         element_id: t.source,
         message: `${t.source} depends on non-existent milestone ${t.target}`,
         fix_hint: 'Fix the depends-on relation target to reference an existing MS element',
@@ -1162,7 +1133,7 @@ function testMustHaveRunnableBinding(graph) {
         .filter(e => e.attributes?.concept !== true) // concept-only TESTs are exempt
         // CR-SM-231: `testRefs` (Array, min 1) statt `testRef` (Objekt). Semantik unveraendert —
         // Praesenz und Form, keine Datei-Existenz; die pruefst RC-02.
-        .filter(e => !TestRefsSchema.safeParse(e.attributes?.testRefs).success)
+        .filter(e => readTestRefs(e.attributes).state !== 'bound')
         .map(test => ({
         rule_id: 'R-19',
         severity: 'warning',
@@ -1194,12 +1165,12 @@ function testFileExclusivity(graph) {
     for (const el of graph.elements) {
         if (el.type !== 'TEST')
             continue;
-        const parsed = TestRefsSchema.safeParse(el.attributes?.testRefs);
-        if (!parsed.success)
+        const parsed = readTestRefs(el.attributes);
+        if (parsed.state !== 'bound')
             continue; // keine/ungueltige Bindung → R-19-Gebiet
         // Innerhalb EINES Knotens ist dieselbe Datei zweimal kein Konflikt, sondern eine
         // Redundanz — sie wuerde sonst als Selbstkollision gemeldet.
-        for (const file of new Set(parsed.data.map(r => r.file))) {
+        for (const file of new Set(parsed.value.map(r => r.file))) {
             const owners = claimedBy.get(file) ?? [];
             owners.push(el.id);
             claimedBy.set(file, owners);
@@ -1244,7 +1215,7 @@ function funcMustHaveCodeBinding(graph) {
     const composeFuncChildren = (id) => graph.traces
         .filter(t => t.source === id && t.type === 'compose' && funcById.has(t.target))
         .map(t => t.target);
-    const hasCodeRef = (el) => RealRefSchema.safeParse(el.attributes?.realRef).success;
+    const hasCodeRef = (el) => readRealRef(el.attributes).state === 'bound';
     const isExempt = (el) => el.attributes?.concept === true || el.attributes?.external === true;
     // A FUNC is bound iff it is exempt, has a codeRef, or is a parent whose
     // compose→FUNC children are all bound (recursive, cycle-safe).
@@ -1501,7 +1472,7 @@ function schemaMustHaveSchemaRef(graph) {
     const idx = indexOf(graph);
     return idx.elementsOfType('SCHEMA')
         .filter(e => e.attributes?.concept !== true && e.attributes?.external !== true)
-        .filter(e => !RealRefSchema.safeParse(e.attributes?.realRef).success)
+        .filter(e => readRealRef(e.attributes).state !== 'bound')
         .map(sc => ({
         rule_id: 'R-26',
         severity: 'warning',
@@ -1526,7 +1497,7 @@ function schemaMustHaveContractTest(graph) {
     const tests = idx.elementsOfType('TEST');
     return idx.elementsOfType('SCHEMA')
         .filter(sc => sc.attributes?.concept !== true)
-        .filter(sc => { const r = RealRefSchema.safeParse(sc.attributes?.realRef); return r.success && r.data.symbol !== undefined; })
+        .filter(sc => { const r = readRealRef(sc.attributes); return r.state === 'bound' && r.value.symbol !== undefined; })
         .filter(sc => !graph.traces.some(t => t.type === 'verify' && t.target === sc.id && typeOf.get(t.source) === 'TEST'))
         .map(sc => ({
         rule_id: 'R-32',
@@ -1686,11 +1657,10 @@ export const V3_RULES = [
     { id: 'R-32', name: 'SCHEMA must have contract TEST', severity: 'warning', evaluate: schemaMustHaveContractTest, domain: ['SCHEMA'] },
     { id: 'RD-01', name: 'Unresolved requirement', severity: 'warning', evaluate: unresolvedRequirement, domain: ['REQ'] },
     { id: 'RD-02', name: 'Decomposition consistency', severity: 'warning', evaluate: decompositionConsistency, domain: ['REQ'] },
-    { id: 'RD-03', name: 'No premature decomposition', severity: 'info', evaluate: noPrematureDecomposition, domain: ['REQ'] },
     { id: 'RD-04', name: 'Decomposition breadth', severity: 'warning', evaluate: decompositionBreadth, domain: ['FUNC', 'MOD', 'SYS'] },
     { id: 'RD-05', name: 'Decomposition too narrow', severity: 'warning', evaluate: decompositionNarrow, domain: ['FUNC', 'MOD', 'SYS'] },
     { id: 'MS-01', name: 'Milestone empty scope', severity: 'warning', evaluate: msEmptyScope, domain: ['MS'] },
-    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'error', evaluate: msDanglingDependency, domain: ['MS'] },
+    { id: 'MS-02', name: 'Milestone dangling dependency', severity: 'warning', evaluate: msDanglingDependency, domain: ['MS'] },
     { id: 'R-30', name: 'FUNC leaf must belong to a function chain', severity: 'warning', evaluate: funcMustBeInEffectChain, domain: ['FUNC'] },
     { id: 'R-31', name: 'FUNC must be wired (io input + output)', severity: 'warning', evaluate: funcMustBeWired, domain: ['FUNC'] },
 ];

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

@@ -8,7 +8,5 @@ export declare function uc01HasRequirements(graph: OntologyGraph): RuleViolation
 export declare function uc02HasActor(graph: OntologyGraph): RuleViolation[];
 export declare function uc03HasScenario(graph: OntologyGraph): RuleViolation[];
 export declare function uc04GoalDefined(graph: OntologyGraph): RuleViolation[];
-export declare function uc05HasPostcondition(graph: OntologyGraph): RuleViolation[];
-export declare function uc06HasPrecondition(graph: OntologyGraph): RuleViolation[];
 export declare const UC_RULES: RuleDefinition[];
 export declare function evaluateUCRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];