@transitrix/diagrams 1.3.0 → 1.4.0

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'] },
       ],
@@ -180,13 +180,13 @@ describe('parseCanonicalFGCA — edge-driving fields populated', () => {
 
 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)', () => {
@@ -229,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);
@@ -245,12 +245,12 @@ 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([]);

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');

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

@@ -2,11 +2,11 @@ import { describe, it, expect } from 'vitest';
 import { validateFGCADoc } from '../validate.js';
 
 const VALID_DOC = {
-  notation: 'fgca',
+  notation: 'dgca',
   factors: [{ id: 1, name: 'Market pressure' }],
   goals: [{ id: 1, name: 'Grow revenue', factor: [{ id: 1 }] }],
   changes: [{ id: 1, name: 'Launch product', goal_id: 1, activity_ids: [1] }],
-  activities: [{ id: 1, name: 'Market research', goal_id: 1 }],
+  actions: [{ id: 1, name: 'Market research', goal_id: 1 }],
 };
 
 describe('validateFGCADoc', () => {
@@ -37,28 +37,28 @@ describe('validateFGCADoc', () => {
 
   it('errors when factors array is missing', () => {
     const { factors: _, ...without } = VALID_DOC;
-    const result = validateFGCADoc({ ...without, notation: 'fgca' });
+    const result = validateFGCADoc({ ...without, notation: 'dgca' });
     expect(result.valid).toBe(false);
     expect(result.errors.some(e => e.path === 'factors')).toBe(true);
   });
 
   it('errors when goals array is missing', () => {
     const { goals: _, ...without } = VALID_DOC;
-    const result = validateFGCADoc({ ...without, notation: 'fgca' });
+    const result = validateFGCADoc({ ...without, notation: 'dgca' });
     expect(result.valid).toBe(false);
     expect(result.errors.some(e => e.path === 'goals')).toBe(true);
   });
 
   it('errors when changes array is missing', () => {
     const { changes: _, ...without } = VALID_DOC;
-    const result = validateFGCADoc({ ...without, notation: 'fgca' });
+    const result = validateFGCADoc({ ...without, notation: 'dgca' });
     expect(result.valid).toBe(false);
     expect(result.errors.some(e => e.path === 'changes')).toBe(true);
   });
 
   it('errors when actions array is missing', () => {
-    const { activities: _, ...without } = VALID_DOC;
-    const result = validateFGCADoc({ ...without, notation: 'fgca' });
+    const { actions: _, ...without } = VALID_DOC;
+    const result = validateFGCADoc({ ...without, notation: 'dgca' });
     expect(result.valid).toBe(false);
     expect(result.errors.some(e => e.path === 'actions')).toBe(true);
   });
@@ -104,11 +104,11 @@ describe('validateFGCADoc', () => {
 
   it('accepts a document with empty arrays', () => {
     const result = validateFGCADoc({
-      notation: 'fgca',
+      notation: 'dgca',
       factors: [],
       goals: [],
       changes: [],
-      activities: [],
+      actions: [],
     });
     expect(result.valid).toBe(true);
   });
@@ -134,8 +134,8 @@ describe('validateFGCADoc', () => {
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
   });
-  it('[blocker] tolerates a null element in activities[] without throwing', () => {
-    const r = validateFGCADoc({ ...VALID_DOC, activities: [null] });
+  it('[blocker] tolerates a null element in actions[] without throwing', () => {
+    const r = validateFGCADoc({ ...VALID_DOC, actions: [null] });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
   });

package/src/fgca/parse-canonical.ts

@@ -82,21 +82,18 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
 
   const raw = input as Record<string, unknown>;
 
-  if ('notation' in raw && raw['notation'] !== 'fgca' && raw['notation'] !== 'dgca') {
+  if ('notation' in raw && raw['notation'] !== 'dgca') {
     return {
       valid: false,
       errors: [
         {
           code: 'FGCA-001',
-          message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw['notation'])}"`,
+          message: `notation must be "dgca", got "${String(raw['notation'])}"`,
         },
       ],
       warnings,
     };
   }
-  if ('notation' in raw && raw['notation'] === 'fgca') {
-    warnings.push({ code: 'FGCA-001', message: 'notation "fgca" is deprecated — rename to "dgca"' });
-  }
 
   // FGCA-002 — document id (optional in v1.4 per the canonical spec? — spec
   // says required; absence is FGCA-002).
@@ -118,10 +115,9 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   const factorsRaw = asObjectArray(raw['factors']);
   const goalsRaw = asObjectArray(raw['goals']);
   const changesRaw = asObjectArray(raw['changes']);
-  // Accept canonical `actions:` or deprecated `activities:`; warn on the latter.
-  const activitiesRaw = asObjectArray(raw['actions']) ?? asObjectArray(raw['activities']);
-  if ('activities' in raw && !('actions' in raw)) {
-    warnings.push({ code: 'FGCA-001', message: '"activities" key is deprecated — rename to "actions"' });
+  const activitiesRaw = asObjectArray(raw['actions']);
+  if (activitiesRaw === null && 'activities' in raw) {
+    errors.push({ code: 'FGCA-004', message: '"activities" key is not accepted — rename to "actions"', path: 'actions' });
   }
 
   if (factorsRaw === null) errors.push({ code: 'FGCA-004', message: 'factors must be an array', path: 'factors' });
@@ -348,10 +344,10 @@ export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
     return { valid: false, errors: [{ code: 'FGA-001', message: 'document root is not an object' }], warnings: [] };
   }
   const raw = input as Record<string, unknown>;
-  if ('notation' in raw && raw['notation'] !== 'fga' && raw['notation'] !== 'dga') {
+  if ('notation' in raw && raw['notation'] !== 'dga') {
     return {
       valid: false,
-      errors: [{ code: 'FGA-001', message: `notation must be "dga" (or legacy "fga"), got "${String(raw['notation'])}"` }],
+      errors: [{ code: 'FGA-001', message: `notation must be "dga", got "${String(raw['notation'])}"` }],
       warnings: [],
     };
   }

package/src/fgca/resolver.ts

@@ -3,7 +3,7 @@
  * view_config projection and a canon element/relation store (VP-3).
  *
  * Output shape matches the flat form that `parseCanonicalFGCA` expects:
- * top-level `factors[]`, `goals[]`, `changes[]`, `activities[]` with typed
+ * top-level `factors[]`, `goals[]`, `changes[]`, `actions[]` with typed
  * string IDs.  Filesystem-free — callable from unit tests without vscode.
  */
 
@@ -69,7 +69,7 @@ export function isFGCAViewDoc(parsed: unknown): boolean {
  * to pass to `parseCanonicalFGCA`.
  *
  * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
- * `activity.changes[]`) are carried from the canon elements unchanged; the
+ * `action.changes[]`) are carried from the canon elements unchanged; the
  * resolver decides which elements to include, not how they are shaped.
  */
 export function resolveFGCA(
@@ -77,7 +77,7 @@ export function resolveFGCA(
   sources: FGCACanonSources,
 ): Record<string, unknown> {
   if (!isObject(viewDoc)) {
-    return { notation: 'fgca', factors: [], goals: [], changes: [], activities: [] };
+    return { notation: 'dgca', factors: [], goals: [], changes: [], actions: [] };
   }
 
   const vc = isObject(viewDoc['view_config']) ? viewDoc['view_config'] : {};
@@ -147,13 +147,13 @@ export function resolveFGCA(
   }
 
   return {
-    notation: 'fgca',
+    notation: 'dgca',
     id: viewDoc['id'],
     name: viewDoc['name'],
     spec_version: viewDoc['spec_version'],
     factors: selectedFactors,
     goals: selectedGoals,
     changes: selectedChanges,
-    activities: selectedActivities,
+    actions: selectedActivities,
   };
 }