@sigloch/contracts 11.0.0 → 12.0.0

package/dist/se/readiness.d.ts

@@ -1,47 +1,12 @@
 /**
- * CR-120: Readiness dimension schemas for dynamic phase readiness.
- * Dimensions emerge from graph state — no state machine.
+ * Stufen, Marken und Arbeitsschritte der Steuerung, dazu der Vertrag des Steuerungsraums.
  * CR-SM-395: the phase axis is no longer a table. Each rule carries its stage; the mark
  * (SRR/PDR/CDR/TRR/Bau) is derived from it — see "Stufen und Marken" below.
+ * CR-SM-401: die Dimension ist entfallen (Entscheidung des Autors 2026-10-07: „Stufe statt
+ * Dimension, Befunde zaehlen statt Prozent"). Es gibt EINE Einteilung der Regeln, die Stufe; die
+ * Zahl der Befunde je Stufe liefert `countByStage` in @sigloch/graphcode-client.
  */
 import { z } from 'zod/v4';
-export declare const ReadinessDimension: z.ZodEnum<{
-    req: "req";
-    uc: "uc";
-    arch: "arch";
-    alloc: "alloc";
-    ver: "ver";
-    schema: "schema";
-    cr: "cr";
-    ms: "ms";
-}>;
-export type ReadinessDimensionType = z.infer<typeof ReadinessDimension>;
-export declare const ReadinessScore: z.ZodObject<{
-    dimension: z.ZodEnum<{
-        req: "req";
-        uc: "uc";
-        arch: "arch";
-        alloc: "alloc";
-        ver: "ver";
-        schema: "schema";
-        cr: "cr";
-        ms: "ms";
-    }>;
-    score: z.ZodNullable<z.ZodNumber>;
-    violations: z.ZodNumber;
-    applicable: z.ZodNumber;
-    coreApplicable: z.ZodNumber;
-}, z.core.$strip>;
-export type ReadinessScoreType = z.infer<typeof ReadinessScore>;
-/**
- * CR-SM-237: `overallScore` ist weg. Es war das **ungewichtete** Mittel der acht
- * Dimensions-Scores — `ms` (3 Regeln) zählte so viel wie `arch` (~20 Regeln über Hunderte
- * Elemente), die Zahl bewegte sich also mit dem Größenverhältnis der Dimensionen und nicht mit
- * dem Zustand des Modells. Gelesen hat sie ohnehin niemand: der einzige Zugriff in der Familie
- * war eine Formprüfung (`'overallScore' in x`) im inzwischen gelöschten `weight-vector.ts`.
- * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
- * Konsumenten hat — nicht auf Vorrat.
- */
 /**
  * CR-SM-337 (ITEM-2026-059) — der STEUERUNGSRAUM im Bericht, Stufe 1: der Vertrag.
  *
@@ -87,71 +52,6 @@ export declare const SteerSpace: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SteerSpaceType = z.infer<typeof SteerSpace>;
-export declare const ReadinessReport: z.ZodObject<{
-    scores: z.ZodArray<z.ZodObject<{
-        dimension: z.ZodEnum<{
-            req: "req";
-            uc: "uc";
-            arch: "arch";
-            alloc: "alloc";
-            ver: "ver";
-            schema: "schema";
-            cr: "cr";
-            ms: "ms";
-        }>;
-        score: z.ZodNullable<z.ZodNumber>;
-        violations: z.ZodNumber;
-        applicable: z.ZodNumber;
-        coreApplicable: z.ZodNumber;
-    }, z.core.$strip>>;
-    timestamp: z.ZodISODateTime;
-    steer: z.ZodOptional<z.ZodObject<{
-        worst: z.ZodNumber;
-        worstAt: z.ZodNullable<z.ZodObject<{
-            ruleId: z.ZodString;
-            elementId: z.ZodString;
-        }, z.core.$strip>>;
-        mean: z.ZodNumber;
-        score: z.ZodNumber;
-        measured: z.ZodNumber;
-        terms: z.ZodArray<z.ZodObject<{
-            ruleId: z.ZodString;
-            elementId: z.ZodString;
-            value: z.ZodNumber;
-            threshold: z.ZodNumber;
-            overshoot: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type ReadinessReportType = z.infer<typeof ReadinessReport>;
-/**
- * CR-SM-305 — welche Profile in die readiness-Zahlen eingehen, und warum `conformance` nicht.
- *
- * Der Nenner jeder Dimension ist `Σ (Elemente der Grundgesamtheit)` ueber die Regeln der
- * Dimension (`readiness-compute.ts`). Eine Regel, die DEKLARIERT, aber nicht AUSGEWERTET wird,
- * traegt damit zum Nenner bei und liefert null Verstoesse — der Score STEIGT, weil eine
- * Pruefung nicht gelaufen ist. Dieselbe Fail-open-Klasse wie ND-01/02 vor CR-SM-286, nur an der
- * Stelle, die am lautesten gelesen wird.
- *
- * Gemessen ueber vier Familien-Repos, was die sechs RC-Regeln in `arch`/`ver`/`schema`
- * geschenkt haetten: graph-view-edit `schema` +5,0 Punkte (Nenner 24 → 40), graphify `arch`
- * +2,1 und `ver` +1,8, alles Uebrige ≤ 0,2. Der Ausschlag sitzt genau dort, wo die Zahl am
- * meisten wiegt — in der kleinen Dimension.
- *
- * Deshalb steht keine RC-ID in `RULE_TO_DIMENSION`. Das ist keine Luecke,
- * sondern die Aussage „nicht ausgewertet, also weder Zaehler noch Nenner";
- * `computeApplicable` ueberspringt eine Regel ohne Dimension bereits von selbst
- * (`if (!dim) continue`). Sichtbar wird RC ueber die Ableitung `ALL_RULE_DEFS minus
- * ausgewertet` beim Host: sechs Regeln, die als NICHT GEPRUEFT dastehen, solange kein Lauf
- * `CodeFacts` mitbringt.
- */
-export declare const READINESS_SCORED_PROFILES: readonly ["se", "coding"];
-/**
- * Rule → dimension mapping. Some rules belong to multiple dimensions;
- * here we assign primary dimension per rule. R-01 appears in 'ver' (primary)
- * since its core concern is test verification coverage.
- */
-export declare const RULE_TO_DIMENSION: Record<string, ReadinessDimensionType>;
 /** Die Menge je Stufe, Index = Stufe − 1. */
 export declare const STAGE_SETS: readonly ["System", "Anwendungsfall", "Anforderung", "Wirkkette", "Funktion", "Datenfluss", "Modul", "Schema", "Test", "Plan", "Bindung", "Abgleich"];
 /** 1–12, oder `'immer'` fuer die Regeln ueber alle Elemente (R-08, R-18, CR-R03). */
