@sigloch/contracts 0.7.0

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

@@ -0,0 +1,105 @@
+// ---------------------------------------------------------------------------
+// FC-01: FCHAIN must have Actor boundary (input or output via FLOW→ACTOR io)
+// ---------------------------------------------------------------------------
+export function fc01ActorBoundary(graph) {
+    return graph.elements
+        .filter(e => e.type === 'FCHAIN')
+        .filter(fc => {
+        // Get FUNCs in this FCHAIN via compose
+        const funcIds = graph.traces
+            .filter(t => t.source === fc.id && t.type === 'compose')
+            .map(t => t.target);
+        // Check if any FUNC has io trace involving an ACTOR (via FLOW)
+        const hasActorIO = funcIds.some(fid => graph.traces.some(t => {
+            if (t.type !== 'io')
+                return false;
+            // FUNC→FLOW or FLOW→FUNC
+            const flowId = t.source === fid ? t.target : (t.target === fid ? t.source : null);
+            if (!flowId)
+                return false;
+            // FLOW→ACTOR or ACTOR→FLOW
+            return graph.traces.some(ft => ft.type === 'io' &&
+                ((ft.source === flowId && graph.elements.some(e => e.id === ft.target && e.type === 'ACTOR')) ||
+                    (ft.target === flowId && graph.elements.some(e => e.id === ft.source && e.type === 'ACTOR'))));
+        }));
+        // Also check direct ACTOR→UC io on the parent UC
+        const parentUC = graph.traces.find(t => t.type === 'compose' && t.target === fc.id &&
+            graph.elements.some(e => e.id === t.source && e.type === 'UC'));
+        const hasDirectActorIO = parentUC && graph.traces.some(t => t.type === 'io' &&
+            ((t.target === parentUC.source && graph.elements.some(e => e.id === t.source && e.type === 'ACTOR')) ||
+                (t.source === parentUC.source && graph.elements.some(e => e.id === t.target && e.type === 'ACTOR'))));
+        return !hasActorIO && !hasDirectActorIO;
+    })
+        .map(fc => ({
+        rule_id: 'FC-01',
+        severity: 'warning',
+        element_id: fc.id,
+        message: `${fc.id} has no actor boundary (no ACTOR io connection)`,
+        fix_hint: 'Ensure at least one FUNC in the chain connects to an ACTOR via FLOW io',
+        context: { element_type: fc.type, element_name: fc.name },
+    }));
+}
+// ---------------------------------------------------------------------------
+// FC-02: Leaf UC (no UC→compose→UC) must have at least one FCHAIN
+// ---------------------------------------------------------------------------
+export function fc02LeafUcHasFchain(graph) {
+    return graph.elements
+        .filter(e => e.type === 'UC')
+        .filter(uc => {
+        // Leaf = no compose→UC children
+        const hasUCChild = graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
+            graph.elements.some(e => e.id === t.target && e.type === 'UC'));
+        if (hasUCChild)
+            return false;
+        // Must have compose→FCHAIN
+        return !graph.traces.some(t => t.source === uc.id && t.type === 'compose' &&
+            graph.elements.some(e => e.id === t.target && e.type === 'FCHAIN'));
+    })
+        .map(uc => ({
+        rule_id: 'FC-02',
+        severity: 'warning',
+        element_id: uc.id,
+        message: `Leaf UC ${uc.id} has no FCHAIN scenario`,
+        fix_hint: 'Add a FCHAIN via compose trace for behavioral specification',
+        context: { element_type: uc.type, element_name: uc.name },
+    }));
+}
+// ---------------------------------------------------------------------------
+// FC-03: FUNC within FCHAIN should not compose other FUNC (flat chain)
+// ---------------------------------------------------------------------------
+export function fc03FchainFlat(graph) {
+    const violations = [];
+    const fchains = graph.elements.filter(e => e.type === 'FCHAIN');
+    for (const fc of fchains) {
+        const funcIds = graph.traces
+            .filter(t => t.source === fc.id && t.type === 'compose')
+            .map(t => t.target)
+            .filter(id => graph.elements.some(e => e.id === id && e.type === 'FUNC'));
+        for (const fid of funcIds) {
+            const nestedCompose = graph.traces.filter(t => t.source === fid && t.type === 'compose' &&
+                graph.elements.some(e => e.id === t.target && e.type === 'FUNC'));
+            if (nestedCompose.length > 0) {
+                violations.push({
+                    rule_id: 'FC-03',
+                    severity: 'warning',
+                    element_id: fid,
+                    message: `${fid} in ${fc.id} has nested FUNC compose (should be flat)`,
+                    fix_hint: 'Move nested functions to FCHAIN level (flat composition)',
+                    context: { element_type: 'FUNC', element_name: graph.elements.find(e => e.id === fid)?.name ?? fid },
+                });
+            }
+        }
+    }
+    return violations;
+}
+// ---------------------------------------------------------------------------
+// Aggregated
+// ---------------------------------------------------------------------------
+export const FC_RULES = [
+    { id: 'FC-01', name: 'FCHAIN has actor boundary', severity: 'warning', evaluate: fc01ActorBoundary },
+    { id: 'FC-02', name: 'Leaf UC has FCHAIN', severity: 'warning', evaluate: fc02LeafUcHasFchain },
+    { id: 'FC-03', name: 'FCHAIN is flat', severity: 'warning', evaluate: fc03FchainFlat },
+];
+export function evaluateFCRules(graph) {
+    return FC_RULES.flatMap(rule => rule.evaluate(graph));
+}

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

