@transitrix/diagrams 1.0.1 → 1.2.0

package/src/compliance/__tests__/impact.test.ts

@@ -838,4 +838,223 @@ describe('mergeStageTaskDetails', () => {
     // S2 has no tasks in stageOwner, filter returns [] → no tasks embedded
     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'] as const) {
+      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'] as const) {
+      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/src/compliance/html.ts

@@ -16,6 +16,7 @@ import type { ComplianceCanon } from './classify.js';
 import type { ReportScope } from './markdown.js';
 import type { AssertionStatus } from '../assertion/types.js';
 import type { ImpactMatrix } from './impact.js';
+import { escHtml } from '../webview/render-util.js';
 
 const STATUS_LABELS: Record<AssertionStatus, string> = {
   compliant: 'Compliant',
@@ -33,14 +34,6 @@ export interface HtmlOptions {
   title?: string;
 }
 
-function escHtml(s: string): string {
-  return s
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
-}
-
 function badge(status: AssertionStatus): string {
   return `<span class="cmp-badge cmp-${status}">${escHtml(STATUS_LABELS[status])}</span>`;
 }

package/src/compliance/impact.ts

@@ -70,6 +70,16 @@ 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;
 }
 
 /**
@@ -82,9 +92,13 @@ 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';
 }
 
 /**
@@ -103,6 +117,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
@@ -221,17 +244,26 @@ export function parseImpactViewConfig(raw: unknown): ParseImpactViewConfigResult
       ? (v.grouping as Record<string, unknown>)
       : null;
   const rawColumns = typeof rawGrouping?.columns === 'string' ? rawGrouping.columns : undefined;
-  const VALID_COLUMNS = new Set<string>(['product', 'product-stage', 'product-stage-task']);
+  const VALID_COLUMNS = new Set<string>([
+    'product', 'product-stage', 'product-stage-task',
+    'process', 'process-stage', 'process-stage-task',
+  ]);
   const normalizedColumns: ImpactGrouping['columns'] | undefined =
     rawColumns === 'object-details' ? 'product-stage'   // backward-compat alias
     : rawColumns === 'object' ? 'product'               // backward-compat alias
     : VALID_COLUMNS.has(rawColumns ?? '') ? (rawColumns as ImpactGrouping['columns'])
     : undefined;
 
+  const VALID_REPORT_TYPES = new Set(['product', 'process', 'combined']);
+  const rawReportType = typeof v.report_type === 'string' ? v.report_type : undefined;
+
   const config: ImpactViewConfig = {
     id: v.id as string,
     name: v.name as string,
     description: typeof v.description === 'string' ? v.description : undefined,
+    report_type: rawReportType && VALID_REPORT_TYPES.has(rawReportType)
+      ? (rawReportType as ImpactViewConfig['report_type'])
+      : undefined,
     snapshot_at: typeof v.snapshot_at === 'string' ? v.snapshot_at : undefined,
     subjects: {
       products: Array.isArray(subjects.products)
@@ -337,6 +369,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[];
 }
 
 const DEFAULT_NO_OBLIGATION_LABEL = 'No mapped obligation (current model)';
@@ -432,18 +466,48 @@ function aggregateStatus(assertions: IndexAssertion[]): AssertionStatus {
 
 // ── Column builder helpers (CV-3a) ──────────────────────────────────────────
 
-function buildProductColumns(config: ImpactViewConfig, namedItems: { id: string; name: string }[]): ImpactColumn[] {
+function buildProductColumns(
+  config: ImpactViewConfig,
+  namedItems: { id: string; name: string }[],
+  isCombined: boolean,
+): ImpactColumn[] {
   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: ImpactColumn[] = [];
+  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: ImpactViewConfig, objectDetails: ObjectDetailInput[]): ImpactColumn[] {
+function buildObjectDetailColumns(
+  config: ImpactViewConfig,
+  objectDetails: ObjectDetailInput[],
+  isCombined: boolean,
+): ImpactColumn[] {
   const detailMap = new Map<string, ObjectDetailDef[]>(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 ?? []),
@@ -451,12 +515,15 @@ function buildObjectDetailColumns(config: ImpactViewConfig, objectDetails: Objec
   ];
   const cols: ImpactColumn[] = [];
   for (const subjectId of subjects) {
+    const subjectType: 'product' | 'process' | 'capability' =
+      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 });
       }
     }
   }
@@ -469,8 +536,14 @@ function buildObjectDetailColumns(config: ImpactViewConfig, objectDetails: Objec
  * 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: ImpactViewConfig, objectDetails: ObjectDetailInput[]): ImpactColumn[] {
+function buildTaskColumns(
+  config: ImpactViewConfig,
+  objectDetails: ObjectDetailInput[],
+  isCombined: boolean,
+): ImpactColumn[] {
   const detailMap = new Map<string, ObjectDetailDef[]>(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 ?? []),
@@ -478,21 +551,24 @@ function buildTaskColumns(config: ImpactViewConfig, objectDetails: ObjectDetailI
   ];
   const cols: ImpactColumn[] = [];
   for (const subjectId of subjects) {
+    const subjectType: 'product' | 'process' | 'capability' =
+      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) {
             cols.push({
               subjectId,
               stageId: stage.id,
               taskId: task.id,
-              label: `${subjectId}:${stage.id}:${task.id}`,
+              label: `${badge}${subjectId}:${stage.id}:${task.id}`,
+              subjectType,
             });
           }
         }
@@ -559,12 +635,53 @@ export function buildImpactMatrix(
 
   const grain = config.grouping?.columns ?? 'product';
   const hasDetails = objectDetails !== undefined && objectDetails.length > 0;
-  const columns: ImpactColumn[] =
-    grain === 'product-stage-task' && hasDetails
-      ? buildTaskColumns(config, objectDetails!)
-      : (grain === 'product-stage' || (grain as string) === '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: ImpactColumn[] =
+    (grain === 'product-stage-task' || grain === 'process-stage-task') && hasDetails
+      ? buildTaskColumns(config, objectDetails!, isCombined)
+      : (grain === 'product-stage' || grain === 'process-stage' || (grain as string) === 'object-details') && hasDetails
+        ? buildObjectDetailColumns(config, objectDetails!, isCombined)
+        : buildProductColumns(config, [...(canon.products ?? []), ...(canon.subjects ?? [])], isCombined);
+
+  // ── Structural validation (COMPIMP-009, COMPIMP-010, COMPIMP-011) ──────
+  const findings: ImpactFinding[] = [];
+  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<AssertionStatus>(
     config.status_display?.show ?? ['compliant', 'partial', 'non_compliant', 'under_review', 'pending_owner', 'n_a'],
@@ -653,6 +770,7 @@ export function buildImpactMatrix(
         config.empty_cells?.no_obligation_applies_label ?? DEFAULT_NO_OBLIGATION_APPLIES_LABEL,
     },
     obligationsLane,
+    findings,
   };
 }
 

package/src/factor/__tests__/validate.test.ts

@@ -4,7 +4,7 @@ import type { CanonCatalog } from '../../typed-id.js';
 
 function validExternal(): Record<string, unknown> {
   return {
-    notation: 'factor',
+    notation: 'driver',
     id: 'FACTOR-EU-REG-1',
     name: 'EU regulatory window',
     type: 'external',
@@ -22,7 +22,7 @@ function validExternal(): Record<string, unknown> {
 
 function validInternal(): Record<string, unknown> {
   return {
-    notation: 'factor',
+    notation: 'driver',
     id: 'FACTOR-COMP-1',
     name: 'Support response time',
     type: 'internal',
@@ -71,7 +71,7 @@ describe('validateFactor — FACTOR-001 (shape / id grammar)', () => {
   });
 
   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');
   });
 

package/src/factor/types.ts

@@ -17,7 +17,7 @@ export const FACTOR_PESTLE_CATEGORIES = [
 export type FactorPestleCategory = typeof FACTOR_PESTLE_CATEGORIES[number];
 
 export interface Factor {
-  notation: 'factor';
+  notation: 'driver';
   id: string;
   name: string;
   type?: FactorType;

package/src/factor/validate.ts

@@ -39,8 +39,8 @@ export function validateFactor(input: unknown, options: FactorValidateOptions =
   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' });

package/src/fgca/__tests__/chain-table.test.ts

@@ -36,7 +36,7 @@ describe('buildChainTable — worked example (FGCA)', () => {
 
   it('produces the spec grid with F1 spanning 3 and G2/C2 spanning 2', () => {
     const t = buildChainTable(doc);
-    expect(t.columns).toEqual<ChainColumn[]>(['factor', 'goal', 'change', 'activity']);
+    expect(t.columns).toEqual<ChainColumn[]>(['driver', 'goal', 'change', 'activity']);
     expect(asGrid(t)).toEqual([
       ['F1×3', 'G1', 'C1', 'A1'],
       ['·', 'G2×2', 'C2×2', 'A2'],
@@ -67,7 +67,7 @@ describe('buildChainTable — FGA (no Change column)', () => {
 
   it('emits three columns and merges Factor/Goal across the two activities', () => {
     const t = buildChainTable(doc, { hideChanges: true });
-    expect(t.columns).toEqual<ChainColumn[]>(['factor', 'goal', 'activity']);
+    expect(t.columns).toEqual<ChainColumn[]>(['driver', 'goal', 'activity']);
     expect(asGrid(t)).toEqual([
       ['F1×2', 'G1×2', 'A1'],
       ['·', '·', 'A2'],

package/src/fgca/__tests__/layout.test.ts

@@ -9,12 +9,12 @@ beforeAll(() => {
 });
 
 import { buildFGCALayout } from "../layout";
-import type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem } from "../types";
+import type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem } from "../types";
 import { ALL_FGCA_COLUMNS } from "../types";
 
 const ALL_COLS = new Set(ALL_FGCA_COLUMNS);
 
-const factors: FactorItem[] = [
+const factors: DriverItem[] = [
   { id: 1, name: "Digital growth" },
   { id: 2, name: "Talent shortage" },
 ];
@@ -50,16 +50,16 @@ describe("buildFGCALayout — all columns visible", () => {
 
   it("assigns correct node types", () => {
     const types = nodes.map((n) => n.type);
-    expect(types.filter((t) => t === "fgcaFactor")).toHaveLength(factors.length);
+    expect(types.filter((t) => t === "fgcaDriver")).toHaveLength(factors.length);
     expect(types.filter((t) => t === "fgcaGoal")).toHaveLength(goals.length);
     expect(types.filter((t) => t === "fgcaChange")).toHaveLength(changes.length);
     expect(types.filter((t) => t === "fgcaActivity")).toHaveLength(activities.length);
   });
 
   it("creates Factor→Goal edges", () => {
-    const fgEdges = edges.filter((e) => e.source.startsWith("factor_") && e.target.startsWith("goal_"));
+    const fgEdges = edges.filter((e) => e.source.startsWith("driver_") && e.target.startsWith("goal_"));
     expect(fgEdges).toHaveLength(2);
-    expect(fgEdges.find((e) => e.source === "factor_1" && e.target === "goal_10")).toBeTruthy();
+    expect(fgEdges.find((e) => e.source === "driver_1" && e.target === "goal_10")).toBeTruthy();
   });
 
   it("creates Goal→Change edges", () => {
@@ -85,7 +85,7 @@ describe("buildFGCALayout — all columns visible", () => {
   });
 
   it("encodes F-XXXX label format via id in node data", () => {
-    const factorNode = nodes.find((n) => n.id === "factor_1");
+    const factorNode = nodes.find((n) => n.id === "driver_1");
     expect(String(factorNode?.data.id).padStart(4, "0")).toBe("0001");
   });
 
@@ -95,16 +95,16 @@ describe("buildFGCALayout — all columns visible", () => {
   });
 });
 
-describe("buildFGCALayout — Factor column hidden", () => {
-  const cols = new Set(ALL_FGCA_COLUMNS.filter((c) => c !== "factor"));
+describe("buildFGCALayout — Driver column hidden", () => {
+  const cols = new Set(ALL_FGCA_COLUMNS.filter((c) => c !== "driver"));
   const { nodes, edges } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: cols });
 
-  it("produces no factor nodes", () => {
-    expect(nodes.filter((n) => n.type === "fgcaFactor")).toHaveLength(0);
+  it("produces no driver nodes", () => {
+    expect(nodes.filter((n) => n.type === "fgcaDriver")).toHaveLength(0);
   });
 
-  it("produces no Factor→Goal edges", () => {
-    expect(edges.filter((e) => e.source.startsWith("factor_"))).toHaveLength(0);
+  it("produces no Driver→Goal edges", () => {
+    expect(edges.filter((e) => e.source.startsWith("driver_"))).toHaveLength(0);
   });
 
   it("still produces Goal and downstream nodes", () => {
@@ -150,7 +150,7 @@ describe("buildFGCALayout — columns are positioned left to right", () => {
   const { nodes } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: ALL_COLS });
 
   it("factor column x < goal column x", () => {
-    const f = nodes.find((n) => n.type === "fgcaFactor")!;
+    const f = nodes.find((n) => n.type === "fgcaDriver")!;
     const g = nodes.find((n) => n.type === "fgcaGoal")!;
     expect(f.position.x).toBeLessThan(g.position.x);
   });