@sigloch/contracts 3.3.0 → 4.0.0

package/dist/se/ontology.js

@@ -58,25 +58,65 @@ export const RepoRelativePathSchema = z
  * Runnable binding for a TEST element (CR-GC-134, ontology bump 3.4.0).
  * Resolves a TEST node to the concrete artefact a runner can execute, enabling
  * bottom-up selective test deduction (`graph_tests`): change → impacted TESTs →
- * `testRef` → minimal selective run command.
+ * `testRefs` → minimal selective run command.
  *   - `file`  : test file path, e.g. `tests/foo.test.ts` (the runner target).
  *   - `case`  : optional named case/`describe`/`it` block within the file.
  *   - `tool`  : the runner, e.g. `vitest`, `playwright`, `pytest`.
  *   - `level` : optional level, e.g. `unit`, `integration`, `validation`.
- * Stored under `OntologyElement.attributes.testRef` (additive, opt-in validation).
+ *
+ * `tool` steht bewusst **pro Eintrag**, nicht hochgezogen: eine Abnahme mischt real die
+ * Runner — ein TEST kann aus `tests/dashboard.test.mjs` (vitest) *und*
+ * `tests/visual/dashboard-render.spec.mjs` (playwright) bestehen. Ein Runner je TEST-Knoten
+ * wäre eine Lüge, die das alte 1:1-Schema nur deshalb nicht produzierte, weil es die zweite
+ * Datei gar nicht erst zuliess.
  */
 export const TestRefSchema = z.object({
     file: RepoRelativePathSchema,
     case: z.string().optional(),
     tool: z.string(),
     level: z.string().optional(),
+    /**
+     * CR-SM-231b: das Ergebnis haengt **pro Eintrag**, aus demselben Grund wie `tool`.
+     *
+     * Vorher lag `testResult` am TEST-**Knoten**. Mit n Eintraegen ist das mehrdeutig: laeuft eine
+     * Abnahme als vitest *und* playwright, kann ein einzelnes Ergebnis nicht sagen, welcher Lauf
+     * gemeint ist — und „einer rot, einer gruen" ist gar nicht darstellbar. Genau der Zustand,
+     * den ein Gate wissen muss.
+     *
+     * Optional: ein Eintrag ohne Ergebnis ist noch nicht gelaufen, nicht „bestanden". VR-01
+     * meldet das.
+     */
+    result: TestResult.optional(),
+    /** ISO-Zeitstempel des Laufs, der `result` erzeugt hat. Ohne ihn ist ein Ergebnis undatiert. */
+    ranAt: z.iso.datetime().optional(),
+    /** Repo-relativer Pfad zum Lauf-Artefakt (Report, Screenshot, Trace) — die Evidenz zur Aussage. */
+    evidence: RepoRelativePathSchema.optional(),
 });
