@sigloch/se-engine 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sigloch Consulting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/fix-templates.d.ts

@@ -0,0 +1,24 @@
+import type { OntologyGraph, RuleViolation, TraceType, ElementType } from '@sigloch/contracts/se';
+export interface SuggestedEdit {
+    op: 'add-trace';
+    source: string;
+    target: string;
+    type: TraceType;
+    /** Warum genau dieses Ziel — Fundstelle im Elementtext bzw. Eindeutigkeit. */
+    rationale: string;
+}
+type Element = OntologyGraph['elements'][number];
+type FixTemplate = (v: RuleViolation, g: OntologyGraph) => SuggestedEdit | null;
+/**
+ * Elemente der gegebenen Typen, deren id ODER name (Wortgrenze, ≥3 Zeichen,
+ * case-insensitive) im Text vorkommt. Deterministische Rangfolge:
+ * id-Treffer vor name-Treffer, längerer Name vor kürzerem, dann id-lexikografisch.
+ */
+export declare function mentionedElements(text: string, g: OntologyGraph, types: readonly ElementType[]): Element[];
+export declare const FIX_TEMPLATES: Record<string, FixTemplate>;
+/**
+ * Rule-spezifischer Fix für eine Violation — oder null (Fund-Ebene reicht).
+ * Deterministisch; nie der generische applyRule-Trace.
+ */
+export declare function fixFor(v: RuleViolation, g: OntologyGraph): SuggestedEdit | null;
+export {};

package/dist/fix-templates.js