@@ -185,8 +85,6 @@ export declare function markOfStage(stage: RuleStage): MarkType | null;
  *
  *   - Risiko-Anforderungen (FM-01..03), Auftraege und Meilensteine (CR-R01..03, MS-01..03): keine
  *     Elemente, kein Befund.
- *   - Variantenvergleich und Annahmen-Review (TR-01, IR-01): melden erst, wenn die Analyse
- *     gestempelt ist.
  *   - Betriebsarten (CL-01): einzeln geprueft — die Regel laeuft ueber ACTOR, die es im Kern gibt,
  *     meldet aber erst, wenn ein UC eine `operatingMode` traegt. Die setzt nur das Einsatzkonzept.
  *   - Bindung und Abgleich (Stufen 11 und 12): nicht faellig, bis der Bau eroeffnet ist (`isDue`).
@@ -206,9 +104,5 @@ export declare const TASK_OWNED_RULES: Readonly<Partial<Record<Exclude<RuleTask,
 export declare const TASK_ENTRY: Readonly<Record<Exclude<RuleTask, 'kern'>, string | null>>;
 /** Der Eigentuemer einer Regel — der Kern, wenn kein Task sie beansprucht. */
 export declare function taskOf(ruleId: string): RuleTask;
-/** The 8 RULE_TO_DIMENSION topic scores (req/uc/arch/alloc/ver/schema/cr/ms). */
-export declare const DIMENSION_READINESS_NAME = "dimension_readiness";
 /** The marks derived from the rule stage (SRR/PDR/CDR/TRR/Bau). */
 export declare const PHASE_READINESS_NAME = "phase_readiness";
-/** Best-of-N ranking KPI: candidate dimension_readiness minus baseline. */
-export declare const DIMENSION_READINESS_DELTA_NAME = "dimension_readiness_delta";

package/dist/se/readiness.js

@@ -1,60 +1,12 @@
 /**
- * CR-120: Readiness dimension schemas for dynamic phase readiness.
- * Dimensions emerge from graph state — no state machine.
+ * Stufen, Marken und Arbeitsschritte der Steuerung, dazu der Vertrag des Steuerungsraums.
  * CR-SM-395: the phase axis is no longer a table. Each rule carries its stage; the mark
  * (SRR/PDR/CDR/TRR/Bau) is derived from it — see "Stufen und Marken" below.
+ * CR-SM-401: die Dimension ist entfallen (Entscheidung des Autors 2026-10-07: „Stufe statt
+ * Dimension, Befunde zaehlen statt Prozent"). Es gibt EINE Einteilung der Regeln, die Stufe; die
+ * Zahl der Befunde je Stufe liefert `countByStage` in @sigloch/graphcode-client.
  */
 import { z } from 'zod/v4';
