@transitrix/diagrams 1.2.0 → 1.4.0

package/src/activity-card/layout.ts

@@ -183,7 +183,7 @@ export function layoutActivityCard(
     cursorY += height + SECTION_GAP;
   }
 
-  // ── 5. Chain: Drivers → Assessments → Goals → Changes ────────────────────
+  // ── 5. Chain: Drivers → Goals → Changes ──────────────────────────────────
   // Each section is a full-width band with a header label and stacked node rows.
   // An empty section shows a gap indicator ("— not on file") so the author
   // sees which parts of the narrative are missing.
@@ -222,14 +222,10 @@ export function layoutActivityCard(
   }
 
   const { drivers, goals, changes } = card.motivation;
-  const assessments = card.assessments ?? [];
 
   pushChainSection('drivers', 'Drivers', 'What prompted this initiative?',
     drivers.map((d) => ({ id: d.id, name: d.name })));
 
-  pushChainSection('assessments', 'Assessments', 'What is the current gap?',
-    assessments.map((a) => ({ id: a.id, name: a.name, meta: a.observed_at })));
-
   pushChainSection('goals', 'Goals', 'What outcome do we target?',
     goals.map((g) => ({ id: g.id, name: g.name })));
 
@@ -242,9 +238,6 @@ export function layoutActivityCard(
   // Node-level chain edges.
   const driverIdSet = new Set(drivers.map((d) => d.id));
   const goalIdSet = new Set(goals.map((g) => g.id));
-  for (const a of assessments) {
-    if (driverIdSet.has(a.driverId)) chainEdges.push({ sourceId: a.driverId, targetId: a.id });
-  }
   for (const g of goals) {
     for (const did of g.driverIds) {
       if (driverIdSet.has(did)) chainEdges.push({ sourceId: did, targetId: g.id });

package/src/activity-card/resolver.ts

@@ -372,10 +372,19 @@ export function resolveActivityCard(
   // element name, falling back to the id when the element is absent.
   const goalNames = projectGoalIds.map((gid) => str(goalElems.get(gid)?.['name']) ?? gid);
 
-  // ── Stakeholders — active `activity_stakeholder` relations from the project ──
+  // ── Stakeholders — inline `stakeholders: []` on the Action element PLUS active
+  //    `action_stakeholder` / `activity_stakeholder` REL files. Both sources are
+  //    merged; REL entries take precedence (they carry the role field).
   const stakeholderElems = collectByNotation(sources.elements, 'stakeholder');
+  const relStakeholderRefs = activeActivityStakeholders(sources.relations, projectId);
+  const relStakeholderIds = new Set(relStakeholderRefs.map((s) => s.id));
+  const inlineStakeholderIds = strArray(projectRec['stakeholders']).filter((id) => !relStakeholderIds.has(id));
+  const allStakeholderRefs: Array<{ id: string; role?: string }> = [
+    ...relStakeholderRefs,
+    ...inlineStakeholderIds.map((id) => ({ id })),
+  ];
   const stakeholders: ResolvedStakeholder[] = [];
-  for (const { id: sid, role } of activeActivityStakeholders(sources.relations, projectId)) {
+  for (const { id: sid, role } of allStakeholderRefs) {
     const rec = stakeholderElems.get(sid);
     if (!rec) {
       warnings.push({

package/src/activity-card/types.ts

@@ -285,7 +285,7 @@ export interface ChainEdge {
  * so the author sees the missing data.
  */
 export interface ChainSectionLayout {
-  type: 'drivers' | 'assessments' | 'goals' | 'changes';
+  type: 'drivers' | 'goals' | 'changes';
   /** Section header label. */
   label: string;
   /** Short question answered by this section, shown in grey after the label. */

package/src/activity-card/validate.ts

@@ -49,21 +49,15 @@ export function validateActivityCard(input: unknown): ValidationResult {
   // ── Header (CONTRACT.md §2) ────────────────────────────────────────────────
   if (!('notation' in raw)) {
     errors.push({ code: 'HDR-001', message: 'notation field is required' });
-  } else if (raw['notation'] !== 'action-card' && raw['notation'] !== 'activity-card') {
+  } else if (raw['notation'] !== 'action-card') {
     errors.push({
       code: 'HDR-002',
       message: `notation must be "action-card", got "${String(raw['notation'])}"`,
     });
-  } else if (raw['notation'] === 'activity-card') {
-    warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation: "activity-card" is deprecated — migrate to notation: "action-card"' });
   }
 
-  // ── action_card / activity_card block ───────────────────────────────────────
-  // "action_card:" is canonical; "activity_card:" is accepted for compat.
-  const rawBlock = raw['action_card'] ?? raw['activity_card'];
-  if (raw['activity_card'] !== undefined && raw['action_card'] === undefined) {
-    warnings.push({ code: 'DEPRECATED_FIELD', message: 'Root key "activity_card:" is deprecated — rename to "action_card:"' });
-  }
+  // ── action_card block ────────────────────────────────────────────────────────
+  const rawBlock = raw['action_card'];
   const block = rawBlock;
   if (!block || typeof block !== 'object' || Array.isArray(block)) {
     errors.push({ code: 'AC-001', message: 'Missing required root key: action_card (object)' });

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

@@ -103,4 +103,12 @@ describe('validateActor — ACTOR-003 (engagement fields forbidden inline)', ()
   it('flags inline owner', () => {
     expect(codes({ ...valid(), owner: 'ACTOR-OPS-1' })).toContain('ACTOR-003');
   });
+
+  it('flags inline located_at (location belongs in a REL file)', () => {
+    expect(codes({ ...valid(), located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+  });
+
+  it('flags inline unit_located_at (location belongs in a REL file)', () => {
+    expect(codes({ ...valid(), unit_located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+  });
 });

package/src/actor/types.ts

@@ -18,6 +18,8 @@ export const ACTOR_FORBIDDEN_INLINE_FIELDS = [
   'community_membership',
   'contracting',
   'unit_parent',
+  'located_at',
+  'unit_located_at',
   'roles',
   'owner',
 ] as const;

package/src/applications/types.ts

@@ -2,11 +2,19 @@ export type ApplicationType = 'application' | 'integration' | 'platform' | 'data
 export type ApplicationStatus = 'Draft' | 'Active' | 'Deprecated' | 'Decommissioning';
 export type IntegrationDirection = 'inbound' | 'outbound' | 'bidirectional';
 
+export type IntegrationSensitivity = 'public' | 'internal' | 'confidential' | 'restricted';
+export type IntegrationDirectionality = 'producer' | 'consumer' | 'request_reply' | 'bidirectional_stream';
+
 export interface ApplicationIntegration {
   target?: string;
+  source?: string;
   direction?: IntegrationDirection;
   protocol?: string;
   description?: string;
+  interface_semantics?: boolean;
+  payload_class?: string;
+  sensitivity?: IntegrationSensitivity;
+  directionality?: IntegrationDirectionality;
 }
 
 export interface Application {

package/src/applications/validate.ts

@@ -6,8 +6,12 @@ export type { ValidationError, ValidationWarning, ValidationResult };
 const VALID_TYPES = new Set<ApplicationType>(['application', 'integration', 'platform', 'data_store']);
 const VALID_STATUSES = new Set<ApplicationStatus>(['Draft', 'Active', 'Deprecated', 'Decommissioning']);
 const VALID_DIRECTIONS = new Set<IntegrationDirection>(['inbound', 'outbound', 'bidirectional']);
+const VALID_SENSITIVITY = new Set(['public', 'internal', 'confidential', 'restricted']);
+const VALID_DIRECTIONALITY = new Set(['producer', 'consumer', 'request_reply', 'bidirectional_stream']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
+const IFACE_CONDITIONAL = ['protocol', 'payload_class', 'sensitivity', 'directionality'] as const;
+
 export function validateApplicationsCatalogue(input: unknown): ValidationResult {
   const errors: ValidationError[] = [];
   const warnings: ValidationWarning[] = [];
@@ -123,6 +127,22 @@ export function validateApplicationsCatalogue(input: unknown): ValidationResult
         if (intg['direction'] !== undefined && !VALID_DIRECTIONS.has(intg['direction'] as IntegrationDirection)) {
           errors.push({ code: 'APP-009', message: `${idx}.integrations[${j}]: direction "${intg['direction']}" must be one of: inbound, outbound, bidirectional` });
         }
+
+        // INT-001 — when interface_semantics: true, four fields become required.
+        if (intg['interface_semantics'] === true) {
+          for (const field of IFACE_CONDITIONAL) {
+            const v = intg[field];
+            if (typeof v !== 'string' || (v as string).trim() === '') {
+              errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: ${field} is required when interface_semantics is true.`, path: `${idx}.integrations[${j}].${field}` });
+            }
+          }
+          if (typeof intg['sensitivity'] === 'string' && !VALID_SENSITIVITY.has(intg['sensitivity'])) {
+            errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: sensitivity "${intg['sensitivity']}" must be one of public, internal, confidential, restricted.`, path: `${idx}.integrations[${j}].sensitivity` });
+          }
+          if (typeof intg['directionality'] === 'string' && !VALID_DIRECTIONALITY.has(intg['directionality'])) {
+            errors.push({ code: 'INT-001', message: `${idx}.integrations[${j}]: directionality "${intg['directionality']}" must be one of producer, consumer, request_reply, bidirectional_stream.`, path: `${idx}.integrations[${j}].directionality` });
+          }
+        }
       }
     }
   }

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

@@ -119,7 +119,7 @@ describe('layoutNestedBlocks', () => {
     });
     const a = layout.blocks[0];
     expect(a.width).toBe(160);
-    expect(a.height).toBe(60);
+    expect(a.height).toBe(72);
   });
 
   it('honours custom layout options', () => {

package/src/blocks/layout.ts

@@ -8,7 +8,7 @@ import type {
 
 const DEFAULTS: Required<BlocksLayoutOptions> = {
   leafWidth: 160,
-  leafHeight: 60,
+  leafHeight: 72,
   padding: 12,
   headerHeight: 28,
   childGap: 12,

package/src/business-service/__tests__/validate.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest';
+import { validateBusinessService } from '../validate.js';
+
+function valid(): Record<string, unknown> {
+  return {
+    notation: 'business-service',
+    id: 'BUSINESS_SERVICE-CRM-1',
+    name: 'CRM Service',
+    type: 'internal',
+    description: 'Customer relationship management service offering contact management and deal tracking.',
+    offering_unit: 'ACTOR-SALES-OPS-1',
+    capability: 'CAPABILITY-V2.1',
+    zone: 'canon',
+    admitted_at: '2026-06-28',
+    admitted_by: 'v.korobeinikov',
+    gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+    valid_from: '2024-01-01',
+    valid_to: null,
+  };
+}
+
+const codes = (input: unknown): string[] =>
+  validateBusinessService(input).errors.map(e => e.code);
+
+describe('validateBusinessService — positive', () => {
+  it('accepts a well-formed internal service with all optional fields', () => {
+    const r = validateBusinessService(valid());
+    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+  });
+
+  it('accepts an external service with no optional fields', () => {
+    const a = valid();
+    a.id = 'BUSINESS_SERVICE-ONBOARDING-1';
+    a.name = 'Onboarding Service';
+    a.type = 'external';
+    delete a.description;
+    delete a.offering_unit;
+    delete a.capability;
+    expect(validateBusinessService(a).valid).toBe(true);
+  });
+
+  it('accepts a shared service offered by a ROLE', () => {
+    expect(validateBusinessService({ ...valid(), type: 'shared', offering_unit: 'ROLE-PLATFORM-OWNER-1' }).valid).toBe(true);
+  });
+
+  it('accepts valid_to as a date string', () => {
+    expect(validateBusinessService({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
+  });
+
+  it('accepts a service with no offering_unit or capability', () => {
+    const a = valid();
+    delete a.offering_unit;
+    delete a.capability;
+    expect(validateBusinessService(a).valid).toBe(true);
+  });
+});
+
+describe('validateBusinessService — BSV-001 (shape / id grammar)', () => {
+  it('flags a missing required envelope field (name)', () => {
+    const a = valid();
+    delete a.name;
+    expect(codes(a)).toContain('BSV-001');
+  });
+
+  it('flags an id that violates the grammar', () => {
+    expect(codes({ ...valid(), id: 'BUSINESS_SERVICE-001' })).toContain('BSV-001');
+    expect(codes({ ...valid(), id: 'BSV-1' })).toContain('BSV-001');
+    expect(codes({ ...valid(), id: 'business-service-1' })).toContain('BSV-001');
+  });
+
+  it('flags a wrong notation tag', () => {
+    expect(codes({ ...valid(), notation: 'service' })).toContain('BSV-001');
+    expect(codes({ ...valid(), notation: 'business_service' })).toContain('BSV-001');
+  });
+
+  it('flags a non-canon zone', () => {
+    expect(codes({ ...valid(), zone: 'sandbox' })).toContain('BSV-001');
+  });
+
+  it('flags a missing zone', () => {
+    const a = valid();
+    delete a.zone;
+    expect(codes(a)).toContain('BSV-001');
+  });
+
+  it('flags a missing type', () => {
+    const a = valid();
+    delete a.type;
+    expect(codes(a)).toContain('BSV-001');
+  });
+
+  it('flags a missing valid_to key', () => {
+    const a = valid();
+    delete a.valid_to;
+    expect(codes(a)).toContain('BSV-001');
+  });
+
+  it('flags missing gate_checks', () => {
+    const a = valid();
+    delete a.gate_checks;
+    expect(codes(a)).toContain('BSV-001');
+  });
+
+  it('rejects a non-object', () => {
+    expect(codes(null)).toEqual(['BSV-001']);
+    expect(codes('string')).toEqual(['BSV-001']);
+  });
+});
+
+describe('validateBusinessService — BSV-002 (type enum)', () => {
+  it('flags a type outside the allowed enum', () => {
+    expect(codes({ ...valid(), type: 'public' })).toContain('BSV-002');
+    expect(codes({ ...valid(), type: 'platform' })).toContain('BSV-002');
+  });
+
+  it('accepts all valid type values', () => {
+    for (const t of ['internal', 'external', 'shared']) {
+      expect(codes({ ...valid(), type: t })).not.toContain('BSV-002');
+    }
+  });
+});
+
+describe('validateBusinessService — BSV-003 (offering_unit grammar)', () => {
+  it('flags an offering_unit that is not an ACTOR-… or ROLE-… id', () => {
+    expect(codes({ ...valid(), offering_unit: 'PRODUCT-PLATFORM-1' })).toContain('BSV-003');
+    expect(codes({ ...valid(), offering_unit: 'not-an-id' })).toContain('BSV-003');
+    expect(codes({ ...valid(), offering_unit: 'BUSINESS_SERVICE-CRM-1' })).toContain('BSV-003');
+  });
+
+  it('accepts a null or absent offering_unit without error', () => {
+    expect(codes({ ...valid(), offering_unit: undefined })).not.toContain('BSV-003');
+    const a = valid();
+    delete a.offering_unit;
+    expect(codes(a)).not.toContain('BSV-003');
+  });
+
+  it('accepts ACTOR-… and ROLE-… ids', () => {
+    expect(codes({ ...valid(), offering_unit: 'ACTOR-OPS-1' })).not.toContain('BSV-003');
+    expect(codes({ ...valid(), offering_unit: 'ROLE-SERVICE-OWNER-1' })).not.toContain('BSV-003');
+  });
+});
+
+describe('validateBusinessService — BSV-004 (capability grammar)', () => {
+  it('flags a capability that is not a CAPABILITY-… id', () => {
+    expect(codes({ ...valid(), capability: 'PRODUCT-MOBILE-1' })).toContain('BSV-004');
+    expect(codes({ ...valid(), capability: 'not-a-capability' })).toContain('BSV-004');
+  });
+
+  it('accepts a null or absent capability without error', () => {
+    expect(codes({ ...valid(), capability: undefined })).not.toContain('BSV-004');
+    const a = valid();
+    delete a.capability;
+    expect(codes(a)).not.toContain('BSV-004');
+  });
+
+  it('accepts a CAPABILITY-… id', () => {
+    expect(codes({ ...valid(), capability: 'CAPABILITY-V2.1' })).not.toContain('BSV-004');
+    expect(codes({ ...valid(), capability: 'CAPABILITY-H3.1' })).not.toContain('BSV-004');
+  });
+});

package/src/business-service/index.ts

@@ -0,0 +1,3 @@
+export type { BusinessService, BusinessServiceType } from './types.js';
+export { BUSINESS_SERVICE_TYPES } from './types.js';
+export { validateBusinessService } from './validate.js';

package/src/business-service/types.ts

@@ -0,0 +1,29 @@
+// BUSINESS_SERVICE — externally visible behaviour primitive (ArchiMate Business Service).
+// Schema: methodology notations/elements/25-business-services.md
+
+import type { GateChecks } from '../requirement/types.js';
+
+export const BUSINESS_SERVICE_TYPES = ['internal', 'external', 'shared'] as const;
+export type BusinessServiceType = typeof BUSINESS_SERVICE_TYPES[number];
+
+export interface BusinessService {
+  notation: 'business-service';
+  id: string;
+  name: string;
+  type: BusinessServiceType;
+  description?: string;
+  offering_unit?: string;
+  capability?: string;
+  owner_role?: string;
+  status?: string;
+
+  // Admission record (CONTRACT.md §6).
+  zone: 'canon';
+  admitted_at: string;
+  admitted_by: string;
+  gate_checks: GateChecks;
+
+  // Primitive lifecycle (CONTRACT.md §7).
+  valid_from: string;
+  valid_to: string | null;
+}

package/src/business-service/validate.ts

@@ -0,0 +1,82 @@
+// BUSINESS_SERVICE validator — methodology notations/elements/25-business-services.md §5.
+//
+// Implements BSV-001..004. The shared HDR-/LIFECYCLE- rules are
+// cross-cutting concerns (CONTRACT.md §8) and out of scope for the
+// single-artefact validator.
+
+import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
+import { isCanonicalIdOfType, typeOfId } from '../typed-id.js';
+import { BUSINESS_SERVICE_TYPES } from './types.js';
+
+const REQUIRED_STRING_FIELDS = [
+  'name', 'admitted_at', 'admitted_by', 'valid_from',
+] as const;
+
+const TYPES: readonly string[] = BUSINESS_SERVICE_TYPES;
+
+export function validateBusinessService(input: unknown): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationWarning[] = [];
+
+  if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+    errors.push({ code: 'BSV-001', message: 'Business service must be a YAML mapping.' });
+    return { valid: false, errors, warnings };
+  }
+  const a = input as Record<string, unknown>;
+
+  // BSV-001 — id grammar + notation tag + envelope.
+  if (!isCanonicalIdOfType(a.id, 'BUSINESS_SERVICE')) {
+    errors.push({ code: 'BSV-001', message: `id "${String(a.id)}" must match BUSINESS_SERVICE-[<middle>-]<INTEGER>.`, path: 'id' });
+  }
+  if (a.notation !== 'business-service') {
+    errors.push({ code: 'BSV-001', message: 'notation must be the fixed value "business-service".', path: 'notation' });
+  }
+  if (a.zone !== undefined && a.zone !== 'canon') {
+    errors.push({ code: 'BSV-001', message: 'zone must be "canon" for a BUSINESS_SERVICE.', path: 'zone' });
+  } else if (a.zone === undefined) {
+    errors.push({ code: 'BSV-001', message: 'zone is required.', path: 'zone' });
+  }
+  for (const field of REQUIRED_STRING_FIELDS) {
+    const v = a[field];
+    if (typeof v !== 'string' || v.trim() === '') {
+      errors.push({ code: 'BSV-001', message: `${field} is required.`, path: field });
+    }
+  }
+  if (a.gate_checks === null || typeof a.gate_checks !== 'object') {
+    errors.push({ code: 'BSV-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+  }
+  if (!('valid_to' in a) || !(typeof a.valid_to === 'string' || a.valid_to === null)) {
+    errors.push({ code: 'BSV-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+  }
+  if (typeof a.type !== 'string' || a.type.trim() === '') {
+    errors.push({ code: 'BSV-001', message: 'type is required.', path: 'type' });
+  } else if (!TYPES.includes(a.type)) {
+    // BSV-002 — type enum.
+    errors.push({ code: 'BSV-002', message: `type "${a.type}" must be one of ${TYPES.join(', ')}.`, path: 'type' });
+  }
+
+  // BSV-003 — offering_unit must resolve to ACTOR(business_unit) or ROLE when present.
+  if ('offering_unit' in a && a.offering_unit !== undefined && a.offering_unit !== null) {
+    const t = typeOfId(a.offering_unit);
+    if (t !== 'ACTOR' && t !== 'ROLE') {
+      errors.push({
+        code: 'BSV-003',
+        message: `offering_unit "${String(a.offering_unit)}" must be an ACTOR-… or ROLE-… canonical id.`,
+        path: 'offering_unit',
+      });
+    }
+  }
+
+  // BSV-004 — capability must resolve to CAPABILITY when present.
+  if ('capability' in a && a.capability !== undefined && a.capability !== null) {
+    if (typeOfId(a.capability) !== 'CAPABILITY') {
+      errors.push({
+        code: 'BSV-004',
+        message: `capability "${String(a.capability)}" must be a CAPABILITY-… canonical id.`,
+        path: 'capability',
+      });
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}

package/src/fgca/__tests__/parse-canonical.test.ts

@@ -5,7 +5,7 @@ import yaml from 'js-yaml';
 import { parseCanonicalFGCA, parseCanonicalFGA } from '../parse-canonical.js';
 
 const VALID = {
-  notation: 'fgca',
+  notation: 'dgca',
   spec_version: '0.1',
   id: 'FGCA-SAMPLE-1',
   name: 'Sample FGCA chain',
@@ -18,7 +18,7 @@ const VALID = {
   changes: [
     { id: 'CHANGE-1', name: 'Transformation', goals: ['GOAL-1'] },
   ],
-  activities: [
+  actions: [
     { id: 'ACTIVITY-1', name: 'Workstream', changes: ['CHANGE-1'] },
   ],
 };
@@ -108,7 +108,7 @@ describe('parseCanonicalFGCA', () => {
   it('FGCA-010: rejects activity.changes[] referencing undefined change', () => {
     const r = parseCanonicalFGCA({
       ...VALID,
-      activities: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
+      actions: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some((e) => e.code === 'FGCA-010')).toBe(true);
@@ -135,7 +135,7 @@ describe('parseCanonicalFGCA', () => {
     const r = parseCanonicalFGCA({
       ...VALID,
       changes: [{ id: 'CHANGE-1', name: 'C', goals: ['GOAL-1'] }],
-      activities: [
+      actions: [
         { id: 'ACTIVITY-1', name: 'A1', changes: ['CHANGE-1'] },
         { id: 'ACTIVITY-2', name: 'A2', changes: ['CHANGE-1'] },
       ],
@@ -159,20 +159,34 @@ describe('parseCanonicalFGCA — edge-driving fields populated', () => {
     expect(parsed.goals[0].factor).toHaveLength(1);
     // goal → change edge
     expect(parsed.changes[0].goal_id).not.toBe(0);
+    expect(parsed.changes[0].goal_id).not.toBe('');
     // change → activity edge
     expect(parsed.changes[0].activity_ids).toHaveLength(1);
   });
+
+  it('preserves canonical string IDs — not converted to sequential numbers', () => {
+    const r = parseCanonicalFGCA(VALID);
+    expect(r.valid).toBe(true);
+    const parsed = r.parsed!;
+    expect(parsed.factors[0].id).toBe('FACTOR-1');
+    expect(parsed.goals[0].id).toBe('GOAL-1');
+    expect(parsed.goals[0].factor![0].id).toBe('FACTOR-1');
+    expect(parsed.changes[0].id).toBe('CHANGE-1');
+    expect(parsed.changes[0].goal_id).toBe('GOAL-1');
+    expect(parsed.changes[0].activity_ids[0]).toBe('ACTIVITY-1');
+    expect(parsed.activities[0].id).toBe('ACTIVITY-1');
+  });
 });
 
 describe('parseCanonicalFGA', () => {
   const VALID_FGA = {
-    notation: 'fga',
+    notation: 'dga',
     spec_version: '0.1',
     id: 'FGA-SAMPLE-1',
     name: 'Sample FGA chain',
     factors: [{ id: 'FACTOR-1', name: 'Driver' }],
     goals: [{ id: 'GOAL-1', name: 'Outcome', factors: ['FACTOR-1'] }],
-    activities: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-1'] }],
+    actions: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-1'] }],
   };
 
   it('accepts a valid canonical FGA document (no changes layer)', () => {
@@ -215,12 +229,12 @@ describe('parseCanonicalFGA', () => {
 });
 
 describe('parseCanonicalFGCA — example file regression', () => {
-  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca');
+  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca');
   const files = fs.existsSync(EXAMPLES_DIR)
     ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
     : [];
   for (const file of files) {
-    it(`accepts tests/fixtures/notation-corpus/fgca/${file}`, () => {
+    it(`accepts tests/fixtures/notation-corpus/dgca/${file}`, () => {
       const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
       const parsedYaml = yaml.load(text);
       const r = parseCanonicalFGCA(parsedYaml);
@@ -231,18 +245,18 @@ describe('parseCanonicalFGCA — example file regression', () => {
 });
 
 describe('parseCanonicalFGA — example file regression', () => {
-  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fga');
+  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dga');
   const files = fs.existsSync(EXAMPLES_DIR)
     ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
     : [];
   for (const file of files) {
-    it(`accepts tests/fixtures/notation-corpus/fga/${file} and resolves every activity to a goal`, () => {
+    it(`accepts tests/fixtures/notation-corpus/dga/${file} and resolves every activity to a goal`, () => {
       const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
       const r = parseCanonicalFGA(yaml.load(text));
       expect(r.errors).toEqual([]);
       expect(r.valid).toBe(true);
       // Every activity must carry a goal_id, or the FGA preview draws no edges.
-      expect(r.parsed!.activities.every((a) => a.goal_id != null && a.goal_id !== 0)).toBe(true);
+      expect(r.parsed!.activities.every((a) => a.goal_id != null && a.goal_id !== 0 && a.goal_id !== '')).toBe(true);
     });
   }
 });

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

@@ -26,7 +26,7 @@ const ELEMENTS = [
 const SOURCES = { elements: ELEMENTS, relations: [] };
 
 const VIEW_DOC = {
-  notation: 'fgca',
+  notation: 'dgca',
   id: 'FGCA-STRAT-1',
   name: 'Strategy 2026 — FGCA chain',
   spec_version: '0.1',
@@ -47,7 +47,7 @@ describe('isFGCAViewDoc', () => {
 
   it('returns false for an inline doc with factors/goals arrays', () => {
     expect(isFGCAViewDoc({
-      notation: 'fgca', id: 'FGCA-1', name: 'x',
+      notation: 'dgca', id: 'FGCA-1', name: 'x',
       factors: [], goals: [], changes: [], activities: [],
     })).toBe(false);
   });
@@ -66,7 +66,7 @@ describe('resolveFGCA — goals.filter=all', () => {
     const doc = resolveFGCA(VIEW_DOC, SOURCES);
     expect((doc['goals'] as unknown[]).length).toBe(3);
     expect((doc['changes'] as unknown[]).length).toBe(3);
-    expect((doc['activities'] as unknown[]).length).toBe(5);
+    expect((doc['actions'] as unknown[]).length).toBe(5);
   });
 
   it('derives factors from all goal.factors[] refs', () => {
@@ -90,7 +90,7 @@ describe('resolveFGCA — goals.filter=all', () => {
 
   it('carries view doc metadata (id, name, spec_version)', () => {
     const doc = resolveFGCA(VIEW_DOC, SOURCES);
-    expect(doc['notation']).toBe('fgca');
+    expect(doc['notation']).toBe('dgca');
     expect(doc['id']).toBe('FGCA-STRAT-1');
     expect(doc['name']).toBe('Strategy 2026 — FGCA chain');
     expect(doc['spec_version']).toBe('0.1');
@@ -110,7 +110,7 @@ describe('resolveFGCA — goals.filter=ids', () => {
     expect(goalIds).toEqual(['GOAL-1']);
     const changeIds = (doc['changes'] as Array<{ id: string }>).map((c) => c.id);
     expect(changeIds).toEqual(['CHANGE-1']);
-    const actIds = (doc['activities'] as Array<{ id: string }>).map((a) => a.id).sort();
+    const actIds = (doc['actions'] as Array<{ id: string }>).map((a) => a.id).sort();
     expect(actIds).toEqual(['ACTIVITY-1', 'ACTIVITY-2']);
     const r = parseCanonicalFGCA(doc);
     expect(r.valid).toBe(true);
@@ -159,7 +159,7 @@ describe('resolveFGCA — empty sources', () => {
     expect((doc['goals'] as unknown[]).length).toBe(0);
     expect((doc['factors'] as unknown[]).length).toBe(0);
     expect((doc['changes'] as unknown[]).length).toBe(0);
-    expect((doc['activities'] as unknown[]).length).toBe(0);
+    expect((doc['actions'] as unknown[]).length).toBe(0);
   });
 
   it('returns empty arrays for a non-object viewDoc', () => {
@@ -172,7 +172,7 @@ describe('resolveFGCA — empty sources', () => {
 
 describe('resolveFGCA — file-based regression against canon fixture', () => {
   const CANON_ROOT = path.resolve(
-    process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca', 'canon',
+    process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca', 'canon',
   );
   const VIEW_DIR = path.join(CANON_ROOT, 'views');
   const ELEM_DIR = path.join(CANON_ROOT, 'elements');