+/**
+ * CR-SM-231: eine Abnahme, **n** Testdateien — 1:n, nie n:m.
+ *
+ * Vorher war `testRef` ein einzelnes Objekt: ein TEST-Knoten war an genau eine Datei bindbar.
+ * Eine Abnahme aus Unit- *und* Visual-Lauf konnte ihre Evidenz damit nicht vollstaendig
+ * deklarieren, und der Ausweichweg war belegt — dieselbe Spec-Datei stand im `testRef` zweier
+ * TEST-Knoten. Damit war die Relation faktisch n:m: ein roter Lauf war keiner Abnahme mehr
+ * eindeutig zuordenbar, waehrend der TRR-Gate dieselbe Evidenz doppelt zaehlte.
+ *
+ * **Warum n:m hier falsch ist.** n:m zwischen Abnahme und Anforderung ist bereits korrekt
+ * modelliert und in Gebrauch (`TEST -[verify]-> REQ`) — dafuer ist eine Kante da. Die Bindung
+ * an die Laufdatei ist etwas anderes: sie ist **Evidenz-Adresse**, kein Traceability-Link. Sie
+ * gehoert ins Attribut und bleibt 1:n — ein TEST kennt n Dateien, eine Datei gehoert zu
+ * hoechstens einem TEST. Die zweite Haelfte erzwingt R-29.
+ *
+ * Gespeichert unter `OntologyElement.attributes.testRefs`. Das alte `testRef` entfaellt
+ * ersatzlos — kein Union, kein Alias, keine parallelen Pfade.
+ */
+export const TestRefsSchema = z.array(TestRefSchema).min(1);
 /**
  * Realization binding for an element (CR-228, ontology bump 3.9.0) — unifies the
  * byte-identical former `codeRef` (FUNC → code symbol) and `schemaRef` (SCHEMA →
  * Zod export), and extends to MOD (physical part → CAD/geometry artefact). The
  * *type* of the pointing element disambiguates what kind of realization it is:
- * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRef`
+ * FUNC→code, SCHEMA→Zod-def, physical MOD→CAD. TEST keeps its own `testRefs`
  * (a TEST is not just located but *executed* — the runner is the extra value).
  *   - `file`   : realization file path, e.g. `src/harness.ts`, `part.step`.
  *   - `symbol` : the realizing symbol (function/class/Zod export). Optional — a
@@ -181,10 +221,10 @@ export const MODELING_ELEMENT_TYPES = ElementType.options.filter(t => t !== 'SES
  */
 export const ELEMENT_ATTRIBUTES = {
     TEST: [
-        { key: 'testResult', type: 'enum', enumValues: TestResult.options, description: 'Test execution outcome' },
+        // CR-SM-231b: das knotenweite `testResult` ist weg — das Ergebnis haengt pro testRefs-Eintrag.
         { key: 'sourceFile', type: 'string', description: 'Test file path (e.g. tests/foo.test.ts)' },
-        { key: 'testRef', type: 'object', description: 'Runnable binding {file, case?, tool, level?} — see TestRefSchema (CR-GC-134)' },
-        { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRef-binding requirement (CR-GC-205)' },
+        { key: 'testRefs', type: 'array', description: 'Runnable bindings [{file, case?, tool, level?, result?, ranAt?, evidence?}, …] — one acceptance, n test files (1:n), each with its own outcome. See TestRefsSchema (CR-SM-231)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRefs-binding requirement (CR-GC-205)' },
     ],
     REQ: [
         { key: 'severity', type: 'number', description: 'FMEA severity (1-10)' },

package/dist/se/policy.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CR-SM-233: Urteilsschwellen der Architektur-Metriken als Eingabe, nicht als Modulkonstante.
+ *
+ * Vorher stand die Schwelle als `const INSTABILITY_THRESHOLD = 0.7` in `metric-rules.ts`.
+ * Jede Konfigurierbarkeit von außen wäre damit automatisch ein zweiter Pfad gewesen
+ * (Config-Wert neben Code-Default) — und ein stillgelegter Wert hätte still weiterurteilt,
+ * weil der Default einspringt. Deshalb: Parameter ohne Fallback.
+ */
+import { z } from 'zod';
+/**
+ * Urteilsschwellen der Architektur-Metriken. `null` = messen, nicht urteilen.
+ *
+ * `null` ist ein erstklassiger Wert, kein „aus": die Kennzahl wird weiter gerechnet,
+ * exportiert und angezeigt; es entsteht nur kein Verstoß. Das ist die MT-03-Entscheidung
+ * (CR-SM-223) verallgemeinert — der Weg, einen unvalidierten Wert stillzulegen, ohne die
+ * Zahl zu verlieren.
+ */
+export declare const MetricPolicySchema: z.ZodObject<{
+    instability: z.ZodNullable<z.ZodNumber>;
+    lcom4: z.ZodNullable<z.ZodObject<{
+        info: z.ZodNumber;
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
+    crossingFlows: z.ZodNullable<z.ZodObject<{
+        warning: z.ZodNumber;
+    }, z.core.$strip>>;
+    riskRpn: z.ZodNullable<z.ZodNumber>;
+    apTable: z.ZodNullable<z.ZodObject<{
+        severityBands: z.ZodArray<z.ZodObject<{
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+        }, z.core.$strip>>;
+        occurrenceBands: z.ZodArray<z.ZodObject<{
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+        }, z.core.$strip>>;
+        detectionBands: z.ZodArray<z.ZodObject<{
+            from: z.ZodNumber;
+            to: z.ZodNumber;
+        }, z.core.$strip>>;
+        cells: z.ZodArray<z.ZodArray<z.ZodArray<z.ZodEnum<{
+            High: "High";
+            Medium: "Medium";
+            Low: "Low";
+        }>>>>;
+    }, z.core.$strip>>;
+    moduleSize: z.ZodNullable<z.ZodObject<{
+        large: z.ZodNumber;
+        coupled: z.ZodNumber;
+        crossings: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MetricPolicy = z.infer<typeof MetricPolicySchema>;
+/**
+ * Der Startwert, sichtbar als solcher — **kein** Fallback in der Regel.
+ *
+ * Ein Aufrufer nimmt ihn bewusst oder ersetzt ihn; er steht an genau einer Stelle und ist
+ * grep-bar. Die Werte sind die bisherigen (0.7 / 4 / 6-statt-5-Grenze siehe unten) und
+ * ausdrücklich **unvalidiert** (CR-SM-223: „Validation … is deferred") — sie sind gesetzt,
+ * nicht gemessen.
+ *
+ * `lcom4.warning = 6` ist die unveränderte Alt-Semantik: vorher `>= 4 && <= 5` → info,
+ * `> 5` → warning, also warning ab 6.
+ */
+export declare const DEFAULT_METRIC_POLICY: MetricPolicy;

package/dist/se/policy.js

@@ -0,0 +1,100 @@
+/**
+ * CR-SM-233: Urteilsschwellen der Architektur-Metriken als Eingabe, nicht als Modulkonstante.
+ *
+ * Vorher stand die Schwelle als `const INSTABILITY_THRESHOLD = 0.7` in `metric-rules.ts`.
+ * Jede Konfigurierbarkeit von außen wäre damit automatisch ein zweiter Pfad gewesen
+ * (Config-Wert neben Code-Default) — und ein stillgelegter Wert hätte still weiterurteilt,
+ * weil der Default einspringt. Deshalb: Parameter ohne Fallback.
+ */
+import { z } from 'zod';
+import { ApTableSchema } from './action-priority.js';
+/**
+ * Urteilsschwellen der Architektur-Metriken. `null` = messen, nicht urteilen.
+ *
+ * `null` ist ein erstklassiger Wert, kein „aus": die Kennzahl wird weiter gerechnet,
+ * exportiert und angezeigt; es entsteht nur kein Verstoß. Das ist die MT-03-Entscheidung
+ * (CR-SM-223) verallgemeinert — der Weg, einen unvalidierten Wert stillzulegen, ohne die
+ * Zahl zu verlieren.
+ */
+export const MetricPolicySchema = z.object({
+    /** MT-01: Instabilität, ab der gewarnt wird (exklusiv). null → MT-01 feuert nie. */
+    instability: z.number().min(0).max(1).nullable(),
+    /** MT-02: LCOM4-Stufen (info ab, warning ab). null → MT-02 feuert nie. */
+    lcom4: z
+        .object({
+        info: z.number().int().min(2),
+        warning: z.number().int().min(2),
+    })
+        .nullable(),
+    /**
+     * CR-01: kreuzende io-Flows je Modulpaar, ab denen gewarnt wird (inklusiv).
+     *
+     * `null` → CR-01 meldet **nichts**, auch keine info. Das ist der Aus-Zustand, den die Regel
+     * vorher nicht hatte: sie meldete je Modulpaar mit ≥ 1 Kreuzung, und diese info-Fälle zählen
+     * in die `arch`-Dimension ein (CR-SM-236).
+     */
+    crossingFlows: z.object({ warning: z.number().int().min(1) }).nullable(),
+    /**
+     * FM-03: RPN (severity · occurrence · detection), ab dem ein Risiko-REQ eine bestandene
+     * Verifikation braucht (exklusiv). null → FM-03 feuert nie.
+     *
+     * 100 ist Domänenstandard, aber skalenabhängig: bei anderer Belegung von S/O/D ist es die
+     * falsche Grenze.
+     */
+    riskRpn: z.number().int().positive().nullable(),
+    /**
+     * CR-SM-229: die lizenzierte AIAG-VDA-Tabelle, wenn der Host eine hat.
+     *
+     * Sie reist im Policy-Objekt mit, **nicht** in einem zweiten Kontext-Parameter: seit
+     * CR-SM-233 ist `policy` der eine Kanal, über den eine Regel ihre Urteilsgrundlage bekommt.
+     * Ein zweiter daneben wäre genau der parallele Pfad, den der Regelsatz verbietet.
+     *
+     * `null` → der markierte Übergang gilt (bestätigte AP-Invarianten, sonst RPN-Bänder). Der
+     * Konsument lädt die Tabelle aus einer lokalen, nie eingecheckten Datei; **im Repo und im
+     * exportierten Graphen steht sie nie** (Zellwerte sind normative Wertung, keine Fakten).
+     */
+    apTable: ApTableSchema.nullable(),
+    /**
+     * R-04: Modulgröße **gegen** Kreuzungen — die Regel wägt beides ab, ihr alter Name
+     * („Max module size") gab das nicht her. null → R-04 feuert nie.
+     *
+     * Drei Werte, weil die Regel drei Urteile fällt. Ein einzelner Schwellwert hätte zwei davon
+     * im Code gelassen — genau der Zustand, den dieser CR beseitigt.
+     */
+    moduleSize: z
+        .object({
+        /** > `large` FUNCs: mit Kreuzungen warning, ohne Kreuzungen info („kohäsiv, nur groß"). */
+        large: z.number().int().min(1),
+        /** > `coupled` FUNCs ist die Untergrenze, ab der die Regel überhaupt hinsieht. */
+        coupled: z.number().int().min(1),
+        /** Kreuzungen, ab denen ein nur `coupled`-großes Modul warnt (exklusiv). */
+        crossings: z.number().int().min(0),
+    })
+        .nullable(),
+});
+/**
+ * Der Startwert, sichtbar als solcher — **kein** Fallback in der Regel.
+ *
+ * Ein Aufrufer nimmt ihn bewusst oder ersetzt ihn; er steht an genau einer Stelle und ist
+ * grep-bar. Die Werte sind die bisherigen (0.7 / 4 / 6-statt-5-Grenze siehe unten) und
+ * ausdrücklich **unvalidiert** (CR-SM-223: „Validation … is deferred") — sie sind gesetzt,
+ * nicht gemessen.
+ *
+ * `lcom4.warning = 6` ist die unveränderte Alt-Semantik: vorher `>= 4 && <= 5` → info,
+ * `> 5` → warning, also warning ab 6.
+ */
+export const DEFAULT_METRIC_POLICY = {
+    instability: 0.7,
+    lcom4: { info: 4, warning: 6 },
+    // CR-SM-236: die bisherigen Literale, jetzt an einer grep-baren Stelle.
+    // `crossingFlows.warning = 3` ist die unveränderte Alt-Semantik: vorher `count > 2` → warning.
+    crossingFlows: { warning: 3 },
+    riskRpn: 100,
+    // `large`/`coupled`/`crossings` = die drei Literale aus `maxModuleSize`: vorher
+    // `funcCount <= 8` → skip, `funcCount > 12` → groß, `crossings > 2` → gekoppelt.
+    moduleSize: { large: 12, coupled: 8, crossings: 2 },
+    // CR-SM-229: kein Startwert möglich und keiner gewollt — die Tabelle steht nur im Handbook.
+    // `null` heißt hier nicht „aus", sondern „markierter Übergang": bestätigte AP-Invarianten,
+    // sonst RPN-Bänder. `apMethod()` macht das für den Leser sichtbar.
+    apTable: null,
+};

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

@@ -5,6 +5,7 @@
  */
 import type { OntologyGraph } from './ontology.js';
 import type { RuleDefinition, RuleViolation } from './rules.js';
+import type { MetricPolicy } from './policy.js';
 export declare function bq01Unambiguous(graph: OntologyGraph): RuleViolation[];
 export declare function bq02Verifiable(graph: OntologyGraph): RuleViolation[];
 /**
@@ -25,4 +26,4 @@ export declare function bq06Conforming(graph: OntologyGraph): RuleViolation[];
 export declare function bq07Complete(graph: OntologyGraph): RuleViolation[];
 export declare const BQ_RULES: RuleDefinition[];
 /** Run all BQ rules against a graph, returning combined violations. */
-export declare function evaluateBQRules(graph: OntologyGraph): RuleViolation[];
+export declare function evaluateBQRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];

package/dist/se/quality-rules.js

@@ -194,13 +194,15 @@ export function bq07Complete(graph) {
 // Aggregated array & convenience runner
 // ---------------------------------------------------------------------------
 export const BQ_RULES = [
-    { id: 'BQ-01', name: 'Unambiguous', severity: 'warning', evaluate: bq01Unambiguous },
-    { id: 'BQ-02', name: 'Verifiable', severity: 'warning', evaluate: bq02Verifiable },
-    { id: 'BQ-04', name: 'Necessary', severity: 'warning', evaluate: bq04Necessary },
-    { id: 'BQ-06', name: 'Conforming', severity: 'warning', evaluate: bq06Conforming },
-    { id: 'BQ-07', name: 'Complete', severity: 'warning', evaluate: bq07Complete },
+    { id: 'BQ-01', name: 'Unambiguous', severity: 'warning', evaluate: bq01Unambiguous, domain: ['REQ'] },
+    { id: 'BQ-02', name: 'Verifiable', severity: 'warning', evaluate: bq02Verifiable, domain: ['REQ'] },
+    { id: 'BQ-04', name: 'Necessary', severity: 'warning', evaluate: bq04Necessary, domain: ['REQ'] },
+    { id: 'BQ-06', name: 'Conforming', severity: 'warning', evaluate: bq06Conforming, domain: ['REQ'] },
+    { id: 'BQ-07', name: 'Complete', severity: 'warning', evaluate: bq07Complete, domain: ['REQ'] },
 ];
 /** Run all BQ rules against a graph, returning combined violations. */
-export function evaluateBQRules(graph) {
-    return BQ_RULES.flatMap(rule => rule.evaluate(graph));
+// CR-SM-236: `policy` wird durchgereicht, auch wo diese Familie heute keine Schwelle hat —
+// ein Sonderweg je Familie waere genau der zweite Pfad, den der Regelsatz verbietet.
+export function evaluateBQRules(graph, policy) {
+    return BQ_RULES.flatMap(rule => rule.evaluate(graph, policy));
 }

package/dist/se/readiness.d.ts

@@ -36,6 +36,15 @@ export declare const ReadinessScore: z.ZodObject<{
     ready: z.ZodBoolean;
 }, 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.
+ */
 export declare const ReadinessReport: z.ZodObject<{
     scores: z.ZodArray<z.ZodObject<{
         dimension: z.ZodEnum<{
@@ -53,7 +62,6 @@ export declare const ReadinessReport: z.ZodObject<{
         applicable: z.ZodNumber;
         ready: z.ZodBoolean;
     }, z.core.$strip>>;
-    overallScore: z.ZodNumber;
     timestamp: z.ZodISODateTime;
 }, z.core.$strip>;
 export type ReadinessReportType = z.infer<typeof ReadinessReport>;

package/dist/se/readiness.js

@@ -23,11 +23,21 @@ export const ReadinessScore = z.object({
     score: z.number().min(0).max(1), // 1 - (violations / applicable)
     violations: z.number().int(),
     applicable: z.number().int(),
-    ready: z.boolean(), // score >= 0.7
+    // CR-SM-235: `score >= readyThreshold`. Die Schwelle steht bewusst NICHT hier — sie ist
+    // Eingabe von `computeReadiness`, und eine Zahl im Kommentar wäre die dritte Meinung dazu.
+    ready: z.boolean(),
 });
+/**
+ * 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.
+ */
 export const ReadinessReport = z.object({
     scores: z.array(ReadinessScore),
-    overallScore: z.number().min(0).max(1),
     timestamp: z.iso.datetime(),
 });
 /**
@@ -44,6 +54,9 @@ export const RULE_TO_DIMENSION = {
     'RD-04': '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-27': 'arch',
     // CR-SM-226: R-28 Ebenen-Präsenz (>1 FUNC needs FLOW+SCHEMA) is an architecture rule.
     'R-28': 'arch',
@@ -148,6 +161,9 @@ export const RULE_TO_PHASE = {
     'NFR-01': 'CDR',
     // TRR — test readiness.
     'R-01': 'TRR', 'R-05': 'TRR', 'R-19': 'TRR', 'R-20': 'TRR', 'R-21': 'TRR',
+    // 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',
     'VR-01': 'TRR',
     'FM-03': 'TRR',
     'CR-R02': 'TRR',

package/dist/se/rules.d.ts

@@ -5,10 +5,11 @@
  */
 import { z } from 'zod/v4';
 import type { OntologyGraph } from './ontology.js';
+import type { MetricPolicy } from './policy.js';
 export declare const RuleSeverity: z.ZodEnum<{
     error: "error";
-    warning: "warning";
     info: "info";
+    warning: "warning";
 }>;
 export type RuleSeverity = z.infer<typeof RuleSeverity>;
 /** Candidate target for resolving a violation (e.g. a REQ to satisfy, a TEST to link). */
@@ -89,8 +90,8 @@ export declare const RuleViolation: z.ZodObject<{
     rule_id: z.ZodString;
     severity: z.ZodEnum<{
         error: "error";
-        warning: "warning";
         info: "info";
+        warning: "warning";
     }>;
     element_id: z.ZodString;
     message: z.ZodString;
@@ -152,8 +153,27 @@ export interface RuleDefinition {
     id: string;
     name: string;
     severity: 'error' | 'warning' | 'info';
-    evaluate: (graph: OntologyGraph) => RuleViolation[];
+    /**
+     * CR-SM-236: `policy` steht jeder Regel zur Verfuegung, damit eine Urteilsschwelle nirgends
+     * als Literal im Regelcode zurueckbleibt. Regeln ohne Schwelle deklarieren den Parameter
+     * schlicht nicht — eine einstellige Funktion bleibt zuweisbar.
+     */
+    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.
+     *
+     * 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.
+     *
+     * 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).
+     */
+    domain: readonly string[];
 }
 export declare const V3_RULES: RuleDefinition[];
-/** Run all rules against a graph */
-export declare function evaluateRules(graph: OntologyGraph): RuleViolation[];
+/** Run all rules against a graph. CR-SM-236: `policy` ist Pflicht — wie bei `evaluateAllRules`. */
+export declare function evaluateRules(graph: OntologyGraph, policy: MetricPolicy): RuleViolation[];