-export const ReadinessDimension = z.enum([
-    'req', // Requirements quality (BQ-01..07, RD-01..03)
-    'uc', // UC completeness (UC-01..06, R-14, FC-01..04)
-    'arch', // Functional architecture (R-02, R-03, R-10, R-12)
-    'alloc', // Module allocation (R-04)
-    'ver', // Test coverage (R-01, R-05)
-    'schema', // Interface completeness (R-26 binding, SC-02 usage)
-    'cr', // CR traceability (CR-R01..R03)
-    'ms', // Milestone planning (MS-01..02)
-]);
-export const ReadinessScore = z.object({
-    dimension: ReadinessDimension,
-    /**
-     * `1 - (violations / applicable)` — oder **`null`**, wenn die Dimension nicht messbar ist:
-     * nichts wurde geprueft (`applicable === 0`, CR-SM-395 — vorher 0,0) oder die Kernmenge ist
-     * leer (`coreApplicable === 0`, CR-SM-270).
-     *
-     * `null` heisst nie 0 %, so wie schon bei `graph_metrics` (CR-GC-326): "a value that is not
-     * measurable is not zero percent". Der Anlass war die Gegenrichtung — ein Modell ohne einen
-     * einzigen Use Case meldete `uc: 0,997, ready: true`, weil 306 FUNC ueber eine einzige
-     * Fremdtyp-Regel (FC-03) den Nenner fuellten, waehrend die dreizehn Regeln, die wirklich Use
-     * Cases pruefen, nichts zu pruefen hatten und ihr SCHWEIGEN sich als Erfolg las. Der Score
-     * zeigte damit in die falsche Richtung: je mehr importierte FUNCs ein Repo ohne Wozu-Ebene
-     * hat, desto reifer sah seine uc-Readiness aus.
-     */
-    score: z.number().min(0).max(1).nullable(),
-    violations: z.number().int(),
-    applicable: z.number().int(),
-    /**
-     * CR-SM-270: die Kernmenge der Dimension — die Elemente der Typen, die die MEHRHEIT ihrer
-     * Regeln prueft (uc → UC/FCHAIN/ACTOR, arch → FUNC/MOD). Ist sie 0, ist `score` `null`.
-     *
-     * Sie steht im Bericht, weil sonst niemand das `null` erklaeren kann: `applicable` allein
-     * unterscheidet "nichts zu pruefen" (0) nicht von "nur Fremdtypen" (307). Genau die
-     * Unterscheidung, an der der dokumentierte Ausweg aus CR-SM-237 gescheitert ist.
-     */
-    coreApplicable: z.number().int(),
-    // CR-SM-310: kein `ready` mehr. Ob eine Dimension zu schwach ist, urteilt der Konsument mit
-    // SEINER Schwelle (graphcode: generate.ts, focusThreshold aus der Config). Die Messung traegt
-    // kein Urteil — vorher stand es zweimal: hier als `ready` und beim Konsumenten.
-});
-/**
- * CR-SM-237: `overallScore` ist weg. Es war das **ungewichtete** Mittel der acht
- * Dimensions-Scores — `ms` (3 Regeln) zählte so viel wie `arch` (~20 Regeln über Hunderte
- * Elemente), die Zahl bewegte sich also mit dem Größenverhältnis der Dimensionen und nicht mit
- * dem Zustand des Modells. Gelesen hat sie ohnehin niemand: der einzige Zugriff in der Familie
- * war eine Formprüfung (`'overallScore' in x`) im inzwischen gelöschten `weight-vector.ts`.
- * Ein interpretierbarer Ersatz (`1 − Σviolations / Σapplicable`) kommt, wenn er einen
- * Konsumenten hat — nicht auf Vorrat.
- */
 /**
  * CR-SM-337 (ITEM-2026-059) — der STEUERUNGSRAUM im Bericht, Stufe 1: der Vertrag.
  *
@@ -108,119 +60,6 @@ export const SteerSpace = z.object({
     /** Die Terme je Element, aus denen `worst` und `mean` entstehen. */
     terms: z.array(SteerTerm),
 });