@@ -0,0 +1,192 @@
+/**
+ * Rule-spezifische Fix-Templates (CR-SM-225, Spike-2-Design-Konsequenz).
+ *
+ * Der Spike-2-Befund (aimpro docs/spike/revisit_suggestions.md): KEIN einziger
+ * generisch synthetisierter Edit war unverändert anwendbar — der generische
+ * applyRule-Trace taugt als Δm-Richtungssonde, nie als auszuliefernder Edit.
+ * Ausgeliefert wird ein Edit nur, wenn ein rule-spezifisches Template ihn aus
+ * dem Elementtext DETERMINISTISCH herleiten kann (Fundstelle = Begründung):
+ *
+ *   - CR-R01: CR ohne relation → relation zu einem IM CR-TEXT genannten
+ *     UC/REQ/FUNC/MOD (Spike: "Relation zu im CR-Text genannten Elementen")
+ *   - CR-R04: CR ohne FUNC → relation zu einer im CR-Text genannten FUNC
+ *   - MS-03 : CR ohne Milestone → relation zur im Text genannten MS,
+ *     sonst zur einzigen MS im Graphen (eindeutig ⇒ herleitbar)
+ *   - UC-02 : UC ohne Akteur → io von einem im UC-TEXT genannten ACTOR
+ *     ("Als Entwickler…" → ACTOR-developer)
+ *
+ * CR-SM-241 ergänzt die ARCHITEKTUR-Operatoren — die einzigen, die auf
+ * `layer: 'arch'` überhaupt etwas bewegen können (CR/MS/UC liegen nicht im
+ * Teilgraphen, also war dort bis dahin jedes Δm = 0):
+ *
+ *   - R-22 : FUNC ohne Modul → allocate zum im FUNC-TEXT genannten MOD,
+ *     sonst zum einzigen MOD im Graphen (eindeutig ⇒ herleitbar)
+ *   - R-23 : MOD ohne allozierte FUNC → allocate von der im MOD-TEXT
+ *     genannten FUNC (kein Eindeutigkeits-Fallback, s. dort)
+ *   - SC-02/SC-04: FLOW ohne Datenvertrag → relation zum im FLOW-TEXT
+ *     genannten SCHEMA, sonst zum einzigen SCHEMA
+ *
+ * Regeln ohne Template (oder Template ohne Fund) liefern null → die Suggestion
+ * bleibt Fund-Ebene (Violation + Richtung + Δm), ohne Edit. Regeln, deren Fix
+ * Element-Erzeugung braucht (FCHAIN, REQ-Pre/Postcondition, TEST), sind mit
+ * additiven Kanten prinzipiell nicht ausdrückbar — bewusst kein Template.
+ */
+import { isValidTrace } from '@sigloch/contracts/se';
+function byId(g, id) {
+    return g.elements.find((e) => e.id === id);
+}
+function hasTrace(g, source, target, type) {
+    return g.traces.some((t) => t.source === source && t.target === target && t.type === type);
+}
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Elemente der gegebenen Typen, deren id ODER name (Wortgrenze, ≥3 Zeichen,
+ * case-insensitive) im Text vorkommt. Deterministische Rangfolge:
+ * id-Treffer vor name-Treffer, längerer Name vor kürzerem, dann id-lexikografisch.
+ */
+export function mentionedElements(text, g, types) {
+    const hits = [];
+    for (const el of g.elements) {
+        if (!types.includes(el.type))
+            continue;
+        const idHit = new RegExp(`(^|[^A-Za-z0-9-])${escapeRe(el.id)}([^A-Za-z0-9-]|$)`, 'i').test(text);
+        const nameHit = el.name.trim().length >= 3 && new RegExp(`\\b${escapeRe(el.name.trim())}\\b`, 'i').test(text);
+        if (idHit || nameHit)
+            hits.push({ el, idHit, nameLen: nameHit ? el.name.trim().length : 0 });
+    }
+    hits.sort((a, b) => Number(b.idHit) - Number(a.idHit) || b.nameLen - a.nameLen || a.el.id.localeCompare(b.el.id));
+    return hits.map((h) => h.el);
+}
+/** relation vom Violation-Element zu einem im Elementtext genannten Ziel-Typ. */
+function relationToMentioned(types) {
+    return (v, g) => {
+        const el = byId(g, v.element_id);
+        if (!el)
+            return null;
+        const text = `${el.name} ${el.description ?? ''}`;
+        for (const target of mentionedElements(text, g, types)) {
+            if (target.id === el.id)
+                continue;
+            if (hasTrace(g, el.id, target.id, 'relation'))
+                continue;
+            if (!isValidTrace({ source: el.type, target: target.type, type: 'relation' }))
+                continue;
+            return {
+                op: 'add-trace',
+                source: el.id,
+                target: target.id,
+                type: 'relation',
+                rationale: `${target.id} ist im Text von ${el.id} genannt`,
+            };
+        }
+        return null;
+    };
+}
+/**
+ * CR-SM-241 — die Architektur-Operatoren. Verallgemeinerung von
+ * `relationToMentioned`: die Kante muss nicht vom Violation-Element ausgehen
+ * (R-23 sitzt am MOD, die legale Kante läuft aber FUNC→MOD), und der Trace-Typ
+ * ist nicht immer `relation`.
+ *
+ * `uniqueFallback` greift NUR, wenn der Text nichts nennt UND es genau einen
+ * Kandidaten des Zieltyps gibt. „Genau einer" ist eine Herleitung, „der erste
+ * von mehreren" wäre geraten — und ein falsch alloziertes FUNC verfälscht
+ * `coherence`/`modifiability`, also genau die Zahlen, auf denen das Ranking sitzt.
+ */
+function edgeToMentioned(opts) {
+    return (v, g) => {
+        const el = byId(g, v.element_id);
+        if (!el)
+            return null;
+        const text = `${el.name} ${el.description ?? ''}`;
+        const mentioned = mentionedElements(text, g, opts.types);
+        const pool = g.elements.filter((e) => opts.types.includes(e.type));
+        const candidates = mentioned.length > 0 ? mentioned : opts.uniqueFallback && pool.length === 1 ? pool : [];
+        for (const other of candidates) {
+            if (other.id === el.id)
+                continue;
+            const source = opts.direction === 'out' ? el : other;
+            const target = opts.direction === 'out' ? other : el;
+            if (hasTrace(g, source.id, target.id, opts.traceType))
+                continue;
+            if (!isValidTrace({ source: source.type, target: target.type, type: opts.traceType }))
+                continue;
+            return {
+                op: 'add-trace',
+                source: source.id,
+                target: target.id,
+                type: opts.traceType,
+                rationale: mentioned.length > 0
+                    ? `${other.id} ist im Text von ${el.id} genannt`
+                    : `${other.id} ist das einzige ${other.type} im Graphen`,
+            };
+        }
+        return null;
+    };
+}
+export const FIX_TEMPLATES = {
+    'CR-R01': relationToMentioned(['UC', 'REQ', 'FUNC', 'MOD']),
+    'CR-R04': relationToMentioned(['FUNC']),
+    // --- Architektur-Operatoren (CR-SM-241) ------------------------------------
+    // Ohne sie hat auf `layer: 'arch'` — graphcodes DEFAULT-Messebene — jeder
+    // Template-Edit Δm = 0, weil CR/MS/UC gar nicht im Teilgraphen liegen.
+    // FUNC ohne Modul → das im FUNC-Text genannte MOD, sonst das einzige MOD.
+    'R-22': edgeToMentioned({ types: ['MOD'], traceType: 'allocate', direction: 'out', uniqueFallback: true }),
+    // MOD ohne allozierte FUNC → das im MOD-Text genannte FUNC. Die Kante läuft
+    // weiterhin FUNC→MOD (einziges legales Muster), der Fund sitzt am MOD.
+    // KEIN uniqueFallback: „das einzige MOD" ist eine Herleitung (das FUNC muss
+    // irgendwohin), „das einzige FUNC" ist keine — ein FUNC darf legitim einem
+    // anderen Modul gehören, und dieses hier hätte dann einfach noch keins.
+    'R-23': edgeToMentioned({ types: ['FUNC'], traceType: 'allocate', direction: 'in' }),
+    // FLOW ohne Datenvertrag → das im FLOW-Text genannte SCHEMA, sonst das einzige.
+    'SC-02': edgeToMentioned({ types: ['SCHEMA'], traceType: 'relation', direction: 'out', uniqueFallback: true }),
+    'SC-04': edgeToMentioned({ types: ['SCHEMA'], traceType: 'relation', direction: 'out', uniqueFallback: true }),
+    'MS-03': (v, g) => {
+        const cr = byId(g, v.element_id);
+        if (!cr)
+            return null;
+        const milestones = g.elements.filter((e) => e.type === 'MS');
+        const mentioned = mentionedElements(`${cr.name} ${cr.description ?? ''}`, g, ['MS']);
+        const ms = mentioned[0] ?? (milestones.length === 1 ? milestones[0] : undefined);
+        if (!ms || hasTrace(g, cr.id, ms.id, 'relation'))
+            return null;
+        if (!isValidTrace({ source: cr.type, target: ms.type, type: 'relation' }))
+            return null;
+        return {
+            op: 'add-trace',
+            source: cr.id,
+            target: ms.id,
+            type: 'relation',
+            rationale: mentioned[0]
+                ? `${ms.id} ist im Text von ${cr.id} genannt`
+                : `${ms.id} ist der einzige Milestone im Graphen`,
+        };
+    },
+    'UC-02': (v, g) => {
+        const uc = byId(g, v.element_id);
+        if (!uc)
+            return null;
+        const actors = mentionedElements(`${uc.name} ${uc.description ?? ''}`, g, ['ACTOR']);
+        for (const actor of actors) {
+            if (hasTrace(g, actor.id, uc.id, 'io'))
+                continue;
+            if (!isValidTrace({ source: actor.type, target: uc.type, type: 'io' }))
+                continue;
+            return {
+                op: 'add-trace',
+                source: actor.id,
+                target: uc.id,
+                type: 'io',
+                rationale: `${actor.id} ist im Text von ${uc.id} genannt`,
+            };
+        }
+        return null;
+    },
+};
+/**
+ * Rule-spezifischer Fix für eine Violation — oder null (Fund-Ebene reicht).
+ * Deterministisch; nie der generische applyRule-Trace.
+ */
+export function fixFor(v, g) {
+    return FIX_TEMPLATES[v.rule_id]?.(v, g) ?? null;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @sigloch/se-engine — SE analysis over a governed graph.
+ *
+ * One package, two surfaces that were separate packages until CR-SM-248:
+ *   metrics/…        the ℝ⁶ metric vector, layer projection, rule apply, suggestions
+ *   readiness-compute the readiness/steering computation
+ *
+ * They were merged because they share exactly one dependency (@sigloch/contracts),
+ * operate on the same graph, and had the same consumers — two packages with one
+ * consumer set is a publish cascade, not a boundary.
+ */
+export * from './metrics.js';
+export * from './readiness-compute.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * @sigloch/se-engine — SE analysis over a governed graph.
+ *
+ * One package, two surfaces that were separate packages until CR-SM-248:
+ *   metrics/…        the ℝ⁶ metric vector, layer projection, rule apply, suggestions
+ *   readiness-compute the readiness/steering computation
+ *
+ * They were merged because they share exactly one dependency (@sigloch/contracts),
+ * operate on the same graph, and had the same consumers — two packages with one
+ * consumer set is a publish cascade, not a boundary.
+ */
+export * from './metrics.js';
+export * from './readiness-compute.js';

package/dist/layer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * CR-AIM-235: Layer-Projektion + Knotengewicht-Producer.
+ *
+ * Reale governte Graphen bestehen zu 70–83 % aus Doku-Knoten (REQ/TEST/CR/MS);
+ * globale Metriken messen die Doku-Topologie, nicht die Architektur (Spike 2,
+ * aimpro docs/spike/revisit_layered.md §A). `projectLayer` liefert den
+ * Architektur-Teilgraphen; `weightNodes` mappt Datei-Massen (LOC, vom Aufrufer
+ * geliefert — metrics() bleibt pur, kein Filesystem-Zugriff) auf Knoten-Ids
+ * über deren realRef/codeRef-Bindung.
+ */
+import type { OntologyGraph } from '@sigloch/contracts/se';
+/** Architektur-Schicht: Struktur- und Schnittstellen-Typen (ohne REQ/TEST/CR/MS/SYS/UC/FCHAIN). */
+export declare const ARCH_TYPES: ReadonlySet<string>;
+export type MetricLayer = 'all' | 'arch';
+/**
+ * Project a graph onto the requested layer. `'all'` returns the graph
+ * unchanged; `'arch'` keeps only ARCH_TYPES elements and the traces whose BOTH
+ * endpoints survive (Doku-Knoten und ihre Traces fallen weg).
+ */
+export declare function projectLayer(graph: OntologyGraph, layer: MetricLayer): OntologyGraph;
+/**
+ * Derive node weights from per-file masses (e.g. LOC) via each element's
+ * realRef/codeRef file binding. Elements without binding or without a mass
+ * entry get no weight (metrics() defaults their mass to 1). When several
+ * elements bind the same file, each carries the full file mass — the file's
+ * Masse ist an jedem gebundenen Knoten sichtbar (Spike-2-Befund: 713-LOC-File
+ * ist topologisch sonst ein Punkt).
+ */
+export declare function weightNodes(graph: OntologyGraph, massByFile: Map<string, number>): Map<string, number>;

package/dist/layer.js

@@ -0,0 +1,36 @@
+/** Architektur-Schicht: Struktur- und Schnittstellen-Typen (ohne REQ/TEST/CR/MS/SYS/UC/FCHAIN). */
+export const ARCH_TYPES = new Set(['FUNC', 'FLOW', 'MOD', 'SCHEMA', 'ACTOR']);
+/**
+ * Project a graph onto the requested layer. `'all'` returns the graph
+ * unchanged; `'arch'` keeps only ARCH_TYPES elements and the traces whose BOTH
+ * endpoints survive (Doku-Knoten und ihre Traces fallen weg).
+ */
+export function projectLayer(graph, layer) {
+    if (layer === 'all')
+        return graph;
+    const ids = new Set(graph.elements.filter((e) => ARCH_TYPES.has(e.type)).map((e) => e.id));
+    return {
+        elements: graph.elements.filter((e) => ids.has(e.id)),
+        traces: graph.traces.filter((t) => ids.has(t.source) && ids.has(t.target)),
+    };
+}
+/**
+ * Derive node weights from per-file masses (e.g. LOC) via each element's
+ * realRef/codeRef file binding. Elements without binding or without a mass
+ * entry get no weight (metrics() defaults their mass to 1). When several
+ * elements bind the same file, each carries the full file mass — the file's
+ * Masse ist an jedem gebundenen Knoten sichtbar (Spike-2-Befund: 713-LOC-File
+ * ist topologisch sonst ein Punkt).
+ */
+export function weightNodes(graph, massByFile) {
+    const weights = new Map();
+    for (const e of graph.elements) {
+        const file = e.realRef?.file ?? e.codeRef?.file ?? e.attributes?.realRef?.file;
+        if (!file)
+            continue;
+        const mass = massByFile.get(file);
+        if (mass !== undefined)
+            weights.set(e.id, mass);
+    }
+    return weights;
+}

package/dist/metrics.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @sigloch/se-engine — `metrics(G, opts?): MetricVector` (CR-AIM-235).
+ *
+ * Die 6 Zielvektoren (aimpro docs/konzept/architekturgenerator-modell.md) als
+ * pure Funktion über OntologyGraph, nach dem se-steering-Muster: kein LLM,
+ * kein Store, kein Transport, kein Filesystem. Promotet aus aimpro
+ * src/harness/metrics.ts (CR-224) — MIT Layer-Projektion und optionalem
+ * Knotengewicht, denn promotet wird `metrics(G, layer)`, nicht das globale
+ * `metrics(G)` (sonst wird der Spike-2-blinde-Fleck familienweit verteilt).
+ *
+ * - modifiability  = 5·clamp(Q, 0, 1)              — Newman modularity Q (gewichtet, wenn nodeWeight gesetzt)
+ * - faultTolerance = 5·clamp(redundancyDensity)    — cyclomatic redundancy
+ * - flowEfficiency = 5·(1/max(1, meanIO))·reachF   — inverse mean Input→Output path length
+ * - coherence      = 5·intraEdgeFraction           — community-interner Kantenanteil (CR-229; gewichtet)
+ * - viability      = 5·(largestComponentMass / totalMass) — Massenanteil der größten Komponente
+ * - scalability    = 5·(1 − maxBetweenness)        — die eine vom Konzept fixierte Formel
+ *
+ * Default (`layer:'all'`, kein nodeWeight) ist bit-identisch zum bisherigen
+ * globalen metrics(G) — bestehende Aufrufer unverändert (Regression-AC).
+ */
+import { z } from 'zod';
+import type { OntologyGraph } from '@sigloch/contracts/se';
+import { type MetricLayer } from './layer.js';
+export declare const MetricVector: z.ZodObject<{
+    modifiability: z.ZodNumber;
+    faultTolerance: z.ZodNumber;
+    flowEfficiency: z.ZodNumber;
+    coherence: z.ZodNumber;
+    viability: z.ZodNumber;
+    scalability: z.ZodNumber;
+}, z.core.$strip>;
+export type MetricVector = z.infer<typeof MetricVector>;
+/**
+ * Ordered component keys — the canonical column order of the sensitivity
+ * matrix J (CR-227). Keep this order stable; downstream SVD indexes by it.
+ */
+export declare const METRIC_DIMENSIONS: readonly ["modifiability", "faultTolerance", "flowEfficiency", "coherence", "viability", "scalability"];
+/** Flatten a MetricVector into a fixed-order ℝ⁶ array (J-row / Δm). */
+export declare function toArray(v: MetricVector): number[];
+export interface MetricsOptions {
+    /** 'all' (Default, unverändertes Verhalten) oder 'arch' (Architektur-Teilgraph). */
+    layer?: MetricLayer;
+    /** Knotenmasse (z.B. LOC via layer.ts `weightNodes`); fehlende Knoten = Masse 1. */
+    nodeWeight?: Map<string, number>;
+}
+/** Measure a graph as a 6-dimensional topology vector (optional layer projection + node weight). */
+export declare function metrics(graph: OntologyGraph, opts?: MetricsOptions): MetricVector;
+export { projectLayer, weightNodes, ARCH_TYPES, type MetricLayer } from './layer.js';
+export { CLASS_MAP, classOf, classifyAll, classificationStats, type RuleClass, type Classification, type ClassifiedRule, type ClassificationStats, } from './rule-classify.js';
+export { applyRule, markEmptyDelta, type ApplyResult, type DeltaMark } from './rule-apply.js';
+export { targetFor, suggestEdits, type Suggestion, type SuggestOptions } from './suggest.js';
+export { fixFor, mentionedElements, FIX_TEMPLATES, type SuggestedEdit } from './fix-templates.js';
+export { buildAdjacency, betweenness, maxBetweenness, detectCommunities, modularityOf, modularityQ, redundancyDensity, intraEdgeFraction, components, componentSizes, sourceSinkPaths, type Adjacency, } from './topology.js';

package/dist/metrics.js

@@ -0,0 +1,97 @@
+/**
+ * @sigloch/se-engine — `metrics(G, opts?): MetricVector` (CR-AIM-235).
+ *
+ * Die 6 Zielvektoren (aimpro docs/konzept/architekturgenerator-modell.md) als
+ * pure Funktion über OntologyGraph, nach dem se-steering-Muster: kein LLM,
+ * kein Store, kein Transport, kein Filesystem. Promotet aus aimpro
+ * src/harness/metrics.ts (CR-224) — MIT Layer-Projektion und optionalem
+ * Knotengewicht, denn promotet wird `metrics(G, layer)`, nicht das globale
+ * `metrics(G)` (sonst wird der Spike-2-blinde-Fleck familienweit verteilt).
+ *
+ * - modifiability  = 5·clamp(Q, 0, 1)              — Newman modularity Q (gewichtet, wenn nodeWeight gesetzt)
+ * - faultTolerance = 5·clamp(redundancyDensity)    — cyclomatic redundancy
+ * - flowEfficiency = 5·(1/max(1, meanIO))·reachF   — inverse mean Input→Output path length
+ * - coherence      = 5·intraEdgeFraction           — community-interner Kantenanteil (CR-229; gewichtet)
+ * - viability      = 5·(largestComponentMass / totalMass) — Massenanteil der größten Komponente
+ * - scalability    = 5·(1 − maxBetweenness)        — die eine vom Konzept fixierte Formel
+ *
+ * Default (`layer:'all'`, kein nodeWeight) ist bit-identisch zum bisherigen
+ * globalen metrics(G) — bestehende Aufrufer unverändert (Regression-AC).
+ */
+import { z } from 'zod';
+import { buildAdjacency, maxBetweenness, detectCommunities, modularityOf, redundancyDensity, intraEdgeFraction, components, sourceSinkPaths, } from './topology.js';
+import { projectLayer } from './layer.js';
+export const MetricVector = z.object({
+    /** Änderbarkeit — Newman modularity Q (higher = more modular = easier to change). */
+    modifiability: z.number(),
+    /** Ausfalltoleranz — redundant-path density (cyclomatic redundancy). */
+    faultTolerance: z.number(),
+    /** Flusseffizienz — inverse mean Input→Output path length (shorter = more efficient). */
+    flowEfficiency: z.number(),
+    /** Kohärenz — community-internal edge share (cohesion / low coupling). */
+    coherence: z.number(),
+    /** Lebensfähigkeit unter Veränderung — largest-component mass share (stepwise buildability proxy). */
+    viability: z.number(),
+    /** Skalierbarkeit — SC = 5·(1 − maxBetweenness) (bottleneck-free share). */
+    scalability: z.number(),
+});
+/**
+ * Ordered component keys — the canonical column order of the sensitivity
+ * matrix J (CR-227). Keep this order stable; downstream SVD indexes by it.
+ */
+export const METRIC_DIMENSIONS = [
+    'modifiability',
+    'faultTolerance',
+    'flowEfficiency',
+    'coherence',
+    'viability',
+    'scalability',
+];
+/** Flatten a MetricVector into a fixed-order ℝ⁶ array (J-row / Δm). */
+export function toArray(v) {
+    return METRIC_DIMENSIONS.map((d) => v[d]);
+}
+const clamp05 = (x) => Math.max(0, Math.min(5, x));
+/** Measure a graph as a 6-dimensional topology vector (optional layer projection + node weight). */
+export function metrics(graph, opts = {}) {
+    const g = projectLayer(graph, opts.layer ?? 'all');
+    const adj = buildAdjacency(g, opts.nodeWeight);
+    const n = adj.nodes.length;
+    if (n === 0) {
+        return {
+            modifiability: 0,
+            faultTolerance: 0,
+            flowEfficiency: 0,
+            coherence: 0,
+            viability: 0,
+            scalability: 0,
+        };
+    }
+    const io = sourceSinkPaths(adj);
+    const comps = components(adj);
+    let totalMass = 0;
+    let largestMass = 0;
+    for (const group of comps) {
+        let m = 0;
+        for (const id of group)
+            m += adj.mass.get(id);
+        totalMass += m;
+        if (m > largestMass)
+            largestMass = m;
+    }
+    const community = detectCommunities(adj);
+    return {
+        modifiability: clamp05(5 * modularityOf(adj, community)),
+        faultTolerance: clamp05(5 * redundancyDensity(adj)),
+        flowEfficiency: clamp05(5 * (1 / Math.max(1, io.meanLength)) * io.reachableFraction),
+        coherence: clamp05(5 * intraEdgeFraction(adj, community)),
+        viability: clamp05(5 * (largestMass / totalMass)),
+        scalability: clamp05(5 * (1 - maxBetweenness(adj))),
+    };
+}
+export { projectLayer, weightNodes, ARCH_TYPES } from './layer.js';
+export { CLASS_MAP, classOf, classifyAll, classificationStats, } from './rule-classify.js';
+export { applyRule, markEmptyDelta } from './rule-apply.js';
+export { targetFor, suggestEdits } from './suggest.js';
+export { fixFor, mentionedElements, FIX_TEMPLATES } from './fix-templates.js';
+export { buildAdjacency, betweenness, maxBetweenness, detectCommunities, modularityOf, modularityQ, redundancyDensity, intraEdgeFraction, components, componentSizes, sourceSinkPaths, } from './topology.js';

package/dist/readiness-compute.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CR-120 / CR-221: Compute readiness scores from graph state (dimension model).
+ * Readiness is emergent — no state machine, no blockers. Deterministic, F2-free.
+ * Relocated from aimpro (learning-engine/graph/readiness.ts) into @sigloch/se-engine (CR-SM-248).
+ */
+import type { OntologyGraph, MetricPolicy } from '@sigloch/contracts/se';
+import { type ReadinessReportType } from '@sigloch/contracts/se';
+/**
+ * Compute readiness report from the current graph state.
+ *
+ * Jede Dimension: `score = 1 - Verstoesse / applicable`.
+ *
+ * **Was `applicable` zaehlt — und was nicht.** Der Nenner summiert je Regel der Dimension die
+ * Elemente ihrer Grundgesamtheit (`ALL_RULE_DEFS[].domain`, CR-SM-235). Eine Regel mit 72 REQ
+ * traegt 72 bei, zehn solche Regeln 720 — der Score ist damit **„Anteil nicht gerissener
+ * Pruefungen", nicht „Anteil sauberer Elemente"**. Das ist vertretbar, muss aber so heissen:
+ * als Fertigstellungsgrad gelesen ist die Zahl zu optimistisch.
+ *
+ * CR-SM-233: `policy` reicht bis zu den Regeln durch und hat keinen Default — sonst urteilte
+ * die Readiness mit einer anderen Schwelle als die, die der Host anzeigt.
+ *
+ * CR-SM-235: `readyThreshold` ebenso. Vorher stand hier `0.7` und im graphcode-Treiber `0.8`
+ * (`generate.ts`, Default-Parameter) — zwei Werte fuer dieselbe Frage „ist diese Dimension zu
+ * schwach?", und der Konsument konnte nicht wissen, welcher gilt. Den Wert liefert die Config
+ * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
+ */
+export declare function computeReadiness(graph: OntologyGraph, policy: MetricPolicy, readyThreshold: number): ReadinessReportType;

package/dist/readiness-compute.js

@@ -0,0 +1,119 @@
+import { evaluateAllRules, ALL_RULE_DEFS } from '@sigloch/contracts/se';
+import { ReadinessDimension, RULE_TO_DIMENSION, } from '@sigloch/contracts/se';
+/**
+ * Compute readiness report from the current graph state.
+ *
+ * Jede Dimension: `score = 1 - Verstoesse / applicable`.
+ *
+ * **Was `applicable` zaehlt — und was nicht.** Der Nenner summiert je Regel der Dimension die
+ * Elemente ihrer Grundgesamtheit (`ALL_RULE_DEFS[].domain`, CR-SM-235). Eine Regel mit 72 REQ
+ * traegt 72 bei, zehn solche Regeln 720 — der Score ist damit **„Anteil nicht gerissener
+ * Pruefungen", nicht „Anteil sauberer Elemente"**. Das ist vertretbar, muss aber so heissen:
+ * als Fertigstellungsgrad gelesen ist die Zahl zu optimistisch.
+ *
+ * CR-SM-233: `policy` reicht bis zu den Regeln durch und hat keinen Default — sonst urteilte
+ * die Readiness mit einer anderen Schwelle als die, die der Host anzeigt.
+ *
+ * CR-SM-235: `readyThreshold` ebenso. Vorher stand hier `0.7` und im graphcode-Treiber `0.8`
+ * (`generate.ts`, Default-Parameter) — zwei Werte fuer dieselbe Frage „ist diese Dimension zu
+ * schwach?", und der Konsument konnte nicht wissen, welcher gilt. Den Wert liefert die Config
+ * (CR-GC-329); diese Funktion macht nur die Zweitmeinung unmoeglich.
+ */
+export function computeReadiness(graph, policy, readyThreshold) {
+    const allViolations = evaluateAllRules(graph, policy);
+    // Group violations by dimension
+    const violationsByDim = new Map();
+    for (const dim of ReadinessDimension.options) {
+        violationsByDim.set(dim, []);
+    }
+    // CR-SM-239: „wir messen den ganzen Graphen" und „wir messen diese Gruppe" sind zwei
+    // verschiedene Fragen — die Trennung steht seit CR-SM-235 im `domain`, war aber auf diese
+    // Regeln nicht angewandt.
+    //
+    // Die acht Themen-Dimensionen sind **Gruppen-Scores**: „wie sauber sind die REQ / die UC /
+    // die Module?". Ein Check, der EINMAL den ganzen Graphen prueft (AF-01..05 Freshness-Stempel,
+    // R-28 Ebenen-Praesenz), beantwortet diese Frage nicht — er gehoert auf die Gate-Achse
+    // (`RULE_TO_PHASE`, wo er bereits steht). Er zaehlt hier deshalb **weder im Zaehler noch im
+    // Nenner**.
+    //
+    // Warum das noetig war: als Elementregel deklariert wog ein Graph-Check so viel wie EIN
+    // Element. Auf kleinen Gruppen dominierte er damit — `ver` mit einer einzigen Pruefung
+    // (R-21 ueber 1 FCHAIN) las 50 %, weil ein FMEA-Stempel fehlte, und schlug `uc` mit 73 %
+    // echter Befunde. Der Executor haette einen Stempel gefordert statt der leeren FCHAIN.
+    // Die Verstoesse sind nicht verloren: sie stehen im Regelstrom und auf der Gate-Achse.
+    const graphLevelRules = new Set(ALL_RULE_DEFS.filter(d => d.domain.includes('graph')).map(d => d.id));
+    // Count elements by type — used for applicable counts AND phase gate checks
+    const els = graph.elements.filter(e => e.type !== 'SESSION');
+    const countByType = {};
+    for (const e of els) {
+        countByType[e.type] = (countByType[e.type] ?? 0) + 1;
+    }
+    countByType['all'] = els.length;
+    const applicableCounts = computeApplicable(countByType);
+    for (const v of allViolations) {
+        const dim = RULE_TO_DIMENSION[v.rule_id];
+        if (!dim)
+            continue;
+        // Graph-Checks gehoeren auf die Gate-Achse, nicht in einen Gruppen-Score.
+        if (graphLevelRules.has(v.rule_id))
+            continue;
+        violationsByDim.get(dim).push(v);
+    }
+    const scores = ReadinessDimension.options.map(dim => {
+        const violations = violationsByDim.get(dim).length;
+        const applicable = applicableCounts[dim];
+        const score = applicable === 0 ? 0.0 : Math.max(0, 1 - violations / applicable);
+        return {
+            dimension: dim,
+            score: Math.round(score * 1000) / 1000, // 3 decimal precision
+            violations,
+            applicable,
+            ready: score >= readyThreshold,
+        };
+    });
+    // CR-SM-237: `overallScore` faellt — das ungewichtete Mittel dieser Scores, von keinem
+    // Konsumenten gelesen und nicht interpretierbar (`ms` mit 3 Regeln zaehlte so viel wie
+    // `arch` mit ~20). Wer „begonnen" braucht, liest `applicable > 0` je Dimension; das ist
+    // dieselbe Information, die schon den Nenner bildet, und seit CR-SM-235 die einzige
+    // Phasenaussage dieses Moduls.
+    return {
+        scores,
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * CR-146 / CR-SM-235: Anzahl anwendbarer Pruefungen je Dimension.
+ *
+ * `applicable = Σ (Elemente der Grundgesamtheit)` ueber die Regeln der Dimension. Die
+ * Grundgesamtheit steht seit CR-SM-235 an der Regel selbst (`ALL_RULE_DEFS[].domain`) —
+ * vorher lag hier eine Handtabelle `RULE_ELEMENT_TYPE`, in der **18 von 71 Regeln** fehlten.
+ * Deren Verstoesse erhoehten den Zaehler, nie den Nenner; auf graph-view-edit waren das 38
+ * von 415 Verstoessen. Jede neue Regel senkte den Score automatisch, bis jemand die zweite
+ * Tabelle nachzog, und kein Test erzwang das.
+ *
+ * Eine Regel mit mehreren Typen (RD-04: FUNC, MOD, SYS) traegt deren Summe bei — dieselben
+ * Elemente, die sie auch pruefen kann.
+ */
+function computeApplicable(countByType) {
+    const result = {};
+    for (const dim of ReadinessDimension.options) {
+        result[dim] = 0;
+    }
+    // CR-SM-239: zwei Beitragsarten, streng getrennt.
+    //  - Elementregeln zaehlen ihre Gruppe (`domain: ['REQ']` → so viele REQ es gibt).
+    //  - Graph-Regeln (`domain: ['graph']`) pruefen EINMAL den ganzen Graphen (AF-01..05, R-28).
+    //    Sie tragen 1 bei — aber nur, wenn die Dimension ueberhaupt eine Elementmenge hat.
+    for (const def of ALL_RULE_DEFS) {
+        const dim = RULE_TO_DIMENSION[def.id];
+        if (!dim)
+            continue;
+        // `domain: ['graph']` → eine Pruefung ueber den ganzen Graphen, keine Gruppe. Sie traegt
+        // nichts zum Gruppen-Score bei; ihre Heimat ist die Gate-Achse (`RULE_TO_PHASE`).
+        if (def.domain.includes('graph'))
+            continue;
+        for (const type of def.domain) {
+            result[dim] += countByType[type] ?? 0;
+        }
+    }
+    return result;
+}