@transitrix/diagrams 1.9.18 → 1.11.0

package/src/compliance/classify.ts

@@ -40,6 +40,14 @@ export interface ComplianceCanon {
   /** VALIDATION artefacts (28-validation.md) — the validation-domain peer of
    *  `verifications`, anchored on NEED instead of REQUIREMENT. */
   validations: IndexValidation[];
+  /**
+   * Ids rejected by `ingestComplianceDoc` because that id was already present
+   * in the same bucket (two documents claiming one id — transitrix-hq#218).
+   * The second and any later document is dropped rather than silently
+   * duplicating a matrix column; callers that scan a filesystem can surface
+   * this list as a diagnostic.
+   */
+  duplicateIds: string[];
 }
 
 export function emptyCanon(): ComplianceCanon {
@@ -52,6 +60,7 @@ export function emptyCanon(): ComplianceCanon {
     subjects: [],
     needs: [],
     validations: [],
+    duplicateIds: [],
   };
 }
 
@@ -59,12 +68,29 @@ const str = (v: unknown): string | undefined => (typeof v === 'string' ? v : und
 const strArray = (v: unknown): string[] | undefined =>
   Array.isArray(v) ? v.filter((x): x is string => typeof x === 'string') : undefined;
 
+/**
+ * Pushes `item` onto `list` unless `list` already holds an entry with the same
+ * id, in which case the id is recorded in `canon.duplicateIds` and the item is
+ * dropped — two documents claiming one id is a defect (transitrix-hq#218), not
+ * a second matrix column.
+ */
+function pushUnique<T extends { id: string }>(canon: ComplianceCanon, list: T[], item: T): boolean {
+  if (list.some(existing => existing.id === item.id)) {
+    canon.duplicateIds.push(item.id);
+    return false;
+  }
+  list.push(item);
+  return true;
+}
+
 /**
  * Classifies one parsed YAML document and, if it is a compliance artefact,
  * pushes its projection into `canon`. Products / requirements / assertions are
  * identified by their `notation` tag; codex source documents by `zone: codex`.
  * Returns the artefact id when ingested (so the caller can record its path), or
- * null when the document is not a (well-formed) compliance artefact.
+ * null when the document is not a (well-formed) compliance artefact, or when
+ * its id duplicates one already ingested into the same bucket (see
+ * `canon.duplicateIds`).
  */
 export function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): string | null {
   if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) return null;
