@transitrix/diagrams 1.0.0 → 1.0.1

package/dist/change/__tests__/validate.test.js

@@ -15,59 +15,65 @@ function valid() {
         valid_to: null,
     };
 }
-const codes = (input) => validateChange(input).errors.map(e => e.code);
+const codes = (input, opts) => validateChange(input, opts).errors.map(e => e.code);
 describe('validateChange — positive', () => {
-    it('accepts the worked-example CHANGE-EU-CRM-1', () => {
+    it('accepts a well-formed change', () => {
         const r = validateChange(valid());
         expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-        expect(r.errors).toHaveLength(0);
     });
-    it('accepts a minimal change (no goals, no parent)', () => {
-        const r = valid();
-        delete r.goals;
-        expect(validateChange(r).valid).toBe(true);
+    it('accepts a minimal change with no optional fields', () => {
+        const c = valid();
+        delete c.goals;
+        delete c.description;
+        expect(validateChange(c).valid).toBe(true);
     });
     it('accepts a child change with a CHANGE parent', () => {
-        expect(validateChange({ ...valid(), id: 'CHANGE-EU-CRM-DETAIL-1', parent: 'CHANGE-EU-CRM-1' }).valid).toBe(true);
+        const c = valid();
+        c.id = 'CHANGE-EU-CRM-2';
+        c.parent = 'CHANGE-EU-CRM-1';
+        expect(validateChange(c).valid).toBe(true);
     });
 });
-describe('validateChange — CHANGE-001 (envelope / shape)', () => {
-    it('flags a non-object', () => {
-        expect(codes(null)).toEqual(['CHANGE-001']);
+describe('validateChange — CHANGE-001 (shape / id grammar)', () => {
+    it('flags a missing required envelope field', () => {
+        const c = valid();
+        delete c.name;
+        expect(codes(c)).toContain('CHANGE-001');
     });
-    it('flags wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'gap' })).toContain('CHANGE-001');
+    it('flags an id that violates the grammar', () => {
+        expect(codes({ ...valid(), id: 'CHANGE-EU-CRM-001' })).toContain('CHANGE-001');
+        expect(codes({ ...valid(), id: 'CHG-1' })).toContain('CHANGE-001');
     });
-    it('flags an id with the wrong TYPE prefix', () => {
-        expect(codes({ ...valid(), id: 'ACTIVITY-DESIGN-1' })).toContain('CHANGE-001');
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'gap' })).toContain('CHANGE-001');
     });
-    it('flags a missing admission field', () => {
-        const r = valid();
-        delete r.admitted_at;
-        expect(codes(r)).toContain('CHANGE-001');
+    it('flags a non-array goals', () => {
+        expect(codes({ ...valid(), goals: 'GOAL-EU-1' })).toContain('CHANGE-001');
     });
-    it('flags a missing valid_to key', () => {
-        const r = valid();
-        delete r.valid_to;
-        expect(codes(r)).toContain('CHANGE-001');
+    it('rejects a non-object', () => {
+        expect(codes(null)).toEqual(['CHANGE-001']);
     });
 });
-describe('validateChange — CHANGE-002 (goals refs)', () => {
-    it('flags a non-GOAL typed id in goals', () => {
-        expect(codes({ ...valid(), goals: ['CHANGE-EU-CRM-1'] })).toContain('CHANGE-002');
-    });
-    it('flags a malformed entry in goals', () => {
+describe('validateChange — CHANGE-002 (goals references)', () => {
+    it('flags a malformed goals entry', () => {
         expect(codes({ ...valid(), goals: ['not an id'] })).toContain('CHANGE-002');
     });
-    it('flags goals when it is not an array', () => {
-        expect(codes({ ...valid(), goals: 'GOAL-EU-1' })).toContain('CHANGE-002');
+    it('flags a goals entry of the wrong TYPE', () => {
+        expect(codes({ ...valid(), goals: ['FACTOR-X-1'] })).toContain('CHANGE-002');
+    });
+    it('flags an unresolved id when a catalog is supplied', () => {
+        const catalog = { typeOf: () => undefined };
+        expect(codes(valid(), { catalog })).toContain('CHANGE-002');
     });
 });
-describe('validateChange — CHANGE-003 (parent ref)', () => {
-    it('flags a non-CHANGE parent', () => {
-        expect(codes({ ...valid(), parent: 'GOAL-EU-1' })).toContain('CHANGE-003');
+describe('validateChange — CHANGE-003 (parent)', () => {
+    it('flags a parent of the wrong TYPE', () => {
+        expect(codes({ ...valid(), parent: 'GOAL-X-1' })).toContain('CHANGE-003');
     });
-    it('flags self-parenting', () => {
+    it('flags a parent equal to self', () => {
         expect(codes({ ...valid(), parent: 'CHANGE-EU-CRM-1' })).toContain('CHANGE-003');
     });
+    it('flags a malformed parent', () => {
+        expect(codes({ ...valid(), parent: 'not an id' })).toContain('CHANGE-003');
+    });
 });

package/dist/change/index.d.ts

@@ -1,2 +1,3 @@
 export type { Change } from './types.js';
 export { validateChange } from './validate.js';
+export type { ChangeValidateOptions } from './validate.js';

package/dist/change/types.d.ts

@@ -5,7 +5,7 @@ export interface Change {
     name: string;
     /** GOAL-… IDs this change delivers. */
     goals?: string[];
-    /** CHANGE-… — the higher-scale change this one decomposes from. */
+    /** Higher-scale CHANGE this one decomposes from (recursive, §6.1). */
     parent?: string;
     description?: string;
     zone: 'canon';

package/dist/change/types.js

@@ -1,3 +1,3 @@
-// CHANGE — implementation-layer gap primitive (ArchiMate Gap).
-// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.3 + envelope §3.
+// CHANGE — implementation-layer Gap (ArchiMate). The BDN change layer.
+// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.3.
 export {};

package/dist/change/validate.d.ts

@@ -1,2 +1,7 @@
 import type { ValidationResult } from '../validation-types.js';
-export declare function validateChange(input: unknown): ValidationResult;
+import { type CanonCatalog } from '../typed-id.js';
+export interface ChangeValidateOptions {
+    /** When provided, enforces that each `goals` / `parent` id is admitted. */
+    catalog?: CanonCatalog;
+}
+export declare function validateChange(input: unknown, options?: ChangeValidateOptions): ValidationResult;

package/dist/change/validate.js

@@ -1,56 +1,83 @@
 // CHANGE validator — methodology notations/ELEMENT_PRIMITIVES.md §7.3.
 //
-// Implements CHANGE-001..003. Cross-cutting HDR-/LIFECYCLE- and the BDN
-// linkage rules across documents are owned elsewhere (CONTRACT.md §8) and
-// out of scope for this single-artefact validator.
-//
-// §7.3 defines no subtype vocabulary on `type`, so there is no enum gate here.
-import { typeOfId } from '../typed-id.js';
-import { validateElementEnvelope } from '../element-envelope.js';
-export function validateChange(input) {
+// Codes:
+//   CHANGE-001 — shape / id grammar / required envelope fields.
+//   CHANGE-002 — `goals` entry malformed or wrong TYPE (must be GOAL-…).
+//   CHANGE-003 — `parent` malformed, wrong TYPE (must be CHANGE-…), or equals self.
+import { typeOfId, isCanonicalIdOfType } from '../typed-id.js';
+const REQUIRED_STRING_FIELDS = [
+    'name', 'admitted_at', 'admitted_by', 'valid_from',
+];
+export function validateChange(input, options = {}) {
     const errors = [];
     const warnings = [];
-    const { record, errors: envErrors } = validateElementEnvelope(input, {
-        notation: 'change',
-        idType: 'CHANGE',
-        code: 'CHANGE-001',
-    });
-    errors.push(...envErrors);
-    if (!record)
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: 'CHANGE-001', message: 'Change must be a YAML mapping.' });
         return { valid: false, errors, warnings };
-    // CHANGE-002 — goals[] must be a list of GOAL typed ids.
-    if (record.goals !== undefined) {
-        if (!Array.isArray(record.goals)) {
-            errors.push({ code: 'CHANGE-002', message: 'goals must be a list of typed GOAL IDs.', path: 'goals' });
+    }
+    const c = input;
+    // CHANGE-001 — id grammar + notation tag + envelope.
+    if (!isCanonicalIdOfType(c.id, 'CHANGE')) {
+        errors.push({ code: 'CHANGE-001', message: `id "${String(c.id)}" must match CHANGE-[<middle>-]<INTEGER>.`, path: 'id' });
+    }
+    if (c.notation !== 'change') {
+        errors.push({ code: 'CHANGE-001', message: 'notation must be the fixed value "change".', path: 'notation' });
+    }
+    if (c.zone !== undefined && c.zone !== 'canon') {
+        errors.push({ code: 'CHANGE-001', message: 'zone must be "canon" for a CHANGE.', path: 'zone' });
+    }
+    else if (c.zone === undefined) {
+        errors.push({ code: 'CHANGE-001', message: 'zone is required.', path: 'zone' });
+    }
+    for (const field of REQUIRED_STRING_FIELDS) {
+        const v = c[field];
+        if (typeof v !== 'string' || v.trim() === '') {
+            errors.push({ code: 'CHANGE-001', message: `${field} is required.`, path: field });
+        }
+    }
+    if (c.gate_checks === null || typeof c.gate_checks !== 'object') {
+        errors.push({ code: 'CHANGE-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+    }
+    if (!('valid_to' in c) || !(typeof c.valid_to === 'string' || c.valid_to === null)) {
+        errors.push({ code: 'CHANGE-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+    }
+    // CHANGE-002 — `goals` references.
+    if (c.goals !== undefined) {
+        if (!Array.isArray(c.goals)) {
+            errors.push({ code: 'CHANGE-001', message: 'goals must be a list of typed IDs.', path: 'goals' });
         }
         else {
-            record.goals.forEach((ref, i) => {
-                if (typeOfId(ref) !== 'GOAL') {
-                    errors.push({
-                        code: 'CHANGE-002',
-                        message: `goals[${i}] "${String(ref)}" must be a GOAL typed ID.`,
-                        path: `goals[${i}]`,
-                    });
+            c.goals.forEach((ref, i) => {
+                const type = typeOfId(ref);
+                if (!type) {
+                    errors.push({ code: 'CHANGE-002', message: `goals[${i}] "${String(ref)}" is not a resolvable typed ID.`, path: `goals[${i}]` });
+                    return;
+                }
+                if (type !== 'GOAL') {
+                    errors.push({ code: 'CHANGE-002', message: `goals[${i}] TYPE "${type}" must be GOAL.`, path: `goals[${i}]` });
+                    return;
+                }
+                if (options.catalog && options.catalog.typeOf(ref) === undefined) {
+                    errors.push({ code: 'CHANGE-002', message: `goals[${i}] "${String(ref)}" does not resolve to an admitted artefact.`, path: `goals[${i}]` });
                 }
             });
         }
     }
-    // CHANGE-003 — parent must be a CHANGE typed id (multi-scale decomposition).
-    if (record.parent !== undefined) {
-        if (typeof record.parent !== 'string' || typeOfId(record.parent) !== 'CHANGE') {
-            errors.push({
-                code: 'CHANGE-003',
-                message: `parent "${String(record.parent)}" must be a CHANGE typed ID.`,
-                path: 'parent',
-            });
+    // CHANGE-003 — `parent` (CHANGE-…; not self).
+    if (c.parent !== undefined) {
+        const p = c.parent;
+        const type = typeOfId(p);
+        if (typeof p !== 'string' || !type) {
+            errors.push({ code: 'CHANGE-003', message: `parent "${String(p)}" is not a resolvable typed ID.`, path: 'parent' });
         }
-        else if (record.parent === record.id) {
-            // A change cannot decompose from itself.
-            errors.push({
-                code: 'CHANGE-003',
-                message: `parent "${record.parent}" must not equal id (a change cannot be its own parent).`,
-                path: 'parent',
-            });
+        else if (type !== 'CHANGE') {
+            errors.push({ code: 'CHANGE-003', message: `parent TYPE "${type}" must be CHANGE.`, path: 'parent' });
+        }
+        else if (typeof c.id === 'string' && p === c.id) {
+            errors.push({ code: 'CHANGE-003', message: `parent "${p}" must not equal the element's own id.`, path: 'parent' });
+        }
+        else if (options.catalog && options.catalog.typeOf(p) === undefined) {
+            errors.push({ code: 'CHANGE-003', message: `parent "${p}" does not resolve to an admitted CHANGE.`, path: 'parent' });
         }
     }
     return { valid: errors.length === 0, errors, warnings };

package/dist/compliance/__tests__/classify.test.js

@@ -11,6 +11,39 @@ describe('ingestComplianceDoc', () => {
         expect(canon.requirements[0]).toMatchObject({ id: 'REQUIREMENT-1', severity: 'high', derived_from: ['LAW-1'] });
         expect(canon.assertions[0]).toMatchObject({ id: 'ASSERTION-1', status: 'compliant', evidenceCount: 1 });
         expect(canon.codex[0]).toMatchObject({ id: 'LAW-1', type: 'LAW', jurisdiction: 'ge' });
+        expect(canon.subjects).toEqual([]);
+    });
+    it('ingests capability, process, application, system into canon.subjects', () => {
+        const canon = emptyCanon();
+        expect(ingestComplianceDoc(canon, { notation: 'capability', id: 'CAPABILITY-V2', name: 'CRM' })).toBe('CAPABILITY-V2');
+        expect(ingestComplianceDoc(canon, { notation: 'process', id: 'PROCESS-CS-1', name: 'Support' })).toBe('PROCESS-CS-1');
+        expect(ingestComplianceDoc(canon, { notation: 'application', id: 'APP-ERP-1', name: 'ERP System' })).toBe('APP-ERP-1');
+        expect(ingestComplianceDoc(canon, { notation: 'system', id: 'SYSTEM-IAM-1', name: 'IAM' })).toBe('SYSTEM-IAM-1');
+        expect(canon.subjects).toEqual([
+            { id: 'CAPABILITY-V2', name: 'CRM' },
+            { id: 'PROCESS-CS-1', name: 'Support' },
+            { id: 'APP-ERP-1', name: 'ERP System' },
+            { id: 'SYSTEM-IAM-1', name: 'IAM' },
+        ]);
+        expect(canon.products).toEqual([]);
+    });
+    it('falls back to id when name is absent for subjects', () => {
+        const canon = emptyCanon();
+        ingestComplianceDoc(canon, { notation: 'capability', id: 'CAPABILITY-X-1' });
+        expect(canon.subjects[0]).toEqual({ id: 'CAPABILITY-X-1', name: 'CAPABILITY-X-1' });
+    });
+    it('captures owner_to_confirm on pending_owner assertions', () => {
+        const canon = emptyCanon();
+        ingestComplianceDoc(canon, {
+            notation: 'assertion', id: 'ASSERTION-PO-1',
+            about: 'REQUIREMENT-1', subject: 'PRODUCT-1',
+            status: 'pending_owner', owner_to_confirm: 'alice@example.com',
+        });
+        expect(canon.assertions[0]).toMatchObject({
+            id: 'ASSERTION-PO-1',
+            status: 'pending_owner',
+            owner_to_confirm: 'alice@example.com',
+        });
     });
     it('returns null for non-artefacts, missing id, and malformed assertions', () => {
         const canon = emptyCanon();
@@ -20,5 +53,6 @@ describe('ingestComplianceDoc', () => {
         expect(ingestComplianceDoc(canon, null)).toBeNull();
         expect(ingestComplianceDoc(canon, 'str')).toBeNull();
         expect(canon.products).toEqual([]);
+        expect(canon.subjects).toEqual([]);
     });
 });

package/dist/compliance/__tests__/coverage-metric.test.js

@@ -8,17 +8,14 @@ describe('parseCoverageMetricConfig', () => {
         expect(r.ok).toBe(false);
     });
     it('rejects missing id', () => {
-        const r = parseCoverageMetricConfig({ coverage_metric: { name: 'x' } });
+        const r = parseCoverageMetricConfig({ view: { name: 'x' } });
         expect(r.ok).toBe(false);
         if (!r.ok)
             expect(r.errors.some(e => e.includes('id'))).toBe(true);
     });
-    it('parses minimal config', () => {
+    it('parses minimal config via view: wrapper', () => {
         const r = parseCoverageMetricConfig({
-            coverage_metric: {
-                id: 'CM-1',
-                name: 'Test',
-            },
+            view: { id: 'CM-1', name: 'Test' },
         });
         expect(r.ok).toBe(true);
         if (r.ok) {
@@ -26,47 +23,105 @@ describe('parseCoverageMetricConfig', () => {
             expect(r.config.name).toBe('Test');
             expect(r.config.thresholds.green).toBe(0.8);
             expect(r.config.thresholds.amber).toBe(0.5);
+            expect(r.config.regimes).toBeUndefined();
         }
     });
-    it('parses full config with scope and thresholds', () => {
+    it('parses view: wrapper with regimes.include and subjects', () => {
         const r = parseCoverageMetricConfig({
-            coverage_metric: {
+            view: {
                 id: 'CM-2',
                 name: 'EU Coverage',
                 description: 'desc',
-                scope: {
-                    jurisdictions: ['EU'],
-                    codex: ['LAW-GDPR-1'],
-                    subjects: { products: ['PRODUCT-1'] },
-                },
+                regimes: { include: ['LAW-GDPR-1'] },
+                subjects: { products: ['PRODUCT-1'] },
                 thresholds: { green: 0.9, amber: 0.6 },
             },
         });
         expect(r.ok).toBe(true);
         if (r.ok) {
-            expect(r.config.scope.codex).toEqual(['LAW-GDPR-1']);
-            expect(r.config.scope.subjects?.products).toEqual(['PRODUCT-1']);
+            expect(r.config.regimes?.include).toEqual(['LAW-GDPR-1']);
+            expect(r.config.subjects?.products).toEqual(['PRODUCT-1']);
             expect(r.config.thresholds.green).toBe(0.9);
             expect(r.config.thresholds.amber).toBe(0.6);
+            expect(r.config.warnings).toBeUndefined();
+        }
+    });
+    it('parses view: wrapper with regimes.filter', () => {
+        const r = parseCoverageMetricConfig({
+            view: {
+                id: 'CM-3',
+                name: 'EU Filter',
+                regimes: { filter: { jurisdiction: ['EU'], codex_type: ['regulation'] } },
+            },
+        });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.config.regimes?.filter?.jurisdiction).toEqual(['EU']);
+            expect(r.config.regimes?.filter?.codex_type).toEqual(['regulation']);
+            expect(r.config.regimes?.include).toBeUndefined();
+        }
+    });
+    it('warns COVMET-007 when both regimes.include and regimes.filter are set', () => {
+        const r = parseCoverageMetricConfig({
+            view: {
+                id: 'CM-4',
+                name: 'Both',
+                regimes: {
+                    include: ['LAW-GDPR-1'],
+                    filter: { jurisdiction: ['EU'] },
+                },
+            },
+        });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.config.warnings?.some(w => w.includes('COVMET-007'))).toBe(true);
         }
     });
-    it('accepts bare (unwrapped) object', () => {
-        const r = parseCoverageMetricConfig({ id: 'CM-3', name: 'Bare' });
+    it('accepts bare (unwrapped) object without wrapper warning', () => {
+        const r = parseCoverageMetricConfig({ id: 'CM-5', name: 'Bare' });
         expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.config.warnings?.some(w => w.includes('COVMET-DEPRECATED'))).toBeFalsy();
+        }
+    });
+    // ── Backward compatibility: deprecated coverage_metric: wrapper ──────────────
+    it('accepts deprecated coverage_metric: wrapper with COVMET-DEPRECATED warning', () => {
+        const r = parseCoverageMetricConfig({
+            coverage_metric: { id: 'CM-6', name: 'Legacy' },
+        });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.config.warnings?.some(w => w.includes('COVMET-DEPRECATED'))).toBe(true);
+        }
+    });
+    it('maps deprecated scope.codex to regimes.include', () => {
+        const r = parseCoverageMetricConfig({
+            coverage_metric: {
+                id: 'CM-7',
+                name: 'Legacy Scope',
+                scope: {
+                    codex: ['LAW-GDPR-1', 'LAW-NIS2-1'],
+                    subjects: { products: ['PRODUCT-1'] },
+                },
+                thresholds: { green: 0.9, amber: 0.6 },
+            },
+        });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.config.regimes?.include).toEqual(['LAW-GDPR-1', 'LAW-NIS2-1']);
+            expect(r.config.subjects?.products).toEqual(['PRODUCT-1']);
+            expect(r.config.thresholds.green).toBe(0.9);
+        }
     });
 });
 // ── buildCoverageMatrix ───────────────────────────────────────────────────────
 function makeCanon() {
     const canon = emptyCanon();
-    // Codex: GDPR law
     ingestComplianceDoc(canon, { id: 'LAW-GDPR-1', name: 'GDPR', zone: 'codex', jurisdiction: 'EU' });
-    // Requirements
     ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-1', name: 'Lawful basis', derived_from: ['LAW-GDPR-1'] });
     ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-2', name: 'Data minimisation', derived_from: ['LAW-GDPR-1'] });
     ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-3', name: 'Breach notification', derived_from: ['LAW-GDPR-1'] });
-    // Products
     ingestComplianceDoc(canon, { notation: 'product', id: 'PRODUCT-1', name: 'E-commerce' });
-    // Assertions
     ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-1', about: 'REQ-1', subject: 'PRODUCT-1', status: 'compliant' });
     ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-2', about: 'REQ-2', subject: 'PRODUCT-1', status: 'partial' });
     // REQ-3 has no assertion → gap
@@ -76,19 +131,15 @@ function makeConfig(overrides) {
     return {
         id: 'CM-TEST-1',
         name: 'Test Coverage',
-        scope: {
-            codex: ['LAW-GDPR-1'],
-            subjects: { products: ['PRODUCT-1'] },
-        },
+        regimes: { include: ['LAW-GDPR-1'] },
+        subjects: { products: ['PRODUCT-1'] },
         thresholds: { green: 0.8, amber: 0.5 },
         ...overrides,
     };
 }
 describe('buildCoverageMatrix', () => {
     it('returns correct row counts', () => {
-        const canon = makeCanon();
-        const config = makeConfig();
-        const matrix = buildCoverageMatrix(canon, config);
+        const matrix = buildCoverageMatrix(makeCanon(), makeConfig());
         expect(matrix.rows).toHaveLength(1);
         const row = matrix.rows[0];
         expect(row.codexId).toBe('LAW-GDPR-1');
@@ -99,18 +150,14 @@ describe('buildCoverageMatrix', () => {
         expect(row.coveredCount).toBe(2);
     });
     it('computes coverage percentage correctly', () => {
-        const matrix = buildCoverageMatrix(makeCanon(), makeConfig());
-        const row = matrix.rows[0];
-        // 2 covered out of 3 → ~66.7%
+        const row = buildCoverageMatrix(makeCanon(), makeConfig()).rows[0];
         expect(row.coveragePct).toBeCloseTo(2 / 3, 5);
     });
     it('assigns amber RAG status for ~67% coverage with green=0.80, amber=0.50', () => {
-        const matrix = buildCoverageMatrix(makeCanon(), makeConfig());
-        expect(matrix.rows[0].ragStatus).toBe('amber');
+        expect(buildCoverageMatrix(makeCanon(), makeConfig()).rows[0].ragStatus).toBe('amber');
     });
     it('assigns green RAG when all requirements covered', () => {
         const canon = makeCanon();
-        // Add assertion for REQ-3 so all 3 are covered
         ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-3', about: 'REQ-3', subject: 'PRODUCT-1', status: 'compliant' });
         const matrix = buildCoverageMatrix(canon, makeConfig());
         expect(matrix.rows[0].ragStatus).toBe('green');
@@ -118,38 +165,35 @@ describe('buildCoverageMatrix', () => {
     });
     it('assigns red RAG when coverage < amber threshold', () => {
         const matrix = buildCoverageMatrix(makeCanon(), makeConfig({ thresholds: { green: 0.9, amber: 0.8 } }));
-        // ~67% < 80% → red
         expect(matrix.rows[0].ragStatus).toBe('red');
     });
     it('returns no_data when codex has no requirements', () => {
         const canon = emptyCanon();
         ingestComplianceDoc(canon, { id: 'LAW-EMPTY-1', name: 'Empty Law', zone: 'codex', jurisdiction: 'XX' });
-        const config = makeConfig({ scope: { codex: ['LAW-EMPTY-1'] } });
-        const matrix = buildCoverageMatrix(canon, config);
+        const matrix = buildCoverageMatrix(canon, makeConfig({ regimes: { include: ['LAW-EMPTY-1'] } }));
         expect(matrix.rows[0].ragStatus).toBe('no_data');
         expect(matrix.rows[0].totalRequirements).toBe(0);
     });
     it('includes jurisdiction from scanned canon', () => {
-        const matrix = buildCoverageMatrix(makeCanon(), makeConfig());
-        expect(matrix.rows[0].jurisdiction).toBe('EU');
+        expect(buildCoverageMatrix(makeCanon(), makeConfig()).rows[0].jurisdiction).toBe('EU');
     });
-    it('handles multiple codex entries', () => {
+    it('handles multiple codex entries via regimes.include', () => {
         const canon = makeCanon();
         ingestComplianceDoc(canon, { id: 'LAW-NIS2-1', name: 'NIS2', zone: 'codex', jurisdiction: 'EU' });
         ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-NIS-1', name: 'Incident reporting', derived_from: ['LAW-NIS2-1'] });
-        const config = makeConfig({ scope: { codex: ['LAW-GDPR-1', 'LAW-NIS2-1'] } });
-        const matrix = buildCoverageMatrix(canon, config);
+        const matrix = buildCoverageMatrix(canon, makeConfig({ regimes: { include: ['LAW-GDPR-1', 'LAW-NIS2-1'] } }));
         expect(matrix.rows).toHaveLength(2);
         expect(matrix.rows[1].codexId).toBe('LAW-NIS2-1');
         expect(matrix.rows[1].gap).toBe(1);
     });
     it('respects product scope — ignores assertions for other products', () => {
         const canon = makeCanon();
-        // Add another product with compliant assertion for REQ-3
         ingestComplianceDoc(canon, { notation: 'product', id: 'PRODUCT-2', name: 'Support' });
         ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-OUT', about: 'REQ-3', subject: 'PRODUCT-2', status: 'compliant' });
-        // config only scopes PRODUCT-1 → REQ-3 should still be a gap
-        const matrix = buildCoverageMatrix(canon, makeConfig({ scope: { codex: ['LAW-GDPR-1'], subjects: { products: ['PRODUCT-1'] } } }));
+        const matrix = buildCoverageMatrix(canon, makeConfig({
+            regimes: { include: ['LAW-GDPR-1'] },
+            subjects: { products: ['PRODUCT-1'] },
+        }));
         expect(matrix.rows[0].gap).toBe(1);
     });
     it('counts non_compliant separately', () => {
@@ -158,7 +202,63 @@ describe('buildCoverageMatrix', () => {
         const matrix = buildCoverageMatrix(canon, makeConfig());
         expect(matrix.rows[0].non_compliant).toBe(1);
         expect(matrix.rows[0].gap).toBe(0);
-        // non_compliant does not count as covered
         expect(matrix.rows[0].coveredCount).toBe(2);
     });
+    it('counts pending_owner separately and does not include it in coveredCount', () => {
+        const canon = makeCanon();
+        ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-PO', about: 'REQ-3', subject: 'PRODUCT-1', status: 'pending_owner', owner_to_confirm: 'alice' });
+        const matrix = buildCoverageMatrix(canon, makeConfig());
+        expect(matrix.rows[0].pending_owner).toBe(1);
+        expect(matrix.rows[0].gap).toBe(0);
+        expect(matrix.rows[0].coveredCount).toBe(2);
+    });
+    // ── regimes.filter ───────────────────────────────────────────────────────────
+    it('resolves codex via regimes.filter.jurisdiction', () => {
+        const canon = makeCanon();
+        ingestComplianceDoc(canon, { id: 'LAW-CCPA-1', name: 'CCPA', zone: 'codex', jurisdiction: 'US' });
+        // regimes.filter: only EU laws → should return LAW-GDPR-1 only
+        const matrix = buildCoverageMatrix(canon, makeConfig({
+            regimes: { filter: { jurisdiction: ['EU'] } },
+        }));
+        expect(matrix.rows.every(r => r.codexId !== 'LAW-CCPA-1')).toBe(true);
+        expect(matrix.rows.some(r => r.codexId === 'LAW-GDPR-1')).toBe(true);
+    });
+    it('resolves codex via regimes.filter.codex_type', () => {
+        const canon = emptyCanon();
+        ingestComplianceDoc(canon, { id: 'LAW-A', name: 'Regulation A', zone: 'codex', type: 'regulation' });
+        ingestComplianceDoc(canon, { id: 'LAW-B', name: 'Standard B', zone: 'codex', type: 'standard' });
+        const matrix = buildCoverageMatrix(canon, makeConfig({
+            regimes: { filter: { codex_type: ['regulation'] } },
+        }));
+        expect(matrix.rows.map(r => r.codexId)).toEqual(['LAW-A']);
+    });
+    // ── Zero-config: all canon codex entries ─────────────────────────────────────
+    it('zero-config (no regimes) enumerates all canon codex', () => {
+        const canon = makeCanon();
+        ingestComplianceDoc(canon, { id: 'LAW-NIS2-1', name: 'NIS2', zone: 'codex', jurisdiction: 'EU' });
+        const matrix = buildCoverageMatrix(canon, makeConfig({ regimes: undefined }));
+        expect(matrix.rows.map(r => r.codexId)).toContain('LAW-GDPR-1');
+        expect(matrix.rows.map(r => r.codexId)).toContain('LAW-NIS2-1');
+    });
+    // ── Backward compat: deprecated config still produces correct matrix ─────────
+    it('deprecated scope.codex via parseCoverageMetricConfig maps to correct matrix', () => {
+        const r = parseCoverageMetricConfig({
+            coverage_metric: {
+                id: 'CM-LEGACY',
+                name: 'Legacy',
+                scope: {
+                    codex: ['LAW-GDPR-1'],
+                    subjects: { products: ['PRODUCT-1'] },
+                },
+                thresholds: { green: 0.8, amber: 0.5 },
+            },
+        });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            const matrix = buildCoverageMatrix(makeCanon(), r.config);
+            expect(matrix.rows).toHaveLength(1);
+            expect(matrix.rows[0].codexId).toBe('LAW-GDPR-1');
+            expect(matrix.rows[0].coveredCount).toBe(2);
+        }
+    });
 });

package/dist/compliance/__tests__/html.test.js

@@ -104,7 +104,7 @@ describe('renderImpactMatrixHtml (CV-6)', () => {
         ingestComplianceDoc(canon, { notation: 'product', id: 'PROD-1', name: 'Product One' });
         ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-1', name: 'Req One', severity: 'high' });
         ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASS-1', about: 'REQ-1', subject: 'PROD-1', status: 'compliant' });
-        const matrix = buildImpactMatrix({ products: canon.products, requirements: canon.requirements, assertions: canon.assertions, codex: canon.codex }, { id: 'VIEW-1', name: 'My View', subjects: { products: ['PROD-1'] }, obligations: {} });
+        const matrix = buildImpactMatrix({ products: canon.products, requirements: canon.requirements, assertions: canon.assertions, codex: canon.codex, subjects: canon.subjects }, { id: 'VIEW-1', name: 'My View', subjects: { products: ['PROD-1'] }, obligations: {} });
         const html = renderImpactMatrixHtml(matrix, { today: '2026-06-09' });
         expect(html).toContain('<table>');
         expect(html).toContain('My View');
@@ -115,7 +115,7 @@ describe('renderImpactMatrixHtml (CV-6)', () => {
         const canon = emptyCanon();
         ingestComplianceDoc(canon, { notation: 'product', id: 'PROD-1', name: 'P1' });
         ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQ-1', name: 'R1' });
-        const matrix = buildImpactMatrix({ products: canon.products, requirements: canon.requirements, assertions: canon.assertions, codex: canon.codex }, { id: 'V2', name: 'V2', subjects: { products: ['PROD-1'] }, obligations: {} });
+        const matrix = buildImpactMatrix({ products: canon.products, requirements: canon.requirements, assertions: canon.assertions, codex: canon.codex, subjects: canon.subjects }, { id: 'V2', name: 'V2', subjects: { products: ['PROD-1'] }, obligations: {} });
         const html = renderImpactMatrixHtml(matrix);
         expect(html).toContain('No mapped obligation');
     });