@@ -0,0 +1,17 @@
+/**
+ * CR-182: FMEA/FTA Risk Rules + NFR Budget Overshoot Detection.
+ * FM-01: Risk-REQ missing FMEA attributes (severity, occurrence, detection).
+ * FM-02: Risk-REQ without mitigation (compose→REQ(kinds∋mitigation)).
+ * FM-03: High-risk REQ (RPN>100) without passed verification.
+ * NFR-01: measured exceeds budget for an NFR dimension. CR-228 splits the target
+ *   by dimension nature: physical budgets (weight/power/cost) live on the part
+ *   (MOD); behavioral budgets (timing/memory-throughput) on the FCHAIN/FUNC.
+ */
+import type { OntologyGraph } from './ontology.js';
+import type { RuleViolation, RuleDefinition } from './rules.js';
+export declare function fm01MissingFmeaAttributes(graph: OntologyGraph): RuleViolation[];
+export declare function fm02MissingMitigation(graph: OntologyGraph): RuleViolation[];
+export declare function fm03HighRiskUnverified(graph: OntologyGraph): RuleViolation[];
+export declare function nfr01BudgetOvershoot(graph: OntologyGraph): RuleViolation[];
+export declare const FM_RULES: RuleDefinition[];
+export declare function evaluateFMRules(graph: OntologyGraph): RuleViolation[];

package/dist/se/fmea-rules.js