@@ -73,8 +99,7 @@ export function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): strin
   if (!id) return null;
 
   if (d.notation === 'product') {
-    canon.products.push({ id, name: str(d.name) ?? id });
-    return id;
+    return pushUnique(canon, canon.products, { id, name: str(d.name) ?? id }) ? id : null;
   }
   if (
     d.notation === 'capability' ||
@@ -82,12 +107,11 @@ export function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): strin
     d.notation === 'application' ||
     d.notation === 'system'
   ) {
-    canon.subjects.push({ id, name: str(d.name) ?? id });
-    return id;
+    return pushUnique(canon, canon.subjects, { id, name: str(d.name) ?? id }) ? id : null;
   }
   if (d.notation === 'requirement' || d.notation === 'constraint') {
     const origin = str(d.origin);
-    canon.requirements.push({
+    const ok = pushUnique(canon, canon.requirements, {
       id,
       name: str(d.name) ?? id,
       severity: str(d.severity),
@@ -101,31 +125,30 @@ export function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): strin
       next_review_at: str(d.next_review_at),
       serves: str(d.serves),
     });
-    return id;
+    return ok ? id : null;
   }
   if (d.notation === 'need') {
-    canon.needs.push({ id, name: str(d.name) ?? id });
-    return id;
+    return pushUnique(canon, canon.needs, { id, name: str(d.name) ?? id }) ? id : null;
   }
   if (d.notation === 'validation') {
     const validates = str(d.validates);
     const method = str(d.method) as ValidationMethod | undefined;
     const outcome = str(d.outcome) as ValidationOutcome | undefined;
     if (!validates || !method || !outcome) return null;
-    canon.validations.push({
+    const ok = pushUnique(canon, canon.validations, {
       id, validates, method, outcome,
       performed_at: str(d.performed_at),
       evidenceCount: Array.isArray(d.evidence) ? d.evidence.length : 0,
       admitted_at: str(d.admitted_at),
     });
-    return id;
+    return ok ? id : null;
   }
   if (d.notation === 'assertion') {
     const about = str(d.about);
     const subject = str(d.subject);
     const status = str(d.status) as AssertionStatus | undefined;
     if (!about || !subject || !status) return null;
-    canon.assertions.push({
+    const ok = pushUnique(canon, canon.assertions, {
       id, about, subject, status,
       assessed_at: str(d.assessed_at),
       next_review_at: str(d.next_review_at),
@@ -134,24 +157,24 @@ export function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): strin
       realised_via: strArray(d.realised_via),
       owner_to_confirm: str(d.owner_to_confirm),
     });
-    return id;
+    return ok ? id : null;
   }
   if (d.notation === 'verification') {
     const verifies = str(d.verifies);
     const method = str(d.method) as VerificationMethod | undefined;
     const outcome = str(d.outcome) as VerificationOutcome | undefined;
     if (!verifies || !method || !outcome) return null;
-    canon.verifications.push({
+    const ok = pushUnique(canon, canon.verifications, {
       id, verifies, method, outcome,
+      protocol: str(d.protocol),
       performed_at: str(d.performed_at),
       evidenceCount: Array.isArray(d.evidence) ? d.evidence.length : 0,
       admitted_at: str(d.admitted_at),
     });
-    return id;
+    return ok ? id : null;
   }
   if (d.zone === 'codex') {
-    canon.codex.push({ id, name: str(d.name) ?? id, type: str(d.type), jurisdiction: str(d.jurisdiction) });
-    return id;
+    return pushUnique(canon, canon.codex, { id, name: str(d.name) ?? id, type: str(d.type), jurisdiction: str(d.jurisdiction) }) ? id : null;
   }
   return null;
 }

package/src/compliance/impact.ts

@@ -12,6 +12,7 @@ import type { ComplianceCanon } from './classify.js';
 import { buildComplianceIndex } from './reverse-index.js';
 import type { CanonCatalog } from '../typed-id.js';
 import type { ComplianceIndex, IndexAssertion, IndexRequirement, ObjectDetailInput, ObjectDetailDef, DeadlineStatus } from './types.js';
+import { isStageColumnId } from '../process-blueprint/resolve-columns.js';
 
 /** Filter selecting REQUIREMENTs by codex source (jurisdiction / regime keys
  *  are accepted for forward compatibility but not yet honoured — the canon
@@ -649,22 +650,48 @@ function buildTaskColumns(
  *
  * At `'product'` grain: `a.subject` must match `col.subjectId`.
  * At `'product-stage'` grain: `a.subject` must match AND either
- * `a.realised_via` is absent (claim covers the whole subject) OR
- * `col.stageId` ∈ `a.realised_via`.
- * At `'product-stage-task'` grain: as above for stage, plus `col.taskId` ∈
- * `a.realised_via` counts as a match (task-level claim covers this task column).
- * A stage-level claim (`col.stageId` ∈ `a.realised_via`) covers all task columns
- * in that stage.
+ * `a.realised_via` is absent (claim covers the whole subject) OR the token
+ * pins this column: a `PROCESS-…` id matching `col.stageId`, or a STEP whose
+ * home process is that column. Sketch `STAGE-…` ids are never a join key.
+ * At `'product-stage-task'` grain: a task-id hit covers that task column; a
+ * process-level claim covers every task column of that process.
  */
-function assertionMatchesColumn(a: IndexAssertion, col: ImpactColumn): boolean {
+function assertionMatchesColumn(
+  a: IndexAssertion,
+  col: ImpactColumn,
+  stepHomeProcess?: ReadonlyMap<string, string>,
+): boolean {
   if (a.subject !== col.subjectId) return false;
   if (!col.stageId) return true;
   if (!a.realised_via || a.realised_via.length === 0) return true;
-  if (col.taskId) {
-    // Task grain: match on taskId OR on stageId (stage claim covers all tasks).
-    return a.realised_via.includes(col.taskId) || a.realised_via.includes(col.stageId);
+
+  const stageId = col.stageId;
+  if (isStageColumnId(stageId)) {
+    // Sketch column: only a task-id hit counts — never the STAGE- key.
+    return col.taskId != null && a.realised_via.includes(col.taskId);
+  }
+
+  for (const ref of a.realised_via) {
+    if (typeof ref !== 'string') continue;
+    if (isStageColumnId(ref)) continue;
+    if (col.taskId && ref === col.taskId) return true;
+    if (ref === stageId) return true;
+    if (!col.taskId && stepHomeProcess?.get(ref) === stageId) return true;
   }
-  return a.realised_via.includes(col.stageId);
+  return false;
+}
+
+function stepHomeFromObjectDetails(objectDetails?: ObjectDetailInput[]): Map<string, string> {
+  const out = new Map<string, string>();
+  if (!objectDetails) return out;
+  for (const od of objectDetails) {
+    for (const d of od.details ?? []) {
+      for (const t of d.tasks ?? []) {
+        if (typeof t?.id === 'string' && t.id.length > 0) out.set(t.id, d.id);
+      }
+    }
+  }
+  return out;
 }
 
 /**
@@ -691,6 +718,7 @@ export function buildImpactMatrix(
   canon: ComplianceCanon,
   config: ImpactViewConfig,
   objectDetails?: ObjectDetailInput[],
+  join?: { stepHomeProcess?: ReadonlyMap<string, string> },
 ): ImpactMatrix {
   const index = buildComplianceIndex({
     requirements: canon.requirements,
@@ -755,6 +783,7 @@ export function buildImpactMatrix(
 
   const rowIndex = new Set(obligations.map(r => r.id));
   const cells: ImpactCell[][] = obligations.map(() => columns.map(() => emptyCell()));
+  const stepHome = join?.stepHomeProcess ?? stepHomeFromObjectDetails(objectDetails);
 
   for (let c = 0; c < columns.length; c++) {
     const col = columns[c];
@@ -762,7 +791,7 @@ export function buildImpactMatrix(
     for (const a of subjectAssertions) {
       if (!rowIndex.has(a.about)) continue;
       if (!allowedStatuses.has(a.status)) continue;
-      if (!assertionMatchesColumn(a, col)) continue;
+      if (!assertionMatchesColumn(a, col, stepHome)) continue;
       const rowIdx = obligations.findIndex(r => r.id === a.about);
       if (rowIdx < 0) continue;
       cells[rowIdx][c].assertions.push(a);

package/src/compliance/types.ts

@@ -128,6 +128,12 @@ export interface IndexVerification {
   verifies: string;
   method: VerificationMethod;
   outcome: VerificationOutcome;
+  /**
+   * The verification procedure (27-verification.md §2). VERIFICATION carries
+   * no `name` field of its own; `protocol` is the closest human-readable
+   * description and is what a matrix/list view shows as the row's label.
+   */
+  protocol?: string;
   performed_at?: string;
   /** Number of evidence entries — feeds the VERIF-006 gap. */
   evidenceCount?: number;

package/src/compliance-verification-matrix/build.ts

@@ -0,0 +1,84 @@
+// Requirement -> verification matrix builder.
+
+import type { ComplianceIndex } from '../compliance/types.js';
+import { buildGapReport } from '../compliance/gap-report.js';
+import type {
+  RequirementVerificationMatrix,
+  RequirementVerificationMatrixOptions,
+  RequirementVerificationRow,
+} from './types.js';
+
+function byId<T extends { id: string }>(a: T, b: T): number {
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+
+/**
+ * Builds the repository-wide requirement -> verification matrix.
+ *
+ * Pure projection over an already-built `ComplianceIndex`
+ * (`compliance/reverse-index.ts`) — no I/O, no revalidation. Reuses
+ * `buildGapReport`'s `REQ-VERIF-COVERAGE-001`/`-002` verdicts verbatim rather
+ * than recomputing a competing coverage status.
+ *
+ * Ordering: requirements sorted by id; within a requirement, its verification
+ * rows sorted by verification id. Both are explicit sorts over the index's
+ * values, so the result is independent of the Map's insertion order (which —
+ * for a caller that built the index from a filesystem walk — would otherwise
+ * track directory enumeration order).
+ */
+export function buildRequirementVerificationMatrix(
+  index: ComplianceIndex,
+  options: RequirementVerificationMatrixOptions = {},
+): RequirementVerificationMatrix {
+  const gapReport = buildGapReport(index, options);
+  const noVerification = new Set(gapReport.requirementsWithoutVerification.map(r => r.id));
+  const unresolvedVerification = new Set(gapReport.requirementsWithUnresolvedVerification.map(r => r.id));
+
+  const requirements = [...index.requirementById.values()].sort(byId);
+
+  const rows: RequirementVerificationRow[] = [];
+  let verificationRowCount = 0;
+  let gapRequirementCount = 0;
+
+  for (const requirement of requirements) {
+    const parentId = requirement.parent;
+    const parentLabel = parentId ? index.requirementById.get(parentId)?.name : undefined;
+
+    const base: Pick<RequirementVerificationRow, 'requirementId' | 'requirementLabel' | 'parentId' | 'parentLabel'> = {
+      requirementId: requirement.id,
+      requirementLabel: requirement.name,
+      ...(parentId !== undefined ? { parentId } : {}),
+      ...(parentLabel !== undefined ? { parentLabel } : {}),
+    };
+
+    if (noVerification.has(requirement.id)) {
+      gapRequirementCount++;
+      rows.push({ ...base, coverageGap: 'REQ-VERIF-COVERAGE-001' });
+      continue;
+    }
+
+    const gap = unresolvedVerification.has(requirement.id) ? ('REQ-VERIF-COVERAGE-002' as const) : undefined;
+    if (gap) gapRequirementCount++;
+
+    const verifications = [...(index.verificationsByRequirement.get(requirement.id) ?? [])].sort(byId);
+    for (const verification of verifications) {
+      verificationRowCount++;
+      rows.push({
+        ...base,
+        verificationId: verification.id,
+        verificationLabel: verification.protocol ?? verification.id,
+        verificationOutcome: verification.outcome,
+        ...(gap ? { coverageGap: gap } : {}),
+      });
+    }
+  }
+
+  return {
+    rows,
+    summary: {
+      requirements: requirements.length,
+      verifications: verificationRowCount,
+      gaps: gapRequirementCount,
+    },
+  };
+}

package/src/compliance-verification-matrix/csv.ts

@@ -0,0 +1,47 @@
+// Deterministic CSV serialiser for the requirement-verification matrix.
+// Same row order as `buildRequirementVerificationMatrix` (requirement id,
+// then verification id). CRLF line endings, RFC-4180 quoting — the same
+// convention as the Gap Dashboard export.
+
+import type { RequirementVerificationMatrix, RequirementVerificationRow } from './types.js';
+
+const HEADER = [
+  'requirement_id',
+  'requirement_label',
+  'parent_id',
+  'parent_label',
+  'related_test_result_id',
+  'related_test_result_label',
+  'outcome',
+  'coverage_gap',
+] as const;
+
+function csvCell(value: string | undefined): string {
+  const v = value ?? '';
+  return `"${v.replace(/"/g, '""')}"`;
+}
+
+function rowCells(row: RequirementVerificationRow): string[] {
+  return [
+    row.requirementId,
+    row.requirementLabel,
+    row.parentId ?? '',
+    row.parentLabel ?? '',
+    row.verificationId ?? '',
+    row.verificationLabel ?? '',
+    row.verificationOutcome ?? '',
+    row.coverageGap ?? '',
+  ];
+}
+
+/**
+ * Serialise the matrix to CSV. Identical input yields byte-identical output;
+ * the row order is the builder's stable order.
+ */
+export function renderRequirementVerificationMatrixCsv(matrix: RequirementVerificationMatrix): string {
+  const lines = [HEADER.map(h => csvCell(h)).join(',')];
+  for (const row of matrix.rows) {
+    lines.push(rowCells(row).map(csvCell).join(','));
+  }
+  return lines.join('\r\n') + '\r\n';
+}

package/src/compliance-verification-matrix/index.ts

@@ -0,0 +1,7 @@
+export { buildRequirementVerificationMatrix } from './build.js';
+export { renderRequirementVerificationMatrixCsv } from './csv.js';
+export type {
+  RequirementVerificationMatrix,
+  RequirementVerificationMatrixOptions,
+  RequirementVerificationRow,
+} from './types.js';

package/src/compliance-verification-matrix/types.ts

@@ -0,0 +1,85 @@
+// Requirement -> verification matrix — deterministic, repository-wide
+// projection over the shared compliance reverse-index. Pure data; the
+// consumer (a VS Code table, an export) renders it.
+
+import type { VerificationOutcome } from '../verification/types.js';
+
+/**
+ * One row of the requirement-verification matrix.
+ *
+ * A requirement with N admitted VERIFICATION records produces N rows, one per
+ * verification. A requirement with none still produces exactly one row,
+ * carrying the `REQ-VERIF-COVERAGE-001` gap. A requirement whose
+ * verifications exist but never closed (pass/fail) produces one row per
+ * verification — each carrying the `REQ-VERIF-COVERAGE-002` gap alongside its
+ * (still-open) outcome; the open verification is real data and is never
+ * replaced by a placeholder gap row.
+ *
+ * Coverage comes only from `VERIFICATION.verifies` (27-verification.md §2). A
+ * child requirement's verification never covers its `parent`
+ * (15-requirement.md §2.4 — `parent` records structure only, no roll-up).
+ */
+export interface RequirementVerificationRow {
+  requirementId: string;
+  requirementLabel: string;
+
+  /**
+   * Direct `REQUIREMENT.parent` id, verbatim, present whenever the field is
+   * set — whether or not it resolves. `parent` resolution is not currently a
+   * validator concern (15-requirement.md §2.4); a dangling parent must still
+   * be visible on the row, not silently dropped.
+   */
+  parentId?: string;
+  /**
+   * The resolved parent's `name`, present only when `parentId` names an
+   * admitted requirement in the index. Absent when `parentId` is set but
+   * unresolved (dangling), or when the requirement has no parent.
+   */
+  parentLabel?: string;
+
+  /** The verification filling this row, when one exists. */
+  verificationId?: string;
+  /**
+   * VERIFICATION carries no `name`/label field of its own
+   * (27-verification.md §2); `protocol` — the procedure description — is the
+   * closest human-readable text and is what this row shows as its label.
+   */
+  verificationLabel?: string;
+  verificationOutcome?: VerificationOutcome;
+
+  /**
+   * `REQ-VERIF-COVERAGE-001` / `-002` (`compliance/gap-report.ts`), reused
+   * verbatim — this builder never recomputes a competing coverage verdict.
+   * Absent once the requirement has at least one closed (pass/fail)
+   * verification.
+   */
+  coverageGap?: 'REQ-VERIF-COVERAGE-001' | 'REQ-VERIF-COVERAGE-002';
+}
+
+export interface RequirementVerificationMatrixOptions {
+  /**
+   * Forwarded to `buildGapReport`. Neither coverage gap this matrix surfaces
+   * (`REQ-VERIF-COVERAGE-001`/`-002`) depends on `today` — accepted only for
+   * call-site symmetry with the other compliance-view builders.
+   */
+  today?: string;
+}
+
+export interface RequirementVerificationMatrix {
+  /**
+   * One row per (requirement, verification) pair, plus one gap row per
+   * requirement with zero verifications.
+   *
+   * Ordering (stable, independent of filesystem/Map enumeration order):
+   * requirements sorted by id; within a requirement, its verification rows
+   * sorted by verification id.
+   */
+  rows: RequirementVerificationRow[];
+  summary: {
+    requirements: number;
+    /** Rows carrying a real verification (excludes -001 gap-only rows). */
+    verifications: number;
+    /** Requirements carrying a REQ-VERIF-COVERAGE-001 or -002 gap. */
+    gaps: number;
+  };
+}

package/src/fgca/action-change-ids.ts

@@ -0,0 +1,13 @@
+/**
+ * Action → Change linkage on an element record.
+ *
+ * Canonical field is `delivers_changes` (Action element spec). `changes` is
+ * the pre-rename alias still present on older fixtures and inline docs.
+ */
+export function actionChangeLinkField(
+  el: Record<string, unknown>,
+): 'delivers_changes' | 'changes' {
+  return Object.prototype.hasOwnProperty.call(el, 'delivers_changes')
+    ? 'delivers_changes'
+    : 'changes';
+}

package/src/fgca/parse-canonical.ts

@@ -8,7 +8,7 @@
  * - Typed string IDs per `IDS_AND_REFERENCES.md` (`FACTOR-1`,
  *   `GOAL-RET-1`, `CHANGE-1`, `ACTION-ONBOARD-1` (legacy `ACTIVITY-*` accepted).
  * - Plural canonical-direction cross-references: `goal.factors`,
- *   `change.goals`, `activity.changes`, `activity.goals`.
+ *   `change.goals`, `action.delivers_changes`, `action.goals`.
  * - Per-notation validation codes `FGCA-001 … FGCA-015`.
  *
  * Returns the validation result plus, on success, an internal `FGCADoc`
@@ -36,6 +36,7 @@ import type {
   ValidationWarning,
   ValidationResult,
 } from '../validation-types.js';
+import { actionChangeLinkField } from './action-change-ids.js';
 
 export interface CanonicalFGCAResult extends ValidationResult {
   /** On success, the internal-form FGCADoc derived from the canonical input. */
@@ -64,9 +65,10 @@ function asObjectArray(v: unknown): Array<Record<string, unknown>> | null {
   return v.map((el) => (el && typeof el === 'object' ? (el as Record<string, unknown>) : null) as Record<string, unknown>);
 }
 
-/** DGA mode (`view_config.layers.changes: off`) may omit the changes layer. */
-function isChangesLayerOff(raw: Record<string, unknown>): boolean {
-  const vc = raw['view_config'];
+/** DGA mode (`view_config.layers.changes: off`) omits the Changes column. */
+export function isDgcaChangesLayerOff(input: unknown): boolean {
+  if (!input || typeof input !== 'object') return false;
+  const vc = (input as Record<string, unknown>)['view_config'];
   if (!vc || typeof vc !== 'object') return false;
   const layers = (vc as Record<string, unknown>)['layers'];
   if (!layers || typeof layers !== 'object') return false;
@@ -125,7 +127,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   const factorsRaw = asObjectArray(raw['factors']);
   const goalsRaw = asObjectArray(raw['goals']);
   let changesRaw = asObjectArray(raw['changes']);
-  if (changesRaw === null && raw['changes'] === undefined && isChangesLayerOff(raw)) {
+  if (changesRaw === null && raw['changes'] === undefined && isDgcaChangesLayerOff(raw)) {
     changesRaw = [];
   }
   const activitiesRaw = asObjectArray(raw['actions']);
@@ -253,11 +255,12 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     };
   });
 
-  // Build a reverse mapping: which changes does each activity reference (via
-  // canonical activity.changes)? Used to populate the internal `change.activity_ids`.
+  // Build a reverse mapping: which changes does each action deliver (via
+  // canonical `delivers_changes`, or the pre-rename `changes` alias)?
   const activityChangesByCanonicalActivityId = new Map<string, string[]>();
   activities.forEach((el, i) => {
-    const refIds = checkRefArray(el!, 'changes', changeIds, CHANGE_ID_RE, 'FGCA-010', `activities[${i}]`);
+    const field = actionChangeLinkField(el!);
+    const refIds = checkRefArray(el!, field, changeIds, CHANGE_ID_RE, 'FGCA-010', `activities[${i}]`);
     activityChangesByCanonicalActivityId.set(String(el!['id']), refIds);
   });
 
@@ -331,6 +334,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     goals: internalGoals,
     changes: internalChanges,
     activities: internalActivities,
+    hideChanges: isDgcaChangesLayerOff(raw),
   };
 
   return { valid: true, errors, warnings, parsed };

package/src/fgca/resolver.ts

@@ -7,6 +7,8 @@
  * string IDs.  Filesystem-free — callable from unit tests without vscode.
  */
 
+import { actionChangeLinkField } from './action-change-ids.js';
+
 export interface FGCAViewConfig {
   goals?: {
     filter?: 'all' | 'ids' | 'tags';
@@ -15,6 +17,8 @@ export interface FGCAViewConfig {
   };
   factors?: { surface?: 'derived' | 'all' };
   changes?: { surface?: 'derived' | 'all' };
+  /** Canonical projection key. `activities` remains a deprecated alias. */
+  actions?: { surface?: 'derived' | 'all' };
   activities?: { surface?: 'derived' | 'all' };
   display?: { depth?: number | null; collapsed?: string[] };
 }
@@ -69,8 +73,8 @@ export function isFGCAViewDoc(parsed: unknown): boolean {
  * to pass to `parseCanonicalFGCA`.
  *
  * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
- * `action.changes[]`) are carried from the canon elements unchanged; the
- * resolver decides which elements to include, not how they are shaped.
+ * `action.delivers_changes[]`) are carried from the canon elements unchanged;
+ * the resolver decides which elements to include, not how they are shaped.
  */
 export function resolveFGCA(
   viewDoc: unknown,
@@ -84,7 +88,11 @@ export function resolveFGCA(
   const goalsConf = isObject(vc['goals']) ? vc['goals'] : {};
   const factorsConf = isObject(vc['factors']) ? vc['factors'] : {};
   const changesConf = isObject(vc['changes']) ? vc['changes'] : {};
-  const activitiesConf = isObject(vc['activities']) ? vc['activities'] : {};
+  const actionsConf = isObject(vc['actions'])
+    ? vc['actions']
+    : isObject(vc['activities'])
+      ? vc['activities']
+      : {};
 
   const factorElemsLegacy = collectByNotation(sources.elements, 'factor');
   const factorElemsNew = collectByNotation(sources.elements, 'driver');
@@ -139,13 +147,13 @@ export function resolveFGCA(
     selectedChanges.map((c) => str(c['id'])).filter((x): x is string => x !== undefined),
   );
 
-  // 4. Select activities: derived = reference ≥1 selected change or goal (degenerate FGA link)
+  // 4. Select actions: derived = delivers ≥1 selected change, or (DGA) a selected goal
   let selectedActivities: Array<Record<string, unknown>>;
-  if (str(activitiesConf['surface']) === 'all') {
+  if (str(actionsConf['surface']) === 'all') {
     selectedActivities = [...activityElems.values()];
   } else {
     selectedActivities = [...activityElems.values()].filter((a) =>
-      strArray(a['changes']).some((cid) => selectedChangeIds.has(cid)) ||
+      strArray(a[actionChangeLinkField(a)]).some((cid) => selectedChangeIds.has(cid)) ||
       strArray(a['goals']).some((gid) => selectedGoalIds.has(gid)),
     );
   }
@@ -159,5 +167,6 @@ export function resolveFGCA(
     goals: selectedGoals,
     changes: selectedChanges,
     actions: selectedActivities,
+    view_config: viewDoc['view_config'],
   };
 }

package/src/fgca/validate.ts

@@ -19,6 +19,8 @@ export interface FGCADoc {
   goals: GoalItem[];
   changes: BdnChangeWithActivities[];
   activities: ActivityItem[];
+  /** DGA mode: omit the Changes column (`view_config.layers.changes: off`). */
+  hideChanges?: boolean;
 }
 
 export function validateFGCADoc(input: unknown): FGCAValidationResult {

package/src/index.ts

@@ -38,6 +38,7 @@ export {
 export * from "./change/index";
 export * from "./compliance/index";
 export * from "./compliance-matrix/index";
+export * from "./compliance-verification-matrix/index";
 export * from "./confidence/index";
 export * from "./factor/index";
 export * from "./fgca/index";

package/src/process-blueprint/index.ts

@@ -27,6 +27,17 @@ export type {
   ValidationError as ProcessBlueprintValidationError,
   ValidationWarning as ProcessBlueprintValidationWarning,
   ValidationResult as ProcessBlueprintValidationResult,
+  ProcessBlueprintValidateOptions,
+  ProcessParentEdge,
 } from './validate.js';
 
 export { layoutProcessBlueprint } from './layout.js';
+export {
+  collectProcessColumnRecords,
+  collectStepHomeProcess,
+  columnIndexesForRealisedVia,
+  isProcessColumnId,
+  isStageColumnId,
+  resolveColumnDisplay,
+} from './resolve-columns.js';
+export type { ProcessColumnRecord } from './resolve-columns.js';