-export const ReadinessReport = z.object({
-    scores: z.array(ReadinessScore),
-    timestamp: z.iso.datetime(),
-    /**
-     * CR-SM-337: OPTIONAL, damit ein aelterer Produzent gueltig bleibt — der Vertrag wandert vor
-     * dem Fueller (Stufe 2, graphcode CR-GC-537). Fehlt das Feld, heisst das "dieser Produzent
-     * kennt den Steuerungsraum noch nicht", und das ist etwas anderes als `measured: 0`.
-     */
-    steer: SteerSpace.optional(),
-});
-/**
- * CR-SM-305 — welche Profile in die readiness-Zahlen eingehen, und warum `conformance` nicht.
- *
- * Der Nenner jeder Dimension ist `Σ (Elemente der Grundgesamtheit)` ueber die Regeln der
- * Dimension (`readiness-compute.ts`). Eine Regel, die DEKLARIERT, aber nicht AUSGEWERTET wird,
- * traegt damit zum Nenner bei und liefert null Verstoesse — der Score STEIGT, weil eine
- * Pruefung nicht gelaufen ist. Dieselbe Fail-open-Klasse wie ND-01/02 vor CR-SM-286, nur an der
- * Stelle, die am lautesten gelesen wird.
- *
- * Gemessen ueber vier Familien-Repos, was die sechs RC-Regeln in `arch`/`ver`/`schema`
- * geschenkt haetten: graph-view-edit `schema` +5,0 Punkte (Nenner 24 → 40), graphify `arch`
- * +2,1 und `ver` +1,8, alles Uebrige ≤ 0,2. Der Ausschlag sitzt genau dort, wo die Zahl am
- * meisten wiegt — in der kleinen Dimension.
- *
- * Deshalb steht keine RC-ID in `RULE_TO_DIMENSION`. Das ist keine Luecke,
- * sondern die Aussage „nicht ausgewertet, also weder Zaehler noch Nenner";
- * `computeApplicable` ueberspringt eine Regel ohne Dimension bereits von selbst
- * (`if (!dim) continue`). Sichtbar wird RC ueber die Ableitung `ALL_RULE_DEFS minus
- * ausgewertet` beim Host: sechs Regeln, die als NICHT GEPRUEFT dastehen, solange kein Lauf
- * `CodeFacts` mitbringt.
- */
-export const READINESS_SCORED_PROFILES = ['se', 'coding'];
-/**
- * Rule → dimension mapping. Some rules belong to multiple dimensions;
- * here we assign primary dimension per rule. R-01 appears in 'ver' (primary)
- * since its core concern is test verification coverage.
- */
-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-04 is decomposition *breadth* — an architecture concern, not a requirement one
-    'RD-04': 'arch',
-    // CR-SM-311: die Untergrenze derselben Breite — ebenfalls Architektur
-    'RD-05': 'arch',
-    // trace/realization/allocation completeness rules (CR-228 D: previously unmapped → advisory fall-through)
-    'R-18': 'arch', 'R-19': 'ver', 'R-20': 'arch', 'R-21': 'ver',
-    // CR-SM-231: R-29 (Testdatei-Exklusivitaet) gehoert zu 'ver' wie R-19 — beide bewerten die
-    // Evidenz-Bindung einer Abnahme, R-19 ihre Praesenz, R-29 ihre Eindeutigkeit.
-    'R-29': 'ver',
-    'R-22': 'alloc', 'R-23': 'alloc', 'R-26': 'schema', 'R-32': 'ver',
-    // CR-SM-395: die Existenz-Regel des Systems. R-33 prueft den Graphen (kein Gruppen-Score).
-    'R-33': 'uc',
-    // CR-GC-366: R-30 (Wirkketten-Bindung) und R-31 (io-Verdrahtung) bewerten beide, ob ein
-    // Funktionsblock ueberhaupt im Bauplan haengt — dieselbe Dimension wie R-20 (realRef).
-    // NICHT 'uc': R-14..R-17 fragen, ob ein Behaelter gefuellt ist;
-    // diese beiden fragen von der FUNC aus, ob sie angeschlossen ist.
-    'R-30': 'arch', 'R-31': 'arch',
-    // uc
-    'UC-01': 'uc', 'UC-02': 'uc', 'UC-03': 'uc', 'UC-04': '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',
-    'FC-05': 'uc', // CR-SM-363: Zusammenhang der Kette — dieselbe Dimension wie FC-04
-    // arch
-    'R-02': 'arch', 'R-10': 'arch', 'R-12': 'arch',
-    // alloc
-    'R-04': 'alloc',
-    // ver
-    'R-01': 'ver', 'R-05': 'ver',
-    // schema
-    'SC-02': 'schema', // SC-01/SC-03 deleted (BOK-CR-026) — R-26 is the binding rule
-    // SC-04 entfiel mit CR-SM-271: FLOW ohne SCHEMA ist jetzt Grammatik (R-18-Bein, error)
-    // und zaehlt damit unter R-18/'arch' statt als eigene 'schema'-Zeile.
-    // structural rules without primary dimension → assigned by closest concern
-    'R-08': 'arch',
-    // near-duplicate detection
-    'ND-01': 'arch', 'ND-02': 'schema',
-    // architecture metrics
-    // MT-03 is no longer here: it became a measurement (`allocationCohesion`), not a
-    // rule (CR-SM-223) — a per-module advisory would depress this score permanently.
-    'MT-01': 'alloc', 'MT-02': 'alloc',
-    // CR-SM-327: MT-04 misst die FUNC-Whitebox, nicht das Modul — Grundgesamtheit FUNC,
-    // also `arch` (Kern FUNC). In `alloc` waere sie eine Fremdtyp-Regel und wuerde deren
-    // Nenner um jede FUNC des Graphen aufblaehen (Klasse CR-SM-235/270, gemessen im CR).
-    'MT-04': 'arch',
-    // CR traceability
-    'CR-R01': 'cr', 'CR-R02': 'cr', 'CR-R03': 'cr', // architecture optimization
-    // CR-SM-283: BW-02 (Whitebox-Randbreite) ersetzt AO-D03 an dieser Stelle — dieselbe
-    // Dimension, denn beide fragen nach der Struktur des Funktionsschnitts, nicht nach Evidenz.
-    'BW-02': 'arch',
-    // allocation rules (CR-191)
-    'CR-01': 'arch', // milestone planning
-    'MS-01': 'ms', 'MS-02': 'ms', 'MS-03': 'ms',
-    // FMEA / risk
-    '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/397: die Anforderungen des Annahmen-Reviews existieren — 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
-    'NFR-01': 'arch',
-    // cross-module IO (CR-192)
-    'IO-01': 'arch',
-    'IO-02': 'arch', // CR-SM-307: Flusstopologie, dieselbe Dimension wie R-10/IO-01.
-    // view rules (CR-184)
-    'VR-01': 'ver',
-    'CL-01': 'uc',
-};
 // ---------------------------------------------------------------------------
 // Stufen und Marken (CR-SM-395) — die Reihenfolge der Mengen.
 //
