@sigloch/contracts 0.7.0

package/dist/se/conformance-rules.js

@@ -0,0 +1,364 @@
+/**
+ * RC conformance rules (CR-GC-253) — graph↔code resolution, the RESOLUTION
+ * twins of the presence rules R-20 (codeRef) / R-19 (testRef).
+ *
+ * Rules stay in THIS library (one rule base per onto set — no rule definitions
+ * in executor codebases). They are pure functions over (graph, facts): all
+ * filesystem/parser work happens in the executor (graphcode extracts CodeFacts
+ * from the repo), so this module stays I/O-free and browser-bundlable.
+ *
+ * CodeFacts semantics: `files` is keyed by repo-relative path and MUST contain
+ * an entry for every file referenced by a codeRef/testRef the extractor saw.
+ * A MISSING key is treated like `exists:false` — an extractor gap must surface
+ * loudly as a violation, never as a silent pass.
+ *
+ * @sigloch/contracts/se — single source of truth for SE validation rules.
+ */
+import { z } from 'zod/v4';
+import { CodeRefSchema, TestRefSchema, SchemaRefSchema } from './ontology.js';
+/** Parser facts about one source file (extracted by the executor). */
+export const FileFactsSchema = z.object({
+    /** File exists on disk (repo-relative path). */
+    exists: z.boolean(),
+    /** Every declared symbol name (functions, classes, consts, methods, …). */
+    declaredSymbols: z.array(z.string()).default([]),
+    /** Every `it`/`test`/`describe` case name (string first-arg). */
+    testCases: z.array(z.string()).default([]),
+    /** Every imported symbol name (import specifiers) — for RC-04 usage checks (CR-211). */
+    importedSymbols: z.array(z.string()).default([]),
+    /** Symbols X invoked as `X.parse(` / `X.safeParse(` — the schema is actually used (CR-211). */
+    parsedSymbols: z.array(z.string()).default([]),
+});
+/** One file→file import edge (repo-relative paths) — the module-drift evidence (CR-212). */
+export const ImportEdgeSchema = z.object({
+    from: z.string(),
+    to: z.string(),
+});
+/**
+ * Deterministic, serializable code facts — the data contract between the
+ * facts extractor (graphcode: TS parser today, ast-grep later — CR-GC-254)
+ * and the RC rules. Testable without any filesystem.
+ */
+export const CodeFactsSchema = z.object({
+    files: z.record(z.string(), FileFactsSchema),
+    /**
+     * File-level import graph of the repo (JS/TS), for the cross-module drift rule
+     * RC-05 (CR-212). Optional: an extractor that does not supply it simply means
+     * RC-05 has nothing to check (never a silent gap — RC-05 only judges edges it is
+     * given), so pre-CR-212 CodeFacts stay valid.
+     */
+    importEdges: z.array(ImportEdgeSchema).optional(),
+});
+const missingFile = (facts, file) => facts.files[file]?.exists !== true;
+// RC-01: every valid codeRef must resolve — file on disk, symbol declared in it.
+// Presence is R-20's concern (incl. concept/external/decomposition-parent
+// exemptions, CR-GC-244); RC-01 only judges bindings that exist. `lang:'prompt'`
+// is realized by a skill file — file-exists is the whole binding.
+function codeRefMustResolve(graph, facts) {
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'FUNC')
+            continue;
+        if (el.attributes?.concept === true || el.attributes?.external === true)
+            continue;
+        const parsed = CodeRefSchema.safeParse(el.attributes?.codeRef);
+        if (!parsed.success)
+            continue; // no/invalid binding → R-20 territory
+        const ref = parsed.data;
+        if (missingFile(facts, ref.file)) {
+            violations.push({
+                rule_id: 'RC-01',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} codeRef.file '${ref.file}' does not exist on disk`,
+                fix_hint: 'Re-realize the FUNC (graph_realize) against the current source tree, or fix the moved/renamed file path',
+                context: { element_type: el.type, element_name: el.name },
+            });
+            continue;
+        }
+        if (ref.lang === 'prompt')
+            continue; // skill file existing IS the binding
+        if (!facts.files[ref.file].declaredSymbols.includes(ref.symbol)) {
+            violations.push({
+                rule_id: 'RC-01',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} codeRef.symbol '${ref.symbol}' is not declared in '${ref.file}'`,
+                fix_hint: 'The symbol was renamed or removed — re-realize the FUNC against the current code',
+                context: { element_type: el.type, element_name: el.name },
+            });
+        }
+    }
+    return violations;
+}
+// RC-02: every valid testRef must resolve — file on disk and, when `case` is
+// set, the case name declared as an it/test/describe in that file.
+function testRefMustResolve(graph, facts) {
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'TEST')
+            continue;
+        if (el.attributes?.concept === true)
+            continue;
+        const parsed = TestRefSchema.safeParse(el.attributes?.testRef);
+        if (!parsed.success)
+            continue; // no/invalid binding → R-19 territory
+        const ref = parsed.data;
+        if (missingFile(facts, ref.file)) {
+            violations.push({
+                rule_id: 'RC-02',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} testRef.file '${ref.file}' does not exist on disk`,
+                fix_hint: 'The test file was moved or deleted — rebind the TEST (graph_realize) to the current file',
+                context: { element_type: el.type, element_name: el.name },
+            });
+            continue;
+        }
+        // `case` is a name FILTER (vitest -t semantics): it matches by substring,
+        // so it must occur within some declared it/test/describe name — not equal it.
+        const caseName = ref.case;
+        if (caseName !== undefined && !facts.files[ref.file].testCases.some((name) => name.includes(caseName))) {
+            violations.push({
+                rule_id: 'RC-02',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} testRef.case '${ref.case}' is not declared in '${ref.file}'`,
+                fix_hint: 'The test case was renamed or removed — rebind the TEST case name',
+                context: { element_type: el.type, element_name: el.name },
+            });
+        }
+    }
+    return violations;
+}
+// RC-03: every valid SCHEMA schemaRef must resolve — file on disk, symbol declared
+// in it (CR-211). Presence (a SCHEMA with NO schemaRef) is the concern of the
+// R-26 presence rule, not RC-03; concept/external SCHEMAs are exempt there and
+// here. Severity error, like RC-01: a bound-but-broken schema IS a defect. Fires
+// 0× until schemaRefs exist (it only judges SCHEMAs that carry one).
+function schemaRefMustResolve(graph, facts) {
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'SCHEMA')
+            continue;
+        if (el.attributes?.concept === true || el.attributes?.external === true)
+            continue;
+        const parsed = SchemaRefSchema.safeParse(el.attributes?.schemaRef);
+        if (!parsed.success)
+            continue; // no/invalid binding → R-26 territory
+        const ref = parsed.data;
+        if (missingFile(facts, ref.file)) {
+            violations.push({
+                rule_id: 'RC-03',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} schemaRef.file '${ref.file}' does not exist on disk`,
+                fix_hint: 'Re-bind the SCHEMA (graph_realize) to the current source tree, or fix the moved/renamed file path',
+                context: { element_type: el.type, element_name: el.name },
+            });
+            continue;
+        }
+        if (!facts.files[ref.file].declaredSymbols.includes(ref.symbol)) {
+            violations.push({
+                rule_id: 'RC-03',
+                severity: 'error',
+                element_id: el.id,
+                message: `${el.id} schemaRef.symbol '${ref.symbol}' is not a declared export in '${ref.file}'`,
+                fix_hint: 'The schema export was renamed or removed — re-bind the SCHEMA against the current code',
+                context: { element_type: el.type, element_name: el.name },
+            });
+        }
+    }
+    return violations;
+}
+// RC-04: a bound SCHEMA that the graph says is realized at an interface must
+// actually be parsed there (CR-211). The graph gives the check LOCATIONS: FUNCs
+// io-connected to a FLOW whose data format IS this SCHEMA (FUNC ─io→ FLOW
+// ─relation→ SCHEMA) and that carry a resolvable codeRef. If ≥1 such FUNC exists
+// but NONE of their codeRef files import AND parse (`.parse`/`.safeParse`) the
+// schema symbol, the modelled validation is missing. Severity warn (the parse may
+// legitimately sit in a framework layer, not the FUNC's own file). Skips when the
+// SCHEMA has no schemaRef, or no io-connected realized FUNC to check against.
+function schemaRefMustBeUsed(graph, facts) {
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const violations = [];
+    for (const el of graph.elements) {
+        if (el.type !== 'SCHEMA')
+            continue;
+        if (el.attributes?.concept === true || el.attributes?.external === true)
+            continue;
+        const parsed = SchemaRefSchema.safeParse(el.attributes?.schemaRef);
+        if (!parsed.success)
+            continue;
+        const ref = parsed.data;
+        // The FLOWs whose data format is this SCHEMA (FLOW ─relation→ SCHEMA).
+        const flowIds = new Set(graph.traces
+            .filter(t => t.type === 'relation' && t.target === el.id && typeOf.get(t.source) === 'FLOW')
+            .map(t => t.source));
+        if (flowIds.size === 0)
+            continue;
+        // FUNCs io-connected to those FLOWs (producer or consumer).
+        const funcIds = new Set(graph.traces
+            .filter(t => t.type === 'io' &&
+            ((flowIds.has(t.target) && typeOf.get(t.source) === 'FUNC') ||
+                (flowIds.has(t.source) && typeOf.get(t.target) === 'FUNC')))
+            .map(t => (flowIds.has(t.target) ? t.source : t.target)));
+        // Realized FUNCs among them: a resolvable codeRef whose file exists.
+        const realizedFiles = [];
+        for (const fnId of funcIds) {
+            const fn = graph.elements.find(e => e.id === fnId);
+            const cr = CodeRefSchema.safeParse(fn?.attributes?.codeRef);
+            if (cr.success && !missingFile(facts, cr.data.file))
+                realizedFiles.push(cr.data.file);
+        }
+        if (realizedFiles.length === 0)
+            continue; // nothing realized to check against
+        const usedSomewhere = realizedFiles.some(file => {
+            const f = facts.files[file];
+            return f.importedSymbols.includes(ref.symbol) && f.parsedSymbols.includes(ref.symbol);
+        });
+        if (!usedSomewhere) {
+            violations.push({
+                rule_id: 'RC-04',
+                severity: 'warning',
+                element_id: el.id,
+                message: `${el.id} schema '${ref.symbol}' is not parsed in any realized FUNC at its modelled interface`,
+                fix_hint: `Import and call ${ref.symbol}.parse()/.safeParse() in one of the io-connected FUNC's code files, or mark the SCHEMA external if it is validated by a framework layer`,
+                context: { element_type: el.type, element_name: el.name },
+            });
+        }
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
+// RC-05: cross-module drift (CR-212) — a file-level import that crosses a MOD
+// boundary the graph does not document. The implementer wires a new dependency
+// between modules (an import over a MOD boundary); if the graph has no io/allocate
+// structure connecting those MODs, the relationship is undocumented and blast-
+// radius tools (graph_impact) under-report. Indicator, not blocker (warn), no
+// auto-fix. Pure over (graph, facts.importEdges):
+//   1. file → MOD via codeRef bindings (a bound file belongs to its FUNC's MOD),
+//      then MOD.path longest-prefix for unbound files; the rest are `unassigned`
+//      (reported in the message, never silently dropped).
+//   2. graph MOD-adjacency = any io crossing between two MODs' FUNCs
+//      (FUNC_A ─io→ FLOW ─io→ FUNC_B), treated UNDIRECTED — the graph models that
+//      the relationship exists; a warn rule should not over-fire on io direction.
+//   3. an importEdge whose endpoints map to two DIFFERENT assigned MODs with no
+//      such adjacency ⇒ one RC-05 per (fromMod → toMod) pair, evidence = the
+//      crossing file imports.
+// ---------------------------------------------------------------------------
+function importDriftConformance(graph, facts) {
+    const importEdges = facts.importEdges ?? [];
+    if (importEdges.length === 0)
+        return [];
+    const typeOf = new Map(graph.elements.map(e => [e.id, e.type]));
+    const modIds = graph.elements.filter(e => e.type === 'MOD').map(e => e.id);
+    if (modIds.length === 0)
+        return [];
+    // 1. file → MOD. Direct codeRef bindings first.
+    const fileToMod = new Map();
+    for (const el of graph.elements) {
+        if (el.type !== 'FUNC')
+            continue;
+        const cr = CodeRefSchema.safeParse(el.attributes?.codeRef);
+        if (!cr.success)
+            continue;
+        const modTrace = graph.traces.find(t => t.source === el.id && t.type === 'allocate' && typeOf.get(t.target) === 'MOD');
+        if (modTrace)
+            fileToMod.set(cr.data.file, modTrace.target);
+    }
+    // MOD.path longest-prefix fallback for files with no direct binding.
+    const modPaths = graph.elements
+        .filter(e => e.type === 'MOD' && typeof e.attributes?.path === 'string')
+        .map(e => ({ id: e.id, path: e.attributes.path.replace(/[*].*$/, '').replace(/\/+$/, '') }))
+        .filter(m => m.path.length > 0);
+    const resolveMod = (file) => {
+        if (fileToMod.has(file))
+            return fileToMod.get(file);
+        let best;
+        for (const m of modPaths) {
+            if ((file === m.path || file.startsWith(m.path + '/')) && (!best || m.path.length > best.len)) {
+                best = { id: m.id, len: m.path.length };
+            }
+        }
+        return best?.id;
+    };
+    // 2. graph MOD-adjacency (undirected) from io crossings FUNC_A ─io→ FLOW ─io→ FUNC_B.
+    const funcMod = (funcId) => {
+        const t = graph.traces.find(tr => tr.source === funcId && tr.type === 'allocate' && typeOf.get(tr.target) === 'MOD');
+        return t?.target;
+    };
+    const adjacent = new Set(); // key `A|B` with A<B (undirected)
+    const io = graph.traces.filter(t => t.type === 'io');
+    for (const flow of graph.elements) {
+        if (flow.type !== 'FLOW')
+            continue;
+        const funcs = new Set();
+        for (const t of io) {
+            if (t.target === flow.id && typeOf.get(t.source) === 'FUNC')
+                funcs.add(t.source);
+            if (t.source === flow.id && typeOf.get(t.target) === 'FUNC')
+                funcs.add(t.target);
+        }
+        const mods = [...new Set([...funcs].map(funcMod).filter((m) => !!m))];
+        for (let i = 0; i < mods.length; i++) {
+            for (let j = i + 1; j < mods.length; j++) {
+                const [a, b] = [mods[i], mods[j]].sort();
+                adjacent.add(`${a}|${b}`);
+            }
+        }
+    }
+    const isAdjacent = (a, b) => {
+        const [x, y] = [a, b].sort();
+        return adjacent.has(`${x}|${y}`);
+    };
+    // 3. drift per (fromMod → toMod), aggregating evidence; collect unassigned files.
+    const drift = new Map();
+    const unassigned = new Set();
+    for (const edge of importEdges) {
+        const fromMod = resolveMod(edge.from);
+        const toMod = resolveMod(edge.to);
+        if (!fromMod)
+            unassigned.add(edge.from);
+        if (!toMod)
+            unassigned.add(edge.to);
+        if (!fromMod || !toMod || fromMod === toMod)
+            continue;
+        if (isAdjacent(fromMod, toMod))
+            continue;
+        const key = `${fromMod}->${toMod}`;
+        const entry = drift.get(key) ?? { fromMod, toMod, evidence: [] };
+        entry.evidence.push(`${edge.from} → ${edge.to}`);
+        drift.set(key, entry);
+    }
+    const nameOf = new Map(graph.elements.map(e => [e.id, e.name]));
+    const unassignedNote = unassigned.size > 0 ? ` (unassigned files not mapped to a MOD: ${[...unassigned].sort().join(', ')})` : '';
+    return [...drift.values()].map(d => {
+        const shown = d.evidence.slice(0, 5);
+        const more = d.evidence.length > shown.length ? ` +${d.evidence.length - shown.length} more` : '';
+        return {
+            rule_id: 'RC-05',
+            severity: 'warning',
+            element_id: d.fromMod,
+            message: `${d.fromMod} imports ${d.toMod} across a module boundary the graph does not document — evidence: ${shown.join('; ')}${more}${unassignedNote}`,
+            fix_hint: `Document the ${d.fromMod}→${d.toMod} dependency in the graph (an io/FLOW connection between their FUNCs), or remove the import`,
+            context: {
+                element_type: 'MOD',
+                element_name: nameOf.get(d.fromMod),
+                candidate_targets: [{ id: d.toMod, type: 'MOD', name: nameOf.get(d.toMod) ?? d.toMod }],
+            },
+        };
+    });
+}
+/** All RC conformance rules — evaluated by executors that can supply CodeFacts. */
+export const CODE_CONFORMANCE_RULES = [
+    { id: 'RC-01', name: 'codeRef resolves to a declared symbol', severity: 'error', evaluate: codeRefMustResolve },
+    { id: 'RC-02', name: 'testRef resolves to a runnable test', severity: 'error', evaluate: testRefMustResolve },
+    { id: 'RC-03', name: 'schemaRef resolves to a declared export', severity: 'error', evaluate: schemaRefMustResolve },
+    { id: 'RC-04', name: 'schemaRef is parsed at its interface', severity: 'warning', evaluate: schemaRefMustBeUsed },
+    { id: 'RC-05', name: 'cross-module import drift', severity: 'warning', evaluate: importDriftConformance },
+];
+/** Run all RC rules against a graph + extracted code facts. */
+export function evaluateConformanceRules(graph, facts) {
+    return CODE_CONFORMANCE_RULES.flatMap((rule) => rule.evaluate(graph, facts));
+}

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