@@ -0,0 +1,137 @@
+const PHYSICAL_BUDGET_PAIRS = [
+    ['costBudget', 'measuredCost', 'cost'],
+    ['weightBudgetKg', 'measuredWeightKg', 'weight (kg)'],
+    ['powerBudgetW', 'measuredPowerW', 'power (W)'],
+];
+const BEHAVIORAL_BUDGET_PAIRS = [
+    ['timingBudgetMs', 'measuredMs', 'timing (ms)'],
+    ['memoryBudgetMb', 'measuredMemoryMb', 'memory (MB)'],
+];
+const PHYSICAL_BUDGET_TYPES = ['MOD'];
+const BEHAVIORAL_BUDGET_TYPES = ['FUNC', 'FCHAIN'];
+// ---------------------------------------------------------------------------
+// FM-01: Risk-REQ without FMEA attributes
+// ---------------------------------------------------------------------------
+export function fm01MissingFmeaAttributes(graph) {
+    return graph.elements
+        .filter(e => e.type === 'REQ' && e.kinds?.includes('risk'))
+        .filter(e => {
+        const a = e.attributes ?? {};
+        return a['severity'] == null || a['occurrence'] == null || a['detection'] == null;
+    })
+        .map(e => {
+        const missing = [];
+        const a = e.attributes ?? {};
+        if (a['severity'] == null)
+            missing.push('severity');
+        if (a['occurrence'] == null)
+            missing.push('occurrence');
+        if (a['detection'] == null)
+            missing.push('detection');
+        return {
+            rule_id: 'FM-01',
+            severity: 'warning',
+            element_id: e.id,
+            message: `${e.id} is a risk REQ missing FMEA attributes: ${missing.join(', ')}`,
+            fix_hint: 'Add severity, occurrence, and detection ratings (1-10) to attributes',
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// FM-02: Risk-REQ without mitigation
+// ---------------------------------------------------------------------------
+export function fm02MissingMitigation(graph) {
+    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    return riskReqs
+        .filter(riskReq => {
+        // Check: compose trace from riskReq to a REQ with kinds∋mitigation
+        return !graph.traces.some(t => t.source === riskReq.id &&
+            t.type === 'compose' &&
+            graph.elements.some(el => el.id === t.target && el.type === 'REQ' && el.kinds?.includes('mitigation')));
+    })
+        .map(e => ({
+        rule_id: 'FM-02',
+        severity: 'warning',
+        element_id: e.id,
+        message: `${e.id} is a risk REQ without a mitigation REQ (compose→REQ[mitigation])`,
+        fix_hint: 'Create a mitigation REQ and link via compose trace',
+    }));
+}
+// ---------------------------------------------------------------------------
+// FM-03: High-risk REQ (RPN > 100) without passed verification
+// ---------------------------------------------------------------------------
+export function fm03HighRiskUnverified(graph) {
+    const riskReqs = graph.elements.filter(e => e.type === 'REQ' && e.kinds?.includes('risk'));
+    return riskReqs
+        .filter(riskReq => {
+        const a = riskReq.attributes ?? {};
+        const s = Number(a['severity']);
+        const o = Number(a['occurrence']);
+        const d = Number(a['detection']);
+        if (isNaN(s) || isNaN(o) || isNaN(d))
+            return false; // can't compute RPN → skip
+        const rpn = s * o * d;
+        if (rpn <= 100)
+            return false;
+        // Check: TEST→verify→riskReq with testResult=passed
+        const hasPassedTest = graph.traces.some(t => t.type === 'verify' &&
+            t.target === riskReq.id &&
+            graph.elements.some(el => el.id === t.source && el.type === 'TEST' && el.attributes?.['testResult'] === 'passed'));
+        return !hasPassedTest;
+    })
+        .map(e => {
+        const a = e.attributes ?? {};
+        const rpn = Number(a['severity']) * Number(a['occurrence']) * Number(a['detection']);
+        return {
+            rule_id: 'FM-03',
+            severity: 'error',
+            element_id: e.id,
+            message: `${e.id} has RPN ${rpn} (>100) without passed test verification`,
+            fix_hint: 'Add a TEST with testResult=passed and verify trace to this risk REQ',
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// NFR-01: Budget overshoot detection
+// ---------------------------------------------------------------------------
+export function nfr01BudgetOvershoot(graph) {
+    const violations = [];
+    const check = (types, pairs) => {
+        for (const el of graph.elements) {
+            if (!types.includes(el.type))
+                continue;
+            const a = el.attributes ?? {};
+            for (const [budgetKey, measuredKey, label] of pairs) {
+                const budget = Number(a[budgetKey]);
+                const measured = Number(a[measuredKey]);
+                if (isNaN(budget) || isNaN(measured))
+                    continue;
+                if (measured > budget) {
+                    violations.push({
+                        rule_id: 'NFR-01',
+                        severity: 'warning',
+                        element_id: el.id,
+                        message: `${el.id} ${label} over budget: ${measured} > ${budget}`,
+                        fix_hint: `Reduce ${measuredKey} or increase ${budgetKey}`,
+                    });
+                }
+            }
+        }
+    };
+    // Physical budgets on the part (MOD); behavioral budgets on the behavior (FCHAIN/FUNC).
+    check(PHYSICAL_BUDGET_TYPES, PHYSICAL_BUDGET_PAIRS);
+    check(BEHAVIORAL_BUDGET_TYPES, BEHAVIORAL_BUDGET_PAIRS);
+    return violations;
+}
+// ---------------------------------------------------------------------------
+// Aggregated array & convenience runner
+// ---------------------------------------------------------------------------
+export const FM_RULES = [
+    { id: 'FM-01', name: 'RiskReqFmeaAttributes', severity: 'warning', evaluate: fm01MissingFmeaAttributes },
+    { id: 'FM-02', name: 'RiskReqMitigation', severity: 'warning', evaluate: fm02MissingMitigation },
+    { id: 'FM-03', name: 'HighRiskVerification', severity: 'error', evaluate: fm03HighRiskUnverified },
+    { id: 'NFR-01', name: 'BudgetOvershoot', severity: 'warning', evaluate: nfr01BudgetOvershoot },
+];
+export function evaluateFMRules(graph) {
+    return FM_RULES.flatMap(rule => rule.evaluate(graph));
+}

package/dist/se/format-e-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Format E Parser — Graph mutations from compact text format.
+ * SE-relevant subset: nodes (+/-/~) and edges (+/-), no chat-canvas or views.
+ * ~150 LOC, no external dependencies beyond @sigloch/contracts/se.
+ *
+ * @sigloch/contracts/se
+ */
+import type { TraceType, OntologyGraph } from './ontology.js';
+export interface FormatEOperation {
+    type: 'add_node' | 'remove_node' | 'update_node' | 'add_edge' | 'remove_edge' | 'strict_add_node' | 'strict_add_edge';
+    semanticId: string;
+    description?: string;
+    /** CR-147: Parsed @key value attributes from lines below the node entry. */
+    attributes?: Record<string, string>;
+    sourceId?: string;
+    targetId?: string;
+    traceType?: TraceType;
+}
+export interface FormatEDiff {
+    operations: FormatEOperation[];
+    errors: string[];
+}
+/** Extract a ```format-e block from LLM output. Returns null if not found. */
+export declare function extractFormatE(llmOutput: string): string | null;
+/** Parse a Format E text block into validated operations. */
+export declare function parseFormatE(input: string): FormatEDiff;
+/** Serialize an OntologyGraph to compact Format E text. */
+export declare function serializeToFormatE(graph: OntologyGraph): string;

package/dist/se/format-e-parser.js

@@ -0,0 +1,217 @@
+import { isValidTrace } from './meta-model.js';
+import { isSemanticId, extractFromSemanticId } from './semantic-id.js';
+// ---------------------------------------------------------------------------
+// Extraction
+// ---------------------------------------------------------------------------
+const FORMAT_E_FENCE = /```format-e\s*\n([\s\S]*?)```/;
+/** Extract a ```format-e block from LLM output. Returns null if not found. */
+export function extractFormatE(llmOutput) {
+    const m = FORMAT_E_FENCE.exec(llmOutput);
+    return m ? m[1].trim() : null;
+}
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+const VALID_TRACE_TYPES = new Set([
+    'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation', 'produces',
+]);
+const OP_PREFIX = {
+    '+': 'add',
+    '-': 'remove',
+    '~': 'update',
+    '!': 'strict_add',
+};
+const EDGE_RE = /^([+\-~!])?\s*(\S+)\s+-(\w+)->\s+(\S+)\s*$/;
+const NODE_RE = /^([+\-~!])?\s*(\S+?)(?:\|(.*))?$/;
+/** CR-147: @key value attribute line (indented, below a node entry). */
+const ATTR_RE = /^\s*@(\w+)\s+(.+)$/;
+/** CR-148: Trace-type normalization aliases (source→target→from→to). */
+const TRACE_NORMALIZE = {
+    FLOW: { SCHEMA: 'relation' }, // FLOW→SCHEMA io → relation
+};
+/** Parse a Format E text block into validated operations. */
+export function parseFormatE(input) {
+    const operations = [];
+    const errors = [];
+    let section = null;
+    for (const rawLine of input.split('\n')) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('//') || line.startsWith('#!'))
+            continue;
+        // CR-147: @attribute lines attach to the last node operation
+        const attrMatch = ATTR_RE.exec(line);
+        if (attrMatch) {
+            const lastOp = operations.length > 0 ? operations[operations.length - 1] : null;
+            if (lastOp && (lastOp.type === 'add_node' || lastOp.type === 'update_node' || lastOp.type === 'strict_add_node')) {
+                if (!lastOp.attributes)
+                    lastOp.attributes = {};
+                lastOp.attributes[attrMatch[1]] = attrMatch[2].trim();
+            }
+            else {
+                errors.push(`@attribute line without preceding node: "${line}"`);
+            }
+            continue;
+        }
+        // Section headers
+        if (/^##\s*nodes?\s*$/i.test(line)) {
+            section = 'nodes';
+            continue;
+        }
+        if (/^##\s*edges?\s*$/i.test(line)) {
+            section = 'edges';
+            continue;
+        }
+        // Skip other markdown headers
+        if (line.startsWith('#'))
+            continue;
+        // Try edge first (more specific pattern)
+        const edgeMatch = EDGE_RE.exec(line);
+        if (edgeMatch || section === 'edges') {
+            if (edgeMatch) {
+                parseEdge(edgeMatch, operations, errors);
+            }
+            else {
+                errors.push(`Invalid edge line: "${line}"`);
+            }
+            continue;
+        }
+        // Try node
+        if (section === 'nodes') {
+            const nodeMatch = NODE_RE.exec(line);
+            if (nodeMatch) {
+                parseNode(nodeMatch, operations, errors);
+            }
+            else {
+                errors.push(`Invalid node line: "${line}"`);
+            }
+            continue;
+        }
+        // Outside a section — try to auto-detect
+        const autoEdge = EDGE_RE.exec(line);
+        if (autoEdge) {
+            parseEdge(autoEdge, operations, errors);
+            continue;
+        }
+        const autoNode = NODE_RE.exec(line);
+        if (autoNode && isSemanticId(autoNode[2])) {
+            parseNode(autoNode, operations, errors);
+            continue;
+        }
+        // Unknown line
+        if (line.length > 0)
+            errors.push(`Unrecognized line: "${line}"`);
+    }
+    return { operations, errors };
+}
+/** CR-148: Normalize trace type using alias table. */
+function normalizeTraceType(srcType, tgtType, traceType) {
+    const aliases = TRACE_NORMALIZE[srcType];
+    if (aliases && aliases[tgtType] && traceType !== aliases[tgtType]) {
+        return aliases[tgtType];
+    }
+    return traceType;
+}
+function parseNode(m, ops, errors) {
+    const opChar = m[1] || '+';
+    const id = m[2];
+    const descr = m[3]?.trim();
+    const action = OP_PREFIX[opChar] ?? 'add';
+    if (!isSemanticId(id)) {
+        errors.push(`Invalid SemanticId: "${id}"`);
+        return;
+    }
+    if (action === 'remove') {
+        ops.push({ type: 'remove_node', semanticId: id });
+    }
+    else if (action === 'update') {
+        ops.push({ type: 'update_node', semanticId: id, description: descr });
+    }
+    else if (action === 'strict_add') {
+        ops.push({ type: 'strict_add_node', semanticId: id, description: descr });
+    }
+    else {
+        ops.push({ type: 'add_node', semanticId: id, description: descr });
+    }
+}
+function parseEdge(m, ops, errors) {
+    const opChar = m[1] || '+';
+    const sourceId = m[2];
+    const traceType = m[3];
+    const targetId = m[4];
+    const action = OP_PREFIX[opChar] ?? 'add';
+    if (!isSemanticId(sourceId)) {
+        errors.push(`Invalid source SemanticId: "${sourceId}"`);
+        return;
+    }
+    if (!isSemanticId(targetId)) {
+        errors.push(`Invalid target SemanticId: "${targetId}"`);
+        return;
+    }
+    if (!VALID_TRACE_TYPES.has(traceType)) {
+        errors.push(`Invalid trace type: "${traceType}"`);
+        return;
+    }
+    // Meta-model validation (with CR-148 normalization)
+    let resolvedTraceType = traceType;
+    try {
+        const src = extractFromSemanticId(sourceId);
+        const tgt = extractFromSemanticId(targetId);
+        // CR-148: Normalize before meta-model check (e.g. FLOW→SCHEMA io → relation)
+        resolvedTraceType = normalizeTraceType(src.type, tgt.type, traceType);
+        if (!isValidTrace({ source: src.type, target: tgt.type, type: resolvedTraceType })) {
+            errors.push(`Meta-model violation: ${src.type} -${traceType}-> ${tgt.type} is not valid`);
+            return;
+        }
+    }
+    catch {
+        errors.push(`Cannot extract types from edge: ${sourceId} -${traceType}-> ${targetId}`);
+        return;
+    }
+    const edgeType = action === 'remove'
+        ? 'remove_edge'
+        : action === 'strict_add'
+            ? 'strict_add_edge'
+            : 'add_edge';
+    ops.push({
+        type: edgeType,
+        semanticId: `${sourceId}->${targetId}`,
+        sourceId,
+        targetId,
+        traceType: resolvedTraceType,
+    });
+}
+// ---------------------------------------------------------------------------
+// Serializer
+// ---------------------------------------------------------------------------
+/** Serialize an OntologyGraph to compact Format E text. */
+export function serializeToFormatE(graph) {
+    const lines = [];
+    // Nodes
+    if (graph.elements.length > 0) {
+        lines.push('## Nodes');
+        for (const el of graph.elements) {
+            if (el.type === 'SESSION')
+                continue; // skip audit sessions
+            const descr = el.description ? `|${el.description}` : '';
+            lines.push(`+ ${el.id}${descr}`);
+            // CR-147: Serialize known attributes
+            if (el.attributes) {
+                for (const [k, v] of Object.entries(el.attributes)) {
+                    if (v != null && String(v).length > 0) {
+                        lines.push(`  @${k} ${String(v)}`);
+                    }
+                }
+            }
+        }
+    }
+    // Edges
+    const modelingTraces = graph.traces.filter(t => t.category !== 'audit');
+    if (modelingTraces.length > 0) {
+        lines.push('');
+        lines.push('## Edges');
+        for (const t of modelingTraces) {
+            lines.push(`+ ${t.source} -${t.type}-> ${t.target}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/se/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @sigloch/contracts/se — SE Ontology + Rules (versions below are the single source of truth).
+ * Single source of truth for SE ontology schemas across all projects.
+ */
+/** Ontology schema version (element types + trace types). */
+export declare const ONTOLOGY_VERSION = "3.8.0";
+/** Rules engine version (validation rules incl. RC conformance). */
+export declare const RULES_VERSION = "2.17.0";
+/** Meta-model version (trace pattern constraints + format-e parser). */
+export declare const META_MODEL_VERSION = "1.4.0";
+export * from './ontology.js';
+export * from './rules.js';
+export * from './conformance-rules.js';
+export * from './schema-quality-rules.js';
+export * from './uc-quality-rules.js';
+export * from './fchain-quality-rules.js';
+export * from './metric-rules.js';
+export * from './fmea-rules.js';
+export * from './view-rules.js';
+export * from './cr-quality-rules.js';
+export * from './near-duplicate-rules.js';
+export * from './ao-rules.js';
+export * from './quality-rules.js';
+export * from './evaluate-all.js';
+export * from './readiness.js';
+export * from './meta-model.js';
+export * from './semantic-id.js';
+export * from './format-e-parser.js';

package/dist/se/index.js

@@ -0,0 +1,28 @@
+/**
+ * @sigloch/contracts/se — SE Ontology + Rules (versions below are the single source of truth).
+ * Single source of truth for SE ontology schemas across all projects.
+ */
+/** Ontology schema version (element types + trace types). */
+export const ONTOLOGY_VERSION = '3.8.0'; // +RepoRelativePathSchema on testRef/codeRef/schemaRef .file — no absolute/`..` paths (CR-GC-255)
+/** Rules engine version (validation rules incl. RC conformance). */
+export const RULES_VERSION = '2.17.0'; // -R-24/R-25 REQ→MOD allocation rules deleted (CR-228 A: REQ→MOD allocate no longer a valid pattern, R-18 flags residual edges); NFR-01 budget target split physical→MOD / behavioral→FCHAIN; RULE_TO_DIMENSION completeness (R-18..R-23/R-26/MS-03/CR-R04 mapped, no advisory fall-through) (CR-228 B/D); +BQ-01/02/04/06/07 base-quality rules promoted from aimpro (K2-b, completes rule consolidation); +ND-01/02 near-duplicate + AO-D01/D03/CR-01/RT-01/PH-01/CA-01/IO-01 architecture rules promoted from aimpro (K2-b); +CR-R01..04/MS-03 change-request rules promoted from aimpro (K2-b); +FM-01..03/NFR-01 FMEA + VR-01/CL-01 view rules promoted from aimpro (K2-b); +MT-01..03 architecture metrics promoted from aimpro (K2-b); +SC-01..03/UC-01..06/FC-01..03 quality rules promoted from aimpro (K2-a); +RC-05 cross-module import drift (CR-212); +R-26/RC-03/RC-04 schemaRef (CR-211); +R-22..R-25/R-10/R-20 (CR-201/202/208/209/210)
+/** Meta-model version (trace pattern constraints + format-e parser). */
+export const META_MODEL_VERSION = '1.4.0'; // -REQ→MOD allocate pattern removed (CR-228 A); +FUNC→FUNC compose (blackbox function decomposition)
+export * from './ontology.js';
+export * from './rules.js';
+export * from './conformance-rules.js';
+export * from './schema-quality-rules.js';
+export * from './uc-quality-rules.js';
+export * from './fchain-quality-rules.js';
+export * from './metric-rules.js';
+export * from './fmea-rules.js';
+export * from './view-rules.js';
+export * from './cr-quality-rules.js';
+export * from './near-duplicate-rules.js';
+export * from './ao-rules.js';
+export * from './quality-rules.js';
+export * from './evaluate-all.js';
+export * from './readiness.js';
+export * from './meta-model.js';
+export * from './semantic-id.js';
+export * from './format-e-parser.js';

package/dist/se/meta-model.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SE Meta-Model — declarative table of valid trace patterns.
+ * Single source of truth for which ElementType pairs are valid for which TraceType.
+ * @sigloch/contracts/se
+ */
+import type { ElementType, TraceType } from './ontology.js';
+export interface TracePattern {
+    source: ElementType | '*';
+    target: ElementType | '*';
+    type: TraceType;
+    category?: 'modeling' | 'audit';
+    label?: string;
+    cardinality?: '1' | '1..*' | '0..*';
+    description: string;
+}
+export declare const TRACE_PATTERNS: TracePattern[];
+/**
+ * Check if a trace matches a valid pattern in the meta-model.
+ * Uses element types (not IDs) for validation.
+ */
+export declare function isValidTrace(trace: {
+    source: ElementType;
+    target: ElementType;
+    type: TraceType;
+    label?: string;
+}, patterns?: TracePattern[]): boolean;

package/dist/se/meta-model.js

@@ -0,0 +1,60 @@
+export const TRACE_PATTERNS = [
+    // ── compose (parent → child) ──
+    { source: 'SYS', target: 'SYS', type: 'compose', cardinality: '0..*', description: 'System decomposes into subsystems' },
+    { source: 'SYS', target: 'UC', type: 'compose', cardinality: '1..*', description: 'System decomposes into use cases' },
+    { source: 'SYS', target: 'REQ', type: 'compose', cardinality: '0..*', description: 'System-level requirements' },
+    { source: 'SYS', target: 'MOD', type: 'compose', cardinality: '0..*', description: 'System decomposes into modules' },
+    { source: 'MOD', target: 'MOD', type: 'compose', cardinality: '0..*', description: 'Module contains sub-module (e.g. ACL belongs to BC)' },
+    { source: 'UC', target: 'FCHAIN', type: 'compose', cardinality: '1..*', description: 'UC behavioral scenarios' },
+    { source: 'UC', target: 'REQ', type: 'compose', cardinality: '1..*', description: 'UC functional/non-functional requirements' },
+    { source: 'FCHAIN', target: 'FUNC', type: 'compose', cardinality: '1..*', description: 'Functions participating in chain' },
+    { source: 'FUNC', target: 'FUNC', type: 'compose', cardinality: '0..*', description: 'Function (blackbox architecture block) decomposes into sub-functions one level deeper; leaf FUNCs carry codeRef, the parent is realized by its children' },
+    { source: 'REQ', target: 'REQ', type: 'compose', cardinality: '0..*', description: 'Requirement decomposes into sub-requirements (incl. mitigation)' },
+    // ── io (data exchange, always through FLOW) ──
+    { source: 'ACTOR', target: 'FLOW', type: 'io', description: 'Actor triggers/receives via flow' },
+    { source: 'FLOW', target: 'ACTOR', type: 'io', description: 'Flow delivers to actor' },
+    { source: 'FUNC', target: 'FLOW', type: 'io', description: 'Function outputs to flow' },
+    { source: 'FLOW', target: 'FUNC', type: 'io', description: 'Flow feeds into function' },
+    { source: 'ACTOR', target: 'UC', type: 'io', description: 'Actor triggers use case' },
+    { source: 'FLOW', target: 'UC', type: 'io', description: 'Flow feeds use case' },
+    { source: 'MOD', target: 'MOD', type: 'io', description: 'Module communicates with module (ACL)' },
+    // ── satisfy (implementation) ──
+    { source: 'FUNC', target: 'REQ', type: 'satisfy', description: 'Function implements requirement' },
+    { source: 'FUNC', target: 'UC', type: 'satisfy', description: 'Function implements use case' },
+    // CR-154: NFR satisfy — non-functional REQs can be satisfied by chains, modules, or the system
+    { source: 'FCHAIN', target: 'REQ', type: 'satisfy', description: 'Function chain satisfies end-to-end NFR (e.g. latency)' },
+    { source: 'MOD', target: 'REQ', type: 'satisfy', description: 'Module satisfies budget NFR (e.g. uptime, memory)' },
+    { source: 'SYS', target: 'REQ', type: 'satisfy', description: 'System satisfies system-level NFR (e.g. availability)' },
+    // ── verify (INCOSE: test verifies requirement) ──
+    { source: 'TEST', target: 'REQ', type: 'verify', description: 'Test verifies requirement' },
+    // ── allocate (deployment/assignment) ──
+    { source: 'FUNC', target: 'MOD', type: 'allocate', description: 'Function deployed in module' },
+    { source: 'FLOW', target: 'SCHEMA', type: 'relation', description: 'Flow data format defined by schema' },
+    // CR-228: REQ→MOD allocate removed — a MOD does not own a REQ. Physical NFRs use
+    // MOD→satisfy→REQ, behavioral NFRs FCHAIN→satisfy→REQ; structural constraints are
+    // rules, not REQs. R-18 now flags any REQ→MOD allocate edge as invalid.
+    // ── MS (Milestone scope + dependencies, CR-181) ──
+    { source: 'MS', target: 'FUNC', type: 'compose', description: 'Milestone includes function' },
+    { source: 'MS', target: 'REQ', type: 'compose', description: 'Milestone includes requirement' },
+    { source: 'MS', target: 'UC', type: 'compose', description: 'Milestone includes use case' },
+    { source: 'MS', target: 'MS', type: 'compose', description: 'Sub-milestone' },
+    { source: 'MS', target: 'MS', type: 'relation', label: 'depends-on', description: 'Milestone dependency' },
+    { source: 'CR', target: 'MS', type: 'relation', description: 'CR assigned to milestone' },
+    // ── CR traceability (CR-155: CR tracks mutated elements) ──
+    { source: 'CR', target: 'UC', type: 'relation', description: 'CR affects use case' },
+    { source: 'CR', target: 'REQ', type: 'relation', description: 'CR affects requirement' },
+    { source: 'CR', target: 'FUNC', type: 'relation', description: 'CR affects function' },
+    { source: 'CR', target: 'MOD', type: 'relation', description: 'CR affects module' },
+    // ── produces (audit lineage) ──
+    { source: 'SESSION', target: '*', type: 'produces', category: 'audit', description: 'Session produced/modified element' },
+];
+/**
+ * Check if a trace matches a valid pattern in the meta-model.
+ * Uses element types (not IDs) for validation.
+ */
+export function isValidTrace(trace, patterns = TRACE_PATTERNS) {
+    return patterns.some(p => (p.source === '*' || p.source === trace.source) &&
+        (p.target === '*' || p.target === trace.target) &&
+        p.type === trace.type &&
+        (!p.label || p.label === trace.label));
+}