@@ -257,8 +96,6 @@ export function markOfStage(stage) {
  *
  *   - Risiko-Anforderungen (FM-01..03), Auftraege und Meilensteine (CR-R01..03, MS-01..03): keine
  *     Elemente, kein Befund.
- *   - Variantenvergleich und Annahmen-Review (TR-01, IR-01): melden erst, wenn die Analyse
- *     gestempelt ist.
  *   - Betriebsarten (CL-01): einzeln geprueft — die Regel laeuft ueber ACTOR, die es im Kern gibt,
  *     meldet aber erst, wenn ein UC eine `operatingMode` traegt. Die setzt nur das Einsatzkonzept.
  *   - Bindung und Abgleich (Stufen 11 und 12): nicht faellig, bis der Bau eroeffnet ist (`isDue`).
@@ -294,9 +131,5 @@ export function taskOf(ruleId) {
 // Sprachregelung (CR-SM-226) — naming SSOT so graphcode/graph-view-edit/
 // article render the same terms instead of re-inventing string literals.
 // ---------------------------------------------------------------------------
-/** The 8 RULE_TO_DIMENSION topic scores (req/uc/arch/alloc/ver/schema/cr/ms). */
-export const DIMENSION_READINESS_NAME = 'dimension_readiness';
 /** The marks derived from the rule stage (SRR/PDR/CDR/TRR/Bau). */
 export const PHASE_READINESS_NAME = 'phase_readiness';
-/** Best-of-N ranking KPI: candidate dimension_readiness minus baseline. */
-export const DIMENSION_READINESS_DELTA_NAME = 'dimension_readiness_delta';

package/dist/se/rule-due.d.ts

@@ -2,21 +2,12 @@ import type { OntologyGraph } from './ontology.js';
 import type { RuleStage } from './readiness.js';
 import type { RuleViolation } from './rules.js';
 /**
- * Gibt es einen offenen BAUAUFTRAG — einen CR mit `status: open`, aus dem Code entsteht? Er muss
- * nicht auf die Elemente zeigen.
+ * Gibt es einen offenen Auftrag — einen CR mit `status: open`? Er muss nicht auf die Elemente zeigen.
  *
- * CR-SM-396 (Entscheidung des Autors 2026-10-06): ein reiner ENTSCHEIDUNGS-CR zaehlt nicht. Der
- * Variantenvergleich haelt sein Ergebnis als CR fest; solange nur solche offen sind, ist nichts
- * beauftragt — der Entwurf bliebe sonst mit dem ersten Variantenvergleich „im Bau" und truege die
- * ganze Bindung als Arbeitsliste. Die uebrigen Analysen hinterlassen gar keinen CR, sondern
- * Anforderungen mit Test (CR-SM-397); Bauauftraege entstehen nur im Bauplan.
- *
- * Das Merkmal ist die Kante, die den CR zur Entscheidung macht: eine ausgehende
- * `relation [label: decides]` (SP-1; TR-01 verlangt sie an jedem CR eines Variantenvergleichs).
- * Kein neues Attribut. Nicht `architectureOnly`: das traegt heute kein offener CR, nur die
- * verworfenen Optionen. Nicht „Umfang auf FUNC/MOD/SCHEMA": ein Entscheidungs-CR zeigt daneben
- * mit gewoehnlichen Kanten auf das, was er betrifft, und ein Bauauftrag fuer eine Anforderung am
- * Modul traegt seine Kante an der REQ (CR-SM-343).
+ * CR-SM-400 (Entscheidung des Autors 2026-10-07): ein offener CR IST ein Bauauftrag. Eine
+ * Entscheidung — das Ergebnis einer Analyse oder Optimierung — ist ein ERLEDIGTER Auftrag und
+ * eroeffnet deshalb keinen Bau. Der Filter auf `relation [label: decides]` (CR-SM-396) ist ohne
+ * Ersatz entfallen.
  */
 export declare function hasOpenOrder(graph: OntologyGraph): boolean;
 /** Ist die Regel an diesem Graphen faellig — ist ihre Menge nicht leer? */

package/dist/se/rule-due.js

@@ -5,7 +5,7 @@
  * leer ist. Fuer die Stufen 1 bis 10 ist die Menge die `domain` der Regel — eine Regel ueber eine
  * leere Menge schweigt von selbst, dort ist nichts zu bauen. Fuer die Stufen 11 (Bindung) und 12
  * (Abgleich Modell gegen Code) ist die Menge der BAU: er ist eroeffnet, sobald es einen offenen
- * BAUAUFTRAG gibt (`hasOpenOrder` — ein offener Entscheidungs-CR ist keiner) oder irgendeine
+ * AUFTRAG gibt (`hasOpenOrder` — eine Entscheidung ist ein erledigter Auftrag) oder irgendeine
  * Bindung. Vorher ist die Regel NICHT AUSGEWERTET — nicht bestanden.
  *
  * Zwei Leser, eine Funktion:
@@ -23,26 +23,15 @@
 import { readRealRef, readTestRefs } from './ontology.js';
 import { toEvaluableGraph } from './flat-graph.js';
 /**
- * Gibt es einen offenen BAUAUFTRAG — einen CR mit `status: open`, aus dem Code entsteht? Er muss
- * nicht auf die Elemente zeigen.
+ * Gibt es einen offenen Auftrag — einen CR mit `status: open`? Er muss nicht auf die Elemente zeigen.
  *
- * CR-SM-396 (Entscheidung des Autors 2026-10-06): ein reiner ENTSCHEIDUNGS-CR zaehlt nicht. Der
- * Variantenvergleich haelt sein Ergebnis als CR fest; solange nur solche offen sind, ist nichts
- * beauftragt — der Entwurf bliebe sonst mit dem ersten Variantenvergleich „im Bau" und truege die
- * ganze Bindung als Arbeitsliste. Die uebrigen Analysen hinterlassen gar keinen CR, sondern
- * Anforderungen mit Test (CR-SM-397); Bauauftraege entstehen nur im Bauplan.
- *
- * Das Merkmal ist die Kante, die den CR zur Entscheidung macht: eine ausgehende
- * `relation [label: decides]` (SP-1; TR-01 verlangt sie an jedem CR eines Variantenvergleichs).
- * Kein neues Attribut. Nicht `architectureOnly`: das traegt heute kein offener CR, nur die
- * verworfenen Optionen. Nicht „Umfang auf FUNC/MOD/SCHEMA": ein Entscheidungs-CR zeigt daneben
- * mit gewoehnlichen Kanten auf das, was er betrifft, und ein Bauauftrag fuer eine Anforderung am
- * Modul traegt seine Kante an der REQ (CR-SM-343).
+ * CR-SM-400 (Entscheidung des Autors 2026-10-07): ein offener CR IST ein Bauauftrag. Eine
+ * Entscheidung — das Ergebnis einer Analyse oder Optimierung — ist ein ERLEDIGTER Auftrag und
+ * eroeffnet deshalb keinen Bau. Der Filter auf `relation [label: decides]` (CR-SM-396) ist ohne
+ * Ersatz entfallen.
  */
 export function hasOpenOrder(graph) {
-    const g = toEvaluableGraph(graph);
-    const decisions = new Set(g.traces.filter((t) => t.type === 'relation' && t.label === 'decides').map((t) => t.source));
-    return g.elements.some((e) => e.type === 'CR' && e.attributes?.status === 'open' && !decisions.has(e.id));
+    return toEvaluableGraph(graph).elements.some((e) => e.type === 'CR' && e.attributes?.status === 'open');
 }
 const BUILD_OPEN = new WeakMap();
 /**

package/dist/se/rule-help.d.ts

@@ -12,7 +12,7 @@
  * ## Was hier NICHT steht
  *
  * - **Abgeleitetes** — Titel, Severity, Meldung und `fix_hint` stehen an der Regeldefinition
- *   (`ALL_RULE_DEFS`), die Dimensions-/Phasenzuordnung in `readiness.ts`. Kein Wort davon wird
+ *   (`ALL_RULE_DEFS`), ebenso Stufe und Marke. Kein Wort davon wird
  *   hier wiederholt; ein zweiter Speicher derselben Wahrheit laeuft auseinander.
  * - **`fix_hint` gegen `plain`/`se`** — `fix_hint` ist die Anweisung an den AGENTEN („Add a
  *   `verify` trace"), `plain`/`se` die Erklaerung fuer den MENSCHEN („was ist hier eigentlich

package/dist/se/rule-help.js

@@ -12,7 +12,7 @@
  * ## Was hier NICHT steht
  *
  * - **Abgeleitetes** — Titel, Severity, Meldung und `fix_hint` stehen an der Regeldefinition
- *   (`ALL_RULE_DEFS`), die Dimensions-/Phasenzuordnung in `readiness.ts`. Kein Wort davon wird
+ *   (`ALL_RULE_DEFS`), ebenso Stufe und Marke. Kein Wort davon wird
  *   hier wiederholt; ein zweiter Speicher derselben Wahrheit laeuft auseinander.
  * - **`fix_hint` gegen `plain`/`se`** — `fix_hint` ist die Anweisung an den AGENTEN („Add a
  *   `verify` trace"), `plain`/`se` die Erklaerung fuer den MENSCHEN („was ist hier eigentlich
@@ -209,7 +209,7 @@ export const RULE_HELP = {
     },
     'ND-02': {
         plain: "Two data contracts describe the same thing twice → merge them, or say what distinguishes them.",
-        se: "Near-duplicate `SCHEMA` above 0.85 similarity (name, description, fields and legal trace partners). Partners are filtered through `isValidTrace`: a rule must not reach its verdict via an edge R-18 rejects (CR-SM-286).",
+        se: "Near-duplicate `SCHEMA` above 0.85 similarity (name, description and legal trace partners). Partners are filtered through `isValidTrace`: a rule must not reach its verdict via an edge R-18 rejects (CR-SM-286).",
         vorschlag: 'Führe die doppelten Datenformate {n} zusammen oder grenze sie ab.',
     },
     'NFR-01': {
@@ -435,18 +435,4 @@ export const RULE_HELP = {
         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: die Ausgaenge von Variantenvergleich und Annahmen-Review. Sie melden erst, wenn die
-    // Analyse gestempelt ist — vorher schweigen sie von selbst (CR-SM-395).
-    '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",
-        vorschlag: 'Halte die Entscheidung des Variantenvergleichs für {n} als Änderungsauftrag fest.',
-    },
-    'IR-01': {
-        plain: "The assumption review names a requirement that does not exist → fix the reference or add the requirement with its test; an empty list is fine when no assumption was load-bearing.",
-        se: "Task outcome rule (CR-SM-355, CR-SM-397): every id in `analysisFreshness.assumption-review.reqRefs` resolves to a `REQ` element; empty is a legitimate outcome (low-risk assumptions stay in the record). The verifying `TEST` is R-01's finding. An analysis leaves requirements, never a build order.",
-        prompt: "se-irr",
-        vorschlag: 'Lege die Anforderungen an, die das Annahmen-Review für {n} nennt.',
-    },
 };

package/dist/se/rules.d.ts

@@ -322,14 +322,12 @@ export interface RuleDefinition {
      */
     evaluate: (graph: OntologyGraph, policy: MetricPolicy) => RuleViolation[];
     /**
-     * CR-SM-235: die Grundgesamtheit, ueber die die Regel feuert — der Nenner ihres
-     * Readiness-Anteils. **Der Elementtyp, ueber den sie feuert, nicht das Thema, dem sie
-     * gehoert:** MS-03 („CR ohne Milestone") feuert je CR, nicht je MS.
+     * CR-SM-235: die Grundgesamtheit, ueber die die Regel feuert — die Menge, an der ihre
+     * Faelligkeit haengt (`isDue`). **Der Elementtyp, ueber den sie feuert, nicht das Thema, dem
+     * sie gehoert:** MS-03 („CR ohne Milestone") feuert je CR, nicht je MS.
      *
-     * Pflichtfeld, damit ein neuer Regeleintrag ohne Grundgesamtheit den Build bricht. Vorher
-     * lag die Zuordnung als Handtabelle in einem anderen Paket (`se-steering`), 18 von 71 Regeln
-     * fehlten dort — sie erhoehten den Zaehler, nie den Nenner, und jede neue Regel senkte den
-     * Score automatisch, bis jemand die zweite Tabelle nachzog.
+     * Pflichtfeld, damit ein neuer Regeleintrag ohne Grundgesamtheit den Build bricht. (Bis
+     * CR-SM-401 war sie auch der Nenner eines Prozentwerts je Dimension; den gibt es nicht mehr.)
      *
      * Mehrere Typen, wo die Regel ueber mehrere feuert (RD-04: FUNC, MOD und SYS als Eltern
      * einer Zerlegung). `['all']` = jedes Nicht-SESSION-Element (R-08/R-18 pruefen Traces).
@@ -339,12 +337,6 @@ export interface RuleDefinition {
      * Analyse-Freshness-Stempel (AF-01..05). Sie tragen KEINE
      * Grundgesamtheit bei, denn sie haben keine — der Stempel haengt zwar unter SYS, geprueft
      * wird aber der Graph, nicht das Element.
-     *
-     * Warum das zaehlt: mit `['SYS']` deklariert waren sie eine Ein-Element-Gruppe mit fast
-     * sicherem Verstoss. Eine Dimension ohne eigene Elemente (z. B. `req` in einem Graphen ohne
-     * eine einzige REQ) las dadurch **0 %** statt „nichts zu messen" — und der Executor
-     * fokussierte sie. Ein Graph-Check verfeinert eine Dimension, die es gibt; er erschafft
-     * keine.
      */
     domain: readonly string[];
 }

package/dist/se/similarity.js

@@ -52,14 +52,6 @@ function firstWord(name) {
     return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).find(w => w.length > 0) ?? '';
 }
 const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-/** Feld-Menge eines SCHEMA: `attributes.fields` (Array), sonst Beschreibungs-Token. */