@@ -0,0 +1,8 @@
+/**
+ * CR-155: CR-specific quality rules for change request traceability.
+ * CR is a process node that tracks mutations to structural elements.
+ */
+import type { OntologyGraph } from './ontology.js';
+import type { RuleDefinition, RuleViolation } from './rules.js';
+export declare const CR_RULES: RuleDefinition[];
+export declare function evaluateCRRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/cr-quality-rules.js

@@ -0,0 +1,141 @@
+// ---------------------------------------------------------------------------
+// CR-R01: CR must have at least one outgoing relation trace
+// ---------------------------------------------------------------------------
+function crMustTrack(graph) {
+    const crs = graph.elements.filter(e => e.type === 'CR');
+    return crs
+        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation'))
+        .map(cr => ({
+        rule_id: 'CR-R01',
+        severity: 'error',
+        element_id: cr.id,
+        message: `${cr.id} has no relation traces (tracks nothing)`,
+        fix_hint: 'Add relation traces to affected UC, REQ, FUNC, or MOD elements',
+        context: {
+            element_type: cr.type,
+            element_name: cr.name,
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
+// CR-R02: CR with status=done must have commitRef (unless architectureOnly)
+// ---------------------------------------------------------------------------
+function crDoneRequiresCommit(graph) {
+    const crs = graph.elements.filter(e => e.type === 'CR');
+    return crs
+        .filter(cr => {
+        const status = cr.attributes?.status;
+        if (status !== 'done')
+            return false;
+        if (cr.attributes?.architectureOnly === true)
+            return false;
+        const ref = cr.attributes?.commitRef;
+        return !ref || (Array.isArray(ref) && ref.length === 0);
+    })
+        .map(cr => ({
+        rule_id: 'CR-R02',
+        severity: 'error',
+        element_id: cr.id,
+        message: `${cr.id} is done but has no commitRef`,
+        fix_hint: 'Add commitRef with Git SHA, or set architectureOnly=true',
+        context: {
+            element_type: cr.type,
+            element_name: cr.name,
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
+// CR-R03: No concurrent mutation — warn if two open CRs track the same node
+// ---------------------------------------------------------------------------
+function noConcurrentMutation(graph) {
+    const openCrs = graph.elements.filter(e => e.type === 'CR' && (e.attributes?.status === 'open' || e.attributes?.status === 'in-progress'));
+    if (openCrs.length < 2)
+        return [];
+    // Build map: target node → list of open CRs that track it
+    const targetToCrs = new Map();
+    for (const cr of openCrs) {
+        const targets = graph.traces
+            .filter(t => t.source === cr.id && t.type === 'relation')
+            .map(t => t.target);
+        for (const tgt of targets) {
+            const list = targetToCrs.get(tgt) ?? [];
+            list.push(cr.id);
+            targetToCrs.set(tgt, list);
+        }
+    }
+    const violations = [];
+    const seen = new Set();
+    for (const [target, crIds] of targetToCrs) {
+        if (crIds.length < 2)
+            continue;
+        const key = crIds.sort().join(',');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        violations.push({
+            rule_id: 'CR-R03',
+            severity: 'warning',
+            element_id: target,
+            message: `${target} is tracked by ${crIds.length} open CRs: ${crIds.join(', ')}`,
+            fix_hint: 'Coordinate changes to avoid merge conflicts',
+            context: {
+                element_type: graph.elements.find(e => e.id === target)?.type,
+                element_name: graph.elements.find(e => e.id === target)?.name,
+            },
+        });
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
+// CR-R04: CR must have at least one relation→FUNC trace (CR-207)
+// ---------------------------------------------------------------------------
+function crMustHaveFunc(graph) {
+    const crs = graph.elements.filter(e => e.type === 'CR');
+    return crs
+        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' &&
+        graph.elements.some(e => e.id === t.target && e.type === 'FUNC')))
+        .map(cr => ({
+        rule_id: 'CR-R04',
+        severity: 'warning',
+        element_id: cr.id,
+        message: `${cr.id} has no relation→FUNC trace (no implementation scope)`,
+        fix_hint: 'Add CR→FUNC [relation] traces to define which functions this CR changes',
+        context: {
+            element_type: cr.type,
+            element_name: cr.name,
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
+// MS-03: CR should have a CR→MS [relation] trace (CR-207)
+// ---------------------------------------------------------------------------
+function crShouldHaveMilestone(graph) {
+    const crs = graph.elements.filter(e => e.type === 'CR');
+    return crs
+        .filter(cr => !graph.traces.some(t => t.source === cr.id && t.type === 'relation' &&
+        graph.elements.some(e => e.id === t.target && e.type === 'MS')))
+        .map(cr => ({
+        rule_id: 'MS-03',
+        severity: 'info',
+        element_id: cr.id,
+        message: `${cr.id} is not assigned to any milestone`,
+        fix_hint: 'Add CR→MS [relation] trace to assign this CR to a milestone',
+        context: {
+            element_type: cr.type,
+            element_name: cr.name,
+        },
+    }));
+}
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+export const CR_RULES = [
+    { id: 'CR-R01', name: 'CR must track', severity: 'error', evaluate: crMustTrack },
+    { id: 'CR-R02', name: 'Done requires commit', severity: 'error', evaluate: crDoneRequiresCommit },
+    { id: 'CR-R03', name: 'No concurrent mutation', severity: 'warning', evaluate: noConcurrentMutation },
+    { id: 'CR-R04', name: 'CR must have FUNC', severity: 'warning', evaluate: crMustHaveFunc },
+    { id: 'MS-03', name: 'CR without milestone', severity: 'info', evaluate: crShouldHaveMilestone },
+];
+export function evaluateCRRules(graph) {
+    return CR_RULES.flatMap(rule => rule.evaluate(graph));
+}

package/dist/se/evaluate-all.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Single point of truth for all rule evaluations.
+ * Import `evaluateAllRules` and `ALL_RULE_DEFS` instead of individual evaluators.
+ */
+import type { OntologyGraph } from './ontology.js';
+import type { RuleViolation } from './rules.js';
+/** All prescribed rule definitions (single source of truth for the catalog). */
+export declare const ALL_RULE_DEFS: ReadonlyArray<{
+    id: string;
+    name: string;
+    severity: 'error' | 'warning' | 'info';
+}>;
+/** Profile groupings derived from rule prefixes. */
+export type ProfileId = 'default' | 'se' | 'coding';
+export declare function getRuleDefsForProfile(profile: ProfileId): typeof ALL_RULE_DEFS;
+/** Evaluate all rules against a graph. Single call replaces the individual evaluator calls. */
+export declare function evaluateAllRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/evaluate-all.js

@@ -0,0 +1,50 @@
+import { V3_RULES, evaluateRules } from './rules.js';
+import { SC_RULES, evaluateSCRules } from './schema-quality-rules.js';
+import { UC_RULES, evaluateUCRules } from './uc-quality-rules.js';
+import { FC_RULES, evaluateFCRules } from './fchain-quality-rules.js';
+import { MT_RULES, evaluateMTRules } from './metric-rules.js';
+import { FM_RULES, evaluateFMRules } from './fmea-rules.js';
+import { VIEW_RULES, evaluateViewRules } from './view-rules.js';
+import { CR_RULES, evaluateCRRules } from './cr-quality-rules.js';
+import { ND_RULES, evaluateNDRules } from './near-duplicate-rules.js';
+import { AO_RULES, evaluateAORules } from './ao-rules.js';
+import { BQ_RULES, evaluateBQRules } from './quality-rules.js';
+/** All prescribed rule definitions (single source of truth for the catalog). */
+export const ALL_RULE_DEFS = [
+    ...V3_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...UC_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...FC_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...SC_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...MT_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...BQ_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...ND_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...CR_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...AO_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...FM_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+    ...VIEW_RULES.map(r => ({ id: r.id, name: r.name, severity: r.severity })),
+];
+const SE_PREFIXES = ['R-', 'UC-', 'FC-', 'SC-', 'MT-', 'CR-', 'AO-', 'FM-', 'NFR-', 'RT-', 'PH-', 'CA-', 'IO-', 'VR-', 'CL-'];
+const CODING_PREFIXES = ['BQ-', 'ND-'];
+export function getRuleDefsForProfile(profile) {
+    if (profile === 'se')
+        return ALL_RULE_DEFS.filter(r => SE_PREFIXES.some(p => r.id.startsWith(p)));
+    if (profile === 'coding')
+        return ALL_RULE_DEFS.filter(r => CODING_PREFIXES.some(p => r.id.startsWith(p)));
+    return ALL_RULE_DEFS;
+}
+/** Evaluate all rules against a graph. Single call replaces the individual evaluator calls. */
+export function evaluateAllRules(graph) {
+    return [
+        ...evaluateRules(graph),
+        ...evaluateBQRules(graph),
+        ...evaluateUCRules(graph),
+        ...evaluateFCRules(graph),
+        ...evaluateSCRules(graph),
+        ...evaluateNDRules(graph),
+        ...evaluateMTRules(graph),
+        ...evaluateCRRules(graph),
+        ...evaluateAORules(graph),
+        ...evaluateFMRules(graph),
+        ...evaluateViewRules(graph),
+    ];
+}

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

@@ -0,0 +1,10 @@
+/**
+ * FC-01..FC-03 — FCHAIN quality rules (CR-121 Phase 1).
+ */
+import type { OntologyGraph } from './ontology.js';
+import type { RuleDefinition, RuleViolation } from './rules.js';
+export declare function fc01ActorBoundary(graph: OntologyGraph): RuleViolation[];
+export declare function fc02LeafUcHasFchain(graph: OntologyGraph): RuleViolation[];
+export declare function fc03FchainFlat(graph: OntologyGraph): RuleViolation[];
+export declare const FC_RULES: RuleDefinition[];
+export declare function evaluateFCRules(graph: OntologyGraph): RuleViolation[];