@transitrix/diagrams 1.0.1 → 1.1.0

package/dist/activities/cpm.js

@@ -2,6 +2,15 @@ export function computeCpm(activities) {
     const result = new Map();
     if (activities.length === 0)
         return result;
+    // When no activity carries any duration data, critical path is indeterminate —
+    // return all non-critical so the diagram renders in default grey.
+    const hasDuration = activities.some((a) => (a.duration !== undefined && a.duration !== null) || (a.duration_days !== undefined && a.duration_days !== null));
+    if (!hasDuration) {
+        for (const a of activities) {
+            result.set(a.id, { es: 0, ef: 0, ls: 0, lf: 0, slack: 0, isCritical: false });
+        }
+        return result;
+    }
     // Build successor map and in-degree for topological sort
     const successors = new Map();
     const predecessors = new Map();
@@ -41,7 +50,7 @@ export function computeCpm(activities) {
     const ef = new Map();
     for (const id of topoOrder) {
         const a = actById.get(id);
-        const dur = a.duration ?? 0;
+        const dur = a.duration ?? a.duration_days ?? 0;
         const maxPredEf = Math.max(0, ...(predecessors.get(id) ?? []).map(p => ef.get(p) ?? 0));
         es.set(id, maxPredEf);
         ef.set(id, maxPredEf + dur);
@@ -53,7 +62,7 @@ export function computeCpm(activities) {
     const lf = new Map();
     for (const id of [...topoOrder].reverse()) {
         const a = actById.get(id);
-        const dur = a.duration ?? 0;
+        const dur = a.duration ?? a.duration_days ?? 0;
         const succs = successors.get(id) ?? [];
         const minSuccLs = succs.length === 0 ? projectFinish : Math.min(...succs.map(s => ls.get(s) ?? projectFinish));
         lf.set(id, minSuccLs);

package/dist/activities/gantt.js

@@ -86,7 +86,10 @@ function detectMode(doc, leaves) {
     if (allPinned)
         return 'pinned';
     const hasProjectStart = typeof doc.project?.start_date === 'string' && doc.project.start_date.length > 0;
-    const allHaveDuration = leaves.every((a) => typeof a.duration === 'number' && Number.isFinite(a.duration) && a.duration >= 0);
+    const allHaveDuration = leaves.every((a) => {
+        const d = a.duration ?? a.duration_days;
+        return typeof d === 'number' && Number.isFinite(d) && d >= 0;
+    });
     if (hasProjectStart && allHaveDuration)
         return 'computed';
     return null;
@@ -111,7 +114,7 @@ export function computeGanttLayout(doc) {
         for (const a of leaves) {
             const startDate = a.start_date;
             const endDate = a.end_date;
-            const isMilestone = a.duration === 0 || startDate === endDate;
+            const isMilestone = (a.duration ?? a.duration_days) === 0 || startDate === endDate;
             const bar = {
                 id: a.id,
                 name: a.name,
@@ -134,7 +137,7 @@ export function computeGanttLayout(doc) {
         for (const a of leaves) {
             const c = cpm.get(a.id);
             const es = c?.es ?? 0;
-            const dur = a.duration ?? 0;
+            const dur = a.duration ?? a.duration_days ?? 0;
             const startDate = nthWorkingDay(projectStart, es, calendar);
             const endDate = dur === 0
                 ? startDate

package/dist/activities/types.d.ts

@@ -6,6 +6,7 @@ export interface Activity {
     id: string;
     name: string;
     duration?: number;
+    duration_days?: number;
     activity_type?: string;
     goals?: string[];
     scenario?: string;

package/dist/activities/validate.js

@@ -113,7 +113,7 @@ export function validateActivities(input) {
             idSet.add(id);
         }
         // ACT-009: non-negative numeric fields
-        const numericFields = ['duration', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort'];
+        const numericFields = ['duration', 'duration_days', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort'];
         for (const field of numericFields) {
             const val = act[field];
             if (val !== undefined && val !== null) {
@@ -122,8 +122,8 @@ export function validateActivities(input) {
                 }
             }
         }
-        // ACT-011: warn if no duration
-        if (act.duration === undefined || act.duration === null) {
+        // ACT-011: warn if no duration (duration_days is accepted as an alias)
+        if ((act.duration === undefined || act.duration === null) && (act.duration_days === undefined || act.duration_days === null)) {
             warnings.push({ code: 'ACT-011', message: `Activity "${id}" has no duration — cannot participate in CPM analysis`, path });
         }
     }

package/dist/activity-card/__tests__/resolver.test.js

@@ -38,7 +38,7 @@ const UNRELATED = {
     name: 'Other',
     parent: 'ACTIVITY-SOMETHING-ELSE-1',
 };
-const FACTOR = { notation: 'factor', id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' };
+const FACTOR = { notation: 'driver', id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' };
 const GOAL = { notation: 'goal', id: 'GOAL-EU-MARKET-1', name: 'Access EU market', factors: ['FACTOR-EU-MDR-1'] };
 const CHANGE = {
     notation: 'change',
@@ -212,6 +212,27 @@ describe('resolveActivityCard', () => {
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
     });
+    it('PC-001 diagnostic discloses paths searched and actionable hint (#344)', () => {
+        const r = resolveActivityCard(CARD, { elements: [FACTOR, GOAL, CHANGE], relations });
+        const pc001 = r.errors.find((e) => e.code === 'PC-001');
+        expect(pc001).toBeDefined();
+        // Must disclose both searched paths (§7 PC-001)
+        expect(pc001.message).toContain('canon/elements/**');
+        expect(pc001.message).toContain('canon/views/activities/**');
+        // Must include actionable hint with expected file pattern (§7 PC-001)
+        expect(pc001.message).toContain('notation: activity');
+        expect(pc001.message).toContain(`id: "${CARD.activity_card.project}"`);
+    });
+    it('resolves without PC-001 when project activity lives in a deep canon/elements subfolder (#344)', () => {
+        // Regression: the resolver must accept elements regardless of which subfolder
+        // they were loaded from (e.g. canon/elements/05_implementation/activities/).
+        // The resolver is filesystem-free, so we simulate the deep-path scenario by
+        // including the PROJECT element in the elements pool — just as loadCanon does
+        // after walking canon/elements/** recursively.
+        const r = resolveActivityCard(CARD, sources);
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+        expect(r.errors.some((e) => e.code === 'PC-001')).toBe(false);
+    });
     it('resolves activity_type and status from the Activity element', () => {
         const r = resolveActivityCard(CARD, {
             elements: [{ ...PROJECT, activity_type: 'programme', status: 'on_track' }, CHILD, FACTOR, GOAL, CHANGE],

package/dist/activity-card/resolver.js

@@ -148,11 +148,16 @@ export function resolveActivityCard(doc, sources) {
     }
     const activities = collectByNotation(sources.elements, 'activity');
     const projectRec = activities.get(projectId);
-    // PC-001 — project must resolve to an admitted ACTIVITY element in canon.
+    // PC-001 — project must resolve to an admitted ACTIVITY element after
+    // exhausting the canonical resolution scope (§6.1): canon/elements/**
+    // recursively first, then canon/views/activities/** as secondary fallback.
     if (!projectRec) {
         errors.push({
             code: 'PC-001',
-            message: `activity_card.project "${projectId}" does not resolve to an ACTIVITY element in the canon element store`,
+            message: `activity_card.project "${projectId}" not found after searching ` +
+                `canon/elements/** and canon/views/activities/** — ` +
+                `add a YAML file with notation: activity and id: "${projectId}" ` +
+                `(e.g. canon/elements/05_implementation/activities/${projectId}.yaml)`,
         });
         return { valid: false, errors, warnings };
     }
@@ -247,9 +252,10 @@ export function resolveActivityCard(doc, sources) {
         return { valid: false, errors, warnings };
     }
     // ── Motivation chain — expand against canon DRIVER / GOAL / CHANGE elements ──
-    // Note: YAML corpus still uses `notation: factor` and `goal.factors` field names;
-    // the YAML keys are stable. The resolved TypeScript API uses "driver/driverIds".
-    const driverElems = collectByNotation(sources.elements, 'factor');
+    // Canon elements use `notation: driver`; `notation: factor` accepted for backward compat.
+    const driverElemsLegacy = collectByNotation(sources.elements, 'factor');
+    const driverElemsNew = collectByNotation(sources.elements, 'driver');
+    const driverElems = new Map([...driverElemsLegacy, ...driverElemsNew]);
     const goalElems = collectByNotation(sources.elements, 'goal');
     const changeElems = collectByNotation(sources.elements, 'change');
     const changes = [];

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

@@ -713,3 +713,201 @@ describe('mergeStageTaskDetails', () => {
         expect(merged.details[1].tasks).toBeUndefined();
     });
 });
+// ── COMPIMP-010 — subject type label invariant (#345) ────────────────────────
+describe('COMPIMP-010 — subject type label invariant (#345)', () => {
+    it('process-only view: columns carry subjectType=process and plain ID labels (regression)', () => {
+        const canon = emptyCanon();
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        canon.requirements.push({ id: 'REQ-1', name: 'R1' });
+        canon.assertions.push({ id: 'ASS-1', about: 'REQ-1', subject: 'PROCESS-CS-1', status: 'compliant' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'Process-only',
+            subjects: { processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        expect(matrix.columns).toHaveLength(1);
+        expect(matrix.columns[0].subjectType).toBe('process');
+        // Process-only: label is just the ID — no [PRODUCT] prefix (regression)
+        expect(matrix.columns[0].label).toBe('PROCESS-CS-1');
+        expect(matrix.columns[0].label).not.toContain('[PRODUCT]');
+        expect(matrix.cells[0][0].status).toBe('compliant');
+    });
+    it('product-only view: columns carry subjectType=product and plain ID labels', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.requirements.push({ id: 'REQ-1', name: 'R1' });
+        canon.assertions.push({ id: 'ASS-1', about: 'REQ-1', subject: 'PRODUCT-A-1', status: 'compliant' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'Product-only',
+            subjects: { products: ['PRODUCT-A-1'] },
+            obligations: {},
+        });
+        expect(matrix.columns[0].subjectType).toBe('product');
+        expect(matrix.columns[0].label).toBe('PRODUCT-A-1');
+        expect(matrix.columns[0].label).not.toContain('[PROCESS]');
+        expect(matrix.findings).toHaveLength(0);
+    });
+    it('combined view: product columns carry [PRODUCT] badge; process columns carry [PROCESS] badge', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        canon.requirements.push({ id: 'REQ-1', name: 'R1' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'Combined',
+            subjects: { products: ['PRODUCT-A-1'], processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        expect(matrix.columns).toHaveLength(2);
+        const prodCol = matrix.columns.find(c => c.subjectId === 'PRODUCT-A-1');
+        const procCol = matrix.columns.find(c => c.subjectId === 'PROCESS-CS-1');
+        expect(prodCol.subjectType).toBe('product');
+        expect(prodCol.label).toBe('[PRODUCT] PRODUCT-A-1');
+        expect(procCol.subjectType).toBe('process');
+        expect(procCol.label).toBe('[PROCESS] PROCESS-CS-1');
+    });
+    it('combined view: markdown renders [PRODUCT] / [PROCESS] column headers', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        canon.requirements.push({ id: 'REQ-1', name: 'R1' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'Combined',
+            subjects: { products: ['PRODUCT-A-1'], processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        const md = renderImpactMarkdown(matrix);
+        expect(md).toContain('[PRODUCT] PRODUCT-A-1');
+        expect(md).toContain('[PROCESS] PROCESS-CS-1');
+    });
+    it('capability column always has subjectType=capability', () => {
+        const canon = emptyCanon();
+        canon.subjects.push({ id: 'CAPABILITY-CRM-1', name: 'CRM' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'Cap',
+            subjects: { capabilities: ['CAPABILITY-CRM-1'] },
+            obligations: {},
+        });
+        expect(matrix.columns[0].subjectType).toBe('capability');
+    });
+    it('COMPIMP-009 warning: product-* grouping with process-only subjects', () => {
+        const canon = emptyCanon();
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'CS' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            subjects: { processes: ['PROCESS-CS-1'] },
+            obligations: {},
+            grouping: { columns: 'product' },
+        });
+        const c009 = matrix.findings.find(f => f.code === 'COMPIMP-009');
+        expect(c009).toBeDefined();
+        expect(c009.severity).toBe('warning');
+        expect(c009.message).toContain('process');
+    });
+    it('COMPIMP-010 error: product-stage grouping with process subjects', () => {
+        const canon = emptyCanon();
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'CS' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            subjects: { processes: ['PROCESS-CS-1'] },
+            obligations: {},
+            grouping: { columns: 'product-stage' },
+        }, [{ objectId: 'PROCESS-CS-1', details: [{ id: 'STAGE-A', name: 'Stage A' }] }]);
+        const c010 = matrix.findings.find(f => f.code === 'COMPIMP-010');
+        expect(c010).toBeDefined();
+        expect(c010.severity).toBe('error');
+        expect(c010.message).toContain('process-stage');
+    });
+    it('no COMPIMP-010 when process-stage grouping is used for process subjects', () => {
+        const canon = emptyCanon();
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'CS' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            subjects: { processes: ['PROCESS-CS-1'] },
+            obligations: {},
+            grouping: { columns: 'process-stage' },
+        }, [{ objectId: 'PROCESS-CS-1', details: [{ id: 'STAGE-A', name: 'Stage A' }] }]);
+        expect(matrix.findings.some(f => f.code === 'COMPIMP-010')).toBe(false);
+    });
+    it('parseImpactViewConfig accepts process-centric column values', () => {
+        for (const col of ['process', 'process-stage', 'process-stage-task']) {
+            const r = parseImpactViewConfig({ id: 'V', name: 'V', subjects: {}, grouping: { columns: col } });
+            expect(r.ok).toBe(true);
+            if (r.ok)
+                expect(r.config.grouping?.columns).toBe(col);
+        }
+    });
+    it('matrix.findings is empty for a conformant product-only view', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            subjects: { products: ['PRODUCT-A-1'] },
+            obligations: {},
+        });
+        expect(matrix.findings).toEqual([]);
+    });
+    it('COMPIMP-011 error: report_type=product with subjects.processes strips process columns', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            report_type: 'product',
+            subjects: { products: ['PRODUCT-A-1'], processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        // COMPIMP-011 fires
+        const c011 = matrix.findings.find(f => f.code === 'COMPIMP-011');
+        expect(c011).toBeDefined();
+        expect(c011.severity).toBe('error');
+        // Spurious PROCESS column is stripped
+        expect(matrix.columns).toHaveLength(1);
+        expect(matrix.columns[0].subjectType).toBe('product');
+        expect(matrix.columns[0].subjectId).toBe('PRODUCT-A-1');
+    });
+    it('COMPIMP-011 error: report_type=process with subjects.products strips product columns', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            report_type: 'process',
+            subjects: { products: ['PRODUCT-A-1'], processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        const c011 = matrix.findings.find(f => f.code === 'COMPIMP-011');
+        expect(c011).toBeDefined();
+        expect(c011.severity).toBe('error');
+        // Spurious PRODUCT column is stripped
+        expect(matrix.columns).toHaveLength(1);
+        expect(matrix.columns[0].subjectType).toBe('process');
+        expect(matrix.columns[0].subjectId).toBe('PROCESS-CS-1');
+    });
+    it('report_type=combined allows both product and process columns without COMPIMP-011', () => {
+        const canon = emptyCanon();
+        canon.products.push({ id: 'PRODUCT-A-1', name: 'Product A' });
+        canon.subjects.push({ id: 'PROCESS-CS-1', name: 'Customer Support' });
+        const matrix = buildImpactMatrix(canon, {
+            id: 'V', name: 'V',
+            report_type: 'combined',
+            subjects: { products: ['PRODUCT-A-1'], processes: ['PROCESS-CS-1'] },
+            obligations: {},
+        });
+        expect(matrix.findings.some(f => f.code === 'COMPIMP-011')).toBe(false);
+        expect(matrix.columns).toHaveLength(2);
+    });
+    it('parseImpactViewConfig round-trips report_type', () => {
+        for (const rt of ['product', 'process', 'combined']) {
+            const r = parseImpactViewConfig({ id: 'V', name: 'V', report_type: rt, subjects: {}, obligations: {} });
+            expect(r.ok).toBe(true);
+            if (r.ok)
+                expect(r.config.report_type).toBe(rt);
+        }
+    });
+    it('parseImpactViewConfig ignores unknown report_type values', () => {
+        const r = parseImpactViewConfig({ id: 'V', name: 'V', report_type: 'unknown-type', subjects: {}, obligations: {} });
+        expect(r.ok).toBe(true);
+        if (r.ok)
+            expect(r.config.report_type).toBeUndefined();
+    });
+});

package/dist/compliance/html.js

@@ -11,6 +11,7 @@ import { buildComplianceMatrix } from '../compliance-matrix/index.js';
 import { buildComplianceIndex } from './reverse-index.js';
 import { buildLawTree, buildProductView } from './views.js';
 import { buildGapReport } from './gap-report.js';
+import { escHtml } from '../webview/render-util.js';
 const STATUS_LABELS = {
     compliant: 'Compliant',
     partial: 'Partial',
@@ -19,13 +20,6 @@ const STATUS_LABELS = {
     pending_owner: 'Pending owner',
     n_a: 'N/A',
 };
-function escHtml(s) {
-    return s
-        .replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
 function badge(status) {
     return `<span class="cmp-badge cmp-${status}">${escHtml(STATUS_LABELS[status])}</span>`;
 }

package/dist/compliance/impact.d.ts

@@ -53,6 +53,15 @@ export interface ImpactColumn {
     label: string;
     /** Display name for the subject (product/process name, not the id). */
     subjectName?: string;
+    /** Which subjects pool this column derives from (product / process / capability).
+     *  Used to enforce the subject type label invariant (§5.2, COMPIMP-010). */
+    subjectType: 'product' | 'process' | 'capability';
+}
+/** A structural validation finding emitted by the matrix builder. */
+export interface ImpactFinding {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
 }
 /**
  * Grouping options for matrix columns.
@@ -64,9 +73,12 @@ export interface ImpactColumn {
  *   - `'product-stage-task'` — one column per (subject, stage, task) triple;
  *     pass `objectDetails` with stages that carry `tasks[]` (built via
  *     `extractObjectDetails` + `extractProcessFlowTasks` + `mergeStageTaskDetails`).
+ *   - `'process'` / `'process-stage'` / `'process-stage-task'` — process-centric
+ *     equivalents used when `view.subjects.processes` is the sole entry point
+ *     (§7.1 process compliance variant). Avoids COMPIMP-010 for process subjects.
  */
 export interface ImpactGrouping {
-    columns: 'product' | 'product-stage' | 'product-stage-task';
+    columns: 'product' | 'product-stage' | 'product-stage-task' | 'process' | 'process-stage' | 'process-stage-task';
 }
 /**
  * Named, versioned view-config — the report *definition*.
@@ -84,6 +96,15 @@ export interface ImpactViewConfig {
     id: string;
     name: string;
     description?: string;
+    /**
+     * Declares the subject scope of the view (§4, COMPIMP-011 enforcement).
+     * `product`  — covers products only; `subjects.processes` MUST be absent.
+     * `process`  — covers processes directly; `subjects.products` MUST be absent.
+     * `combined` — both subject types allowed; column headers carry explicit badges.
+     * Omitting the field preserves backward-compatible behaviour (auto-detected
+     * from `subjects.*` presence).
+     */
+    report_type?: 'product' | 'process' | 'combined';
     /**
      * ISO 8601 date of the last report snapshot (YYYY-MM-DD).
      * Populated automatically by the CLI on each run and stored back to the
@@ -220,6 +241,8 @@ export interface ImpactMatrix {
      * Empty array when no requirement in the column has a `derived_from`.
      */
     obligationsLane: string[][];
+    /** Structural validation findings emitted during matrix build (COMPIMP-009, COMPIMP-010, etc.). */
+    findings: ImpactFinding[];
 }
 /**
  * Classify a REQUIREMENT deadline relative to a reference date.

package/dist/compliance/impact.js

@@ -86,15 +86,23 @@ export function parseImpactViewConfig(raw) {
         ? v.grouping
         : null;
     const rawColumns = typeof rawGrouping?.columns === 'string' ? rawGrouping.columns : undefined;
-    const VALID_COLUMNS = new Set(['product', 'product-stage', 'product-stage-task']);
+    const VALID_COLUMNS = new Set([
+        'product', 'product-stage', 'product-stage-task',
+        'process', 'process-stage', 'process-stage-task',
+    ]);
     const normalizedColumns = rawColumns === 'object-details' ? 'product-stage' // backward-compat alias
         : rawColumns === 'object' ? 'product' // backward-compat alias
             : VALID_COLUMNS.has(rawColumns ?? '') ? rawColumns
                 : undefined;
+    const VALID_REPORT_TYPES = new Set(['product', 'process', 'combined']);
+    const rawReportType = typeof v.report_type === 'string' ? v.report_type : undefined;
     const config = {
         id: v.id,
         name: v.name,
         description: typeof v.description === 'string' ? v.description : undefined,
+        report_type: rawReportType && VALID_REPORT_TYPES.has(rawReportType)
+            ? rawReportType
+            : undefined,
         snapshot_at: typeof v.snapshot_at === 'string' ? v.snapshot_at : undefined,
         subjects: {
             products: Array.isArray(subjects.products)
@@ -226,17 +234,39 @@ function aggregateStatus(assertions) {
     return 'n_a';
 }
 // ── Column builder helpers (CV-3a) ──────────────────────────────────────────
-function buildProductColumns(config, namedItems) {
+function buildProductColumns(config, namedItems, isCombined) {
     const nameMap = new Map(namedItems.map(p => [p.id, p.name]));
-    const subjects = [
-        ...(config.subjects.products ?? []),
-        ...(config.subjects.processes ?? []),
-        ...(config.subjects.capabilities ?? []),
-    ];
-    return subjects.map(id => ({ subjectId: id, label: id, subjectName: nameMap.get(id) }));
+    const cols = [];
+    for (const id of (config.subjects.products ?? [])) {
+        cols.push({
+            subjectId: id,
+            label: isCombined ? `[PRODUCT] ${id}` : id,
+            subjectName: nameMap.get(id),
+            subjectType: 'product',
+        });
+    }
+    for (const id of (config.subjects.processes ?? [])) {
+        cols.push({
+            subjectId: id,
+            label: isCombined ? `[PROCESS] ${id}` : id,
+            subjectName: nameMap.get(id),
+            subjectType: 'process',
+        });
+    }
+    for (const id of (config.subjects.capabilities ?? [])) {
+        cols.push({
+            subjectId: id,
+            label: id,
+            subjectName: nameMap.get(id),
+            subjectType: 'capability',
+        });
+    }
+    return cols;
 }
-function buildObjectDetailColumns(config, objectDetails) {
+function buildObjectDetailColumns(config, objectDetails, isCombined) {
     const detailMap = new Map(objectDetails.map(d => [d.objectId, d.details]));
+    const productSet = new Set(config.subjects.products ?? []);
+    const processSet = new Set(config.subjects.processes ?? []);
     const subjects = [
         ...(config.subjects.products ?? []),
         ...(config.subjects.processes ?? []),
@@ -244,13 +274,15 @@ function buildObjectDetailColumns(config, objectDetails) {
     ];
     const cols = [];
     for (const subjectId of subjects) {
+        const subjectType = productSet.has(subjectId) ? 'product' : processSet.has(subjectId) ? 'process' : 'capability';
+        const badge = isCombined && subjectType !== 'capability' ? `[${subjectType.toUpperCase()}] ` : '';
         const details = detailMap.get(subjectId);
         if (!details || details.length === 0) {
-            cols.push({ subjectId, label: subjectId });
+            cols.push({ subjectId, label: `${badge}${subjectId}`, subjectType });
         }
         else {
             for (const detail of details) {
-                cols.push({ subjectId, stageId: detail.id, label: `${subjectId}:${detail.id}` });
+                cols.push({ subjectId, stageId: detail.id, label: `${badge}${subjectId}:${detail.id}`, subjectType });
             }
         }
     }
@@ -262,8 +294,10 @@ function buildObjectDetailColumns(config, objectDetails) {
  * per-task columns `{ subjectId, stageId, taskId, label: subjectId:stageId:taskId }`.
  * Stages with no tasks fall back to a single stage-grain column.
  */
-function buildTaskColumns(config, objectDetails) {
+function buildTaskColumns(config, objectDetails, isCombined) {
     const detailMap = new Map(objectDetails.map(d => [d.objectId, d.details]));
+    const productSet = new Set(config.subjects.products ?? []);
+    const processSet = new Set(config.subjects.processes ?? []);
     const subjects = [
         ...(config.subjects.products ?? []),
         ...(config.subjects.processes ?? []),
@@ -271,15 +305,16 @@ function buildTaskColumns(config, objectDetails) {
     ];
     const cols = [];
     for (const subjectId of subjects) {
+        const subjectType = productSet.has(subjectId) ? 'product' : processSet.has(subjectId) ? 'process' : 'capability';
+        const badge = isCombined && subjectType !== 'capability' ? `[${subjectType.toUpperCase()}] ` : '';
         const stages = detailMap.get(subjectId);
         if (!stages || stages.length === 0) {
-            cols.push({ subjectId, label: subjectId });
+            cols.push({ subjectId, label: `${badge}${subjectId}`, subjectType });
         }
         else {
             for (const stage of stages) {
                 if (!stage.tasks || stage.tasks.length === 0) {
-                    // Stage with no tasks: fall back to stage-grain column.
-                    cols.push({ subjectId, stageId: stage.id, label: `${subjectId}:${stage.id}` });
+                    cols.push({ subjectId, stageId: stage.id, label: `${badge}${subjectId}:${stage.id}`, subjectType });
                 }
                 else {
                     for (const task of stage.tasks) {
@@ -287,7 +322,8 @@ function buildTaskColumns(config, objectDetails) {
                             subjectId,
                             stageId: stage.id,
                             taskId: task.id,
-                            label: `${subjectId}:${stage.id}:${task.id}`,
+                            label: `${badge}${subjectId}:${stage.id}:${task.id}`,
+                            subjectType,
                         });
                     }
                 }
@@ -349,11 +385,50 @@ export function buildImpactMatrix(canon, config, objectDetails) {
     const obligations = orderRows(resolveObligations(config, index, canon.requirements), config.order_rows_by);
     const grain = config.grouping?.columns ?? 'product';
     const hasDetails = objectDetails !== undefined && objectDetails.length > 0;
-    const columns = grain === 'product-stage-task' && hasDetails
-        ? buildTaskColumns(config, objectDetails)
-        : (grain === 'product-stage' || grain === 'object-details') && hasDetails
-            ? buildObjectDetailColumns(config, objectDetails)
-            : buildProductColumns(config, [...(canon.products ?? []), ...(canon.subjects ?? [])]);
+    const hasProducts = (config.subjects.products?.length ?? 0) > 0;
+    const hasProcesses = (config.subjects.processes?.length ?? 0) > 0;
+    // Combined = both products and processes are explicit entry points (§7.1).
+    const isCombined = hasProducts && hasProcesses;
+    let columns = (grain === 'product-stage-task' || grain === 'process-stage-task') && hasDetails
+        ? buildTaskColumns(config, objectDetails, isCombined)
+        : (grain === 'product-stage' || grain === 'process-stage' || grain === 'object-details') && hasDetails
+            ? buildObjectDetailColumns(config, objectDetails, isCombined)
+            : buildProductColumns(config, [...(canon.products ?? []), ...(canon.subjects ?? [])], isCombined);
+    // ── Structural validation (COMPIMP-009, COMPIMP-010, COMPIMP-011) ──────
+    const findings = [];
+    if (!hasProducts && hasProcesses &&
+        (grain === 'product' || grain === 'product-stage' || grain === 'product-stage-task')) {
+        findings.push({
+            code: 'COMPIMP-009',
+            severity: 'warning',
+            message: `view.grouping.columns is '${grain}' but view.subjects.products is absent and subjects.processes is the only entry point. Consider using '${grain.replace('product', 'process')}' for a process-centric view.`,
+        });
+    }
+    if (hasProcesses && (grain === 'product-stage' || grain === 'product-stage-task')) {
+        findings.push({
+            code: 'COMPIMP-010',
+            severity: 'error',
+            message: `view.grouping.columns is '${grain}' but view.subjects.processes has entries — product-stage semantics applied to process columns violate the subject type label invariant (§5.2). Use '${grain.replace('product', 'process')}' for process columns.`,
+        });
+    }
+    // COMPIMP-011: report_type contract — strip cross-type columns and emit an
+    // error when the declared scope contradicts the subjects actually present.
+    if (config.report_type === 'product' && hasProcesses) {
+        findings.push({
+            code: 'COMPIMP-011',
+            severity: 'error',
+            message: `view.report_type is 'product' but view.subjects.processes has entries — process columns are excluded. Remove subjects.processes or set report_type to 'combined'.`,
+        });
+        columns = columns.filter(c => c.subjectType !== 'process');
+    }
+    if (config.report_type === 'process' && hasProducts) {
+        findings.push({
+            code: 'COMPIMP-011',
+            severity: 'error',
+            message: `view.report_type is 'process' but view.subjects.products has entries — product columns are excluded. Remove subjects.products or set report_type to 'combined'.`,
+        });
+        columns = columns.filter(c => c.subjectType !== 'product');
+    }
     const allowedStatuses = new Set(config.status_display?.show ?? ['compliant', 'partial', 'non_compliant', 'under_review', 'pending_owner', 'n_a']);
     const rowIndex = new Set(obligations.map(r => r.id));
     const cells = obligations.map(() => columns.map(() => emptyCell()));
@@ -434,6 +509,7 @@ export function buildImpactMatrix(canon, config, objectDetails) {
             no_obligation_applies_label: config.empty_cells?.no_obligation_applies_label ?? DEFAULT_NO_OBLIGATION_APPLIES_LABEL,
         },
         obligationsLane,
+        findings,
     };
 }
 function emptyCell() {