-function schemaFields(el) {
-    const fields = el.attributes?.fields;
-    if (Array.isArray(fields) && fields.length > 0) {
-        return new Set(fields.map(f => String(typeof f === 'object' && f !== null ? (f.name ?? JSON.stringify(f)) : f).toLowerCase()));
-    }
-    return tokens(el.description);
-}
 const CACHE = new WeakMap();
 function build(graph) {
     // ND-01: 0.35*descr_jaccard + 0.25*verb_match + 0.25*io_topology + 0.15*req_overlap
@@ -77,14 +69,16 @@ function build(graph) {
                 + 0.15 * jaccard(fReq[i], fReq[j]))),
     };
     // ND-02: 0.50*field_jaccard + 0.30*descr_jaccard + 0.20*usage_overlap
+    // CR-SM-399: die Feldmenge eines SCHEMA IST seine Beschreibung — das Attribut `fields` (nie
+    // deklariert, 0 Traeger) wird nicht mehr gelesen. Beide Terme bleiben getrennt stehen: zu 0.8
+    // zusammengezogen wiche der Wert in der letzten Stelle ab, und kein Score soll sich bewegen.
     const schemas = graph.elements.filter(e => e.type === 'SCHEMA').sort(byId);
-    const sFields = schemas.map(schemaFields);
     const sDescr = schemas.map(s => tokens(s.description));
     const sUse = schemas.map(s => partners(graph, s.id, ['relation', 'io', 'compose']));
     const schema = {
         ids: schemas.map(s => s.id),
         matrix: schemas.map((_, i) => schemas.map((_, j) => i === j ? 1
-            : 0.5 * jaccard(sFields[i], sFields[j])
+            : 0.5 * jaccard(sDescr[i], sDescr[j])
                 + 0.3 * jaccard(sDescr[i], sDescr[j])
                 + 0.2 * jaccard(sUse[i], sUse[j]))),
     };

package/package.json

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