@transitrix/diagrams 1.0.1 → 1.2.0

package/dist/capability-map/render-capability-tree.js

@@ -0,0 +1,108 @@
+import { layoutCapabilityTree, TREE_NODE_WIDTH, TREE_NODE_HEIGHT, TREE_NODE_SEP } from './layout-tree.js';
+import { horizontalCubicEdgePath, DEFAULT_EDGE_CURVATURE } from '../edge-path.js';
+import { escXml } from '../webview/render-util.js';
+const PAD = 24;
+const BTN_R = 8;
+const LEGEND_H = 40;
+const LABEL_MAX_CHARS = 28;
+const LABEL_TRIM_CHARS = 26;
+const BAND_LABELS = ['Levels 0–2', 'Levels 3–4', 'Levels 5+'];
+function depthBand(depth) {
+    if (depth <= 2)
+        return 0;
+    if (depth <= 4)
+        return 1;
+    return 2;
+}
+function truncate(s, max, trim) {
+    return s.length > max ? s.slice(0, trim) + '…' : s;
+}
+/**
+ * Renders a capability-map as a left-to-right SVG node tree with DSM-matching
+ * visual design: depth-banded fills, maturity badges, and +/− collapse buttons.
+ *
+ * The SVG uses CSS classes (`tree-level-N`, `tree-maturity-N`, `tree-collapse-btn`)
+ * that must be resolved by the host's stylesheet (injected via `diagramClassCss()`
+ * in themes.ts). Collapse buttons carry `data-node-id` / `data-collapsed` attributes
+ * for the webview click handler.
+ */
+export function renderCapabilityTreeSvg(map, opts = {}) {
+    const { collapsedIds = new Set(), curvature = DEFAULT_EDGE_CURVATURE } = opts;
+    const layout = layoutCapabilityTree(map, collapsedIds);
+    if (layout.nodes.length === 0) {
+        return `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0" viewBox="0 0 0 0"></svg>`;
+    }
+    const ox = -layout.bounds.x + PAD;
+    const oy = -layout.bounds.y + PAD;
+    const svgW = layout.bounds.width + PAD * 2 + BTN_R;
+    const svgH = layout.bounds.height + PAD * 2 + LEGEND_H + TREE_NODE_SEP;
+    const nodeMap = new Map(layout.nodes.map(n => [n.id, n]));
+    const edgeSvg = layout.edges.map(e => {
+        const s = nodeMap.get(e.source);
+        const t = nodeMap.get(e.target);
+        if (!s || !t)
+            return '';
+        const sx = s.x + ox + s.width;
+        const sy = s.y + oy + s.height / 2;
+        const tx = t.x + ox;
+        const ty = t.y + oy + t.height / 2;
+        return `<path d="${horizontalCubicEdgePath(sx, sy, tx, ty, curvature)}" class="diagram-edge"/>`;
+    }).filter(Boolean).join('\n');
+    const nodeSvg = layout.nodes.map(n => {
+        const x = n.x + ox;
+        const y = n.y + oy;
+        const band = depthBand(n.depth);
+        const mat = Math.max(1, Math.min(5, n.data.current_maturity | 0));
+        const nameText = truncate(n.data.name, LABEL_MAX_CHARS, LABEL_TRIM_CHARS);
+        const nameTitle = n.data.name.length > LABEL_MAX_CHARS ? escXml(n.data.name) : '';
+        // Maturity badge: left side of node
+        const badgeW = 28;
+        const badgeH = 18;
+        const badgeX = x + 10;
+        const badgeY = y + (TREE_NODE_HEIGHT - badgeH) / 2;
+        // Text area: right of badge
+        const textX = badgeX + badgeW + 8;
+        const nameY = y + TREE_NODE_HEIGHT / 2 - 8;
+        const idY = y + TREE_NODE_HEIGHT / 2 + 9;
+        // Collapse button: centered on right edge of node
+        const btnCx = x + TREE_NODE_WIDTH;
+        const btnCy = y + TREE_NODE_HEIGHT / 2;
+        const collapseBtn = n.hasChildren
+            ? `<circle class="tree-collapse-btn" cx="${btnCx}" cy="${btnCy}" r="${BTN_R}" data-node-id="${escXml(n.id)}" data-collapsed="${n.isCollapsed}"/>
+  <text class="tree-collapse-lbl" x="${btnCx}" y="${btnCy}" text-anchor="middle">${n.isCollapsed ? '+' : '−'}</text>`
+            : '';
+        return `<g${nameTitle ? ` title="${nameTitle}"` : ''}>
+  <rect class="tree-level-${band}" x="${x}" y="${y}" width="${TREE_NODE_WIDTH}" height="${TREE_NODE_HEIGHT}" rx="11" stroke="var(--ts-node-stroke,#94a3b8)" stroke-width="3"/>
+  <rect class="tree-maturity-${mat}" x="${badgeX}" y="${badgeY}" width="${badgeW}" height="${badgeH}" rx="4"/>
+  <text class="text-pill" x="${badgeX + badgeW / 2}" y="${badgeY + badgeH / 2}" text-anchor="middle" fill="white">L${mat}</text>
+  <text class="text-primary" x="${textX}" y="${nameY}" dominant-baseline="central">${escXml(nameText)}</text>
+  <text class="text-id" x="${textX}" y="${idY}" dominant-baseline="central">${escXml(n.id)}</text>
+  ${collapseBtn}
+</g>`;
+    }).join('\n');
+    // Legend band: proportional coloured blocks per level-count band
+    const legendY = layout.bounds.height + PAD * 2 + TREE_NODE_SEP / 2;
+    const legendW = svgW - PAD * 2;
+    const totalNodes = layout.nodes.length || 1;
+    const bandCounts = [layout.levelCounts.band0, layout.levelCounts.band1, layout.levelCounts.band2];
+    let legendX = PAD;
+    const legendSvg = bandCounts.map((count, i) => {
+        const bw = Math.max(1, Math.round(legendW * count / totalNodes));
+        const bx = legendX;
+        legendX += bw;
+        if (count === 0)
+            return '';
+        return `<rect class="tree-level-${i}" x="${bx}" y="${legendY}" width="${bw}" height="24" rx="4" stroke="var(--ts-node-stroke,#94a3b8)" stroke-width="1"/>
+  <text class="text-id" x="${bx + bw / 2}" y="${legendY + 12}" text-anchor="middle" dominant-baseline="central">${escXml(BAND_LABELS[i])}</text>`;
+    }).filter(Boolean).join('\n');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${svgW}" height="${svgH}" viewBox="0 0 ${svgW} ${svgH}">
+<defs>
+  <marker id="cap-tree-arrow" markerWidth="8" markerHeight="8" refX="8" refY="3" orient="auto">
+    <path d="M0,0 L0,6 L8,3 z" class="arrow-fill"/>
+  </marker>
+</defs>
+${edgeSvg}
+${nodeSvg}
+${legendSvg}
+</svg>`;
+}

package/dist/capability-map/types.d.ts

@@ -22,5 +22,7 @@ export interface CapabilityMapHeader {
 export interface CapabilityMapFile {
     notation: string;
     spec_version?: string;
+    /** Render mode for Studio previews. Defaults to 'cards'. */
+    view?: 'cards' | 'tree';
     capability_map: CapabilityMapHeader;
 }

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() {

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

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { validateFactor } from '../validate.js';
 function validExternal() {
     return {
-        notation: 'factor',
+        notation: 'driver',
         id: 'FACTOR-EU-REG-1',
         name: 'EU regulatory window',
         type: 'external',
@@ -19,7 +19,7 @@ function validExternal() {
 }
 function validInternal() {
     return {
-        notation: 'factor',
+        notation: 'driver',
         id: 'FACTOR-COMP-1',
         name: 'Support response time',
         type: 'internal',
@@ -60,7 +60,7 @@ describe('validateFactor — FACTOR-001 (shape / id grammar)', () => {
         expect(codes({ ...validExternal(), id: 'factor-1' })).toContain('FACTOR-001');
     });
     it('flags a wrong notation tag and a non-canon zone', () => {
-        expect(codes({ ...validExternal(), notation: 'driver' })).toContain('FACTOR-001');
+        expect(codes({ ...validExternal(), notation: 'factor' })).toContain('FACTOR-001');
         expect(codes({ ...validExternal(), zone: 'sandbox' })).toContain('FACTOR-001');
     });
     it('flags a missing valid_to key (distinct from a null value)', () => {

package/dist/factor/types.d.ts

@@ -4,7 +4,7 @@ export type FactorType = 'external' | 'internal';
 export declare const FACTOR_PESTLE_CATEGORIES: readonly ["political", "economic", "social", "technological", "legal", "environmental"];
 export type FactorPestleCategory = typeof FACTOR_PESTLE_CATEGORIES[number];
 export interface Factor {
-    notation: 'factor';
+    notation: 'driver';
     id: string;
     name: string;
     type?: FactorType;

package/dist/factor/validate.js

@@ -27,8 +27,8 @@ export function validateFactor(input, options = {}) {
     if (!isCanonicalIdOfType(f.id, 'FACTOR')) {
         errors.push({ code: 'FACTOR-001', message: `id "${String(f.id)}" must match FACTOR-[<middle>-]<INTEGER>.`, path: 'id' });
     }
-    if (f.notation !== 'factor') {
-        errors.push({ code: 'FACTOR-001', message: 'notation must be the fixed value "factor".', path: 'notation' });
+    if (f.notation !== 'driver') {
+        errors.push({ code: 'FACTOR-001', message: 'notation must be the fixed value "driver".', path: 'notation' });
     }
     if (f.zone !== undefined && f.zone !== 'canon') {
         errors.push({ code: 'FACTOR-001', message: 'zone must be "canon" for a FACTOR.', path: 'zone' });