@transitrix/diagrams 1.2.0 → 1.4.0

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

@@ -4,43 +4,41 @@ import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { validateActivities } from '../validate.js';
 
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'activities');
+const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'action');
 
 const minimalValid = {
-  notation: 'activities',
-  activities: [
+  notation: 'action',
+  actions: [
     { id: 'A-001', name: 'Start', duration: 3 },
     { id: 'A-002', name: 'End', duration: 2, predecessors: ['A-001'] },
   ],
 };
 
 describe('validateActivities', () => {
-  it('ACT-001 — accepts notation: activities (deprecated)', () => {
+  it('ACT-001 — accepts notation: action (canonical)', () => {
     const r = validateActivities(minimalValid);
     expect(r.valid).toBe(true);
-    // deprecated notation emits a warning, not an error
-    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(true);
+    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
   });
 
-  it('ACT-001 — accepts notation: action (canonical)', () => {
+  it('ACT-001 — rejects notation: activities (no longer accepted)', () => {
     const r = validateActivities({
-      notation: 'action',
-      actions: [
-        { id: 'ACTION-001', name: 'Start', duration: 3 },
-        { id: 'ACTION-002', name: 'End', duration: 2, predecessors: ['ACTION-001'] },
+      notation: 'activities',
+      activities: [
+        { id: 'A-001', name: 'Start', duration: 3 },
       ],
     });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+    expect(r.valid).toBe(false);
+    expect(r.errors.some(e => e.code === 'ACT-001')).toBe(true);
   });
 
-  it('ACT-001 — accepts notation: action with deprecated activities: key (emits field warning)', () => {
+  it('ACT-001 — rejects activities: root key (only actions: accepted)', () => {
     const r = validateActivities({
       notation: 'action',
       activities: [{ id: 'ACTION-001', name: 'Foo', duration: 1 }],
     });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some(w => w.code === 'DEPRECATED_FIELD')).toBe(true);
+    expect(r.valid).toBe(false);
+    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
   });
 
   it('ACT-001 — normalises action_type to activity_type for downstream layout', () => {
@@ -69,8 +67,8 @@ describe('validateActivities', () => {
 
   it('ACT-002 — rejects activity with missing id', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ name: 'No ID', duration: 1 }],
+      notation: 'action',
+      actions: [{ name: 'No ID', duration: 1 }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
@@ -78,8 +76,8 @@ describe('validateActivities', () => {
 
   it('ACT-002 — rejects activity with empty id', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: '  ', name: 'Empty ID', duration: 1 }],
+      notation: 'action',
+      actions: [{ id: '  ', name: 'Empty ID', duration: 1 }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
@@ -87,8 +85,8 @@ describe('validateActivities', () => {
 
   it('ACT-003 — rejects activity with missing name', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', duration: 1 }],
+      notation: 'action',
+      actions: [{ id: 'A-001', duration: 1 }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-003')).toBe(true);
@@ -96,8 +94,8 @@ describe('validateActivities', () => {
 
   it('ACT-004 — rejects duplicate ids', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'First', duration: 1 },
         { id: 'A-001', name: 'Duplicate', duration: 2 },
       ],
@@ -108,8 +106,8 @@ describe('validateActivities', () => {
 
   it('ACT-005 — rejects unknown predecessor reference', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['MISSING'] }],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['MISSING'] }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-005')).toBe(true);
@@ -123,8 +121,8 @@ describe('validateActivities', () => {
 
   it('ACT-006 — rejects cyclic dependency', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task A', duration: 1, predecessors: ['A-002'] },
         { id: 'A-002', name: 'Task B', duration: 1, predecessors: ['A-001'] },
       ],
@@ -135,8 +133,8 @@ describe('validateActivities', () => {
 
   it('ACT-007 — rejects self-loop', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['A-001'] }],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['A-001'] }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-007')).toBe(true);
@@ -144,8 +142,8 @@ describe('validateActivities', () => {
 
   it('ACT-008 — rejects end_date before start_date', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task', duration: 5, start_date: '2026-06-10', end_date: '2026-06-01' },
       ],
     });
@@ -155,8 +153,8 @@ describe('validateActivities', () => {
 
   it('ACT-008 — accepts end_date equal to start_date', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
       ],
     });
@@ -165,8 +163,8 @@ describe('validateActivities', () => {
 
   it('ACT-008 — rejects non-ISO start_date format', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task', duration: 5, start_date: 'June 1 2026' },
       ],
     });
@@ -176,8 +174,8 @@ describe('validateActivities', () => {
 
   it('ACT-008 — rejects non-ISO end_date format', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task', duration: 5, end_date: '2026/06/30' },
       ],
     });
@@ -191,8 +189,8 @@ describe('validateActivities', () => {
     // on top would be misleading because the lexicographic compare is
     // meaningless on non-ISO strings.
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Task', duration: 5, start_date: 'tomorrow', end_date: 'yesterday' },
       ],
     });
@@ -202,8 +200,8 @@ describe('validateActivities', () => {
 
   it('ACT-009 — rejects negative duration', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: -1 }],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: -1 }],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-009')).toBe(true);
@@ -211,16 +209,16 @@ describe('validateActivities', () => {
 
   it('ACT-009 — accepts zero duration', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Milestone', duration: 0 }],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Milestone', duration: 0 }],
     });
     expect(r.errors.some(e => e.code === 'ACT-009')).toBe(false);
   });
 
   it('ACT-010 — rejects singular "goal:" field', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' } as any],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' } as any],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
@@ -228,8 +226,8 @@ describe('validateActivities', () => {
 
   it('ACT-010 — rejects singular "predecessor:" field', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'First', duration: 1 },
         { id: 'A-002', name: 'Task', duration: 1, predecessor: 'A-001' } as any,
       ],
@@ -240,8 +238,8 @@ describe('validateActivities', () => {
 
   it('ACT-010 — rejects singular "tag:" field', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' } as any],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' } as any],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
@@ -249,8 +247,8 @@ describe('validateActivities', () => {
 
   it('ACT-011 — warns when duration is absent', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'No duration' }],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'No duration' }],
     });
     expect(r.valid).toBe(true);
     expect(r.warnings.some(w => w.code === 'ACT-011')).toBe(true);
@@ -258,8 +256,8 @@ describe('validateActivities', () => {
 
   it('ACT-013 — warns on structurally orphan activity', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-001', name: 'Connected', duration: 1 },
         { id: 'A-002', name: 'Orphan', duration: 1 },
         { id: 'A-003', name: 'End', duration: 1, predecessors: ['A-001'] },
@@ -272,9 +270,9 @@ describe('validateActivities', () => {
 
   it('full valid example passes with no errors', () => {
     const r = validateActivities({
-      notation: 'activities',
+      notation: 'action',
       title: 'Test Project',
-      activities: [
+      actions: [
         { id: 'A', name: 'Start', duration: 3 },
         { id: 'B', name: 'Middle', duration: 5, predecessors: ['A'] },
         { id: 'C', name: 'End', duration: 2, predecessors: ['B'] },
@@ -333,8 +331,8 @@ describe('validateActivities', () => {
 
   it('ACT-016 — rejects milestone with mismatched start/end dates', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-02' },
       ],
     });
@@ -344,8 +342,8 @@ describe('validateActivities', () => {
 
   it('ACT-016 — accepts milestone with equal start/end dates', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
       ],
     });
@@ -356,8 +354,8 @@ describe('validateActivities', () => {
 
   it('ACT-017 — warns when a referenced-as-parent activity carries its own duration', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'PHASE-1', name: 'Design', duration: 5 },
         { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
       ],
@@ -368,8 +366,8 @@ describe('validateActivities', () => {
 
   it('ACT-017 — no warning when phase omits duration/dates and rolls up from children', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'PHASE-1', name: 'Design' },
         { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
       ],
@@ -379,8 +377,8 @@ describe('validateActivities', () => {
 
   it('ACT-018 — warns when an activity with no duration is not referenced as parent', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-1', name: 'Has duration', duration: 3 },
         { id: 'P-EMPTY', name: 'Looks like phase but no children' },
       ],
@@ -390,8 +388,8 @@ describe('validateActivities', () => {
 
   it('ACT-018 — no warning when the no-duration activity has at least one child', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'PHASE-1', name: 'Phase' },
         { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
       ],
@@ -413,26 +411,31 @@ describe('validateActivities', () => {
 
   it('ACT-019 — no warning when every activity has pinned dates', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [
+      notation: 'action',
+      actions: [
         { id: 'A-1', name: 'A', duration: 3, start_date: '2026-06-01', end_date: '2026-06-04' },
       ],
     });
     expect(r.warnings.some(w => w.code === 'ACT-019')).toBe(false);
   });
 
-  it('[blocker] tolerates a null element in activities[] without throwing', () => {
-    const r = validateActivities({ ...minimalValid, activities: [null] });
+  it('[blocker] tolerates a null element in actions[] without throwing', () => {
+    // Do NOT spread minimalValid here: validateActivities mutates its input
+    // to normalise raw.activities, so a previously-called test that passed
+    // minimalValid directly would have set minimalValid.activities. Spreading
+    // that mutated object would cause the actions:[null] override to be masked
+    // by the pre-existing activities array.
+    const r = validateActivities({ notation: 'action', actions: [null] });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
   });
 });
 
-describe('activities examples (regression)', () => {
+describe('action examples (regression)', () => {
   const files = fs.readdirSync(EXAMPLES_DIR).filter(f => f.endsWith('.yaml'));
   expect(files.length).toBeGreaterThan(0);
   for (const file of files) {
-    it(`validates tests/fixtures/notation-corpus/activities/${file}`, () => {
+    it(`validates tests/fixtures/notation-corpus/action/${file}`, () => {
       const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
       const parsed = yaml.load(text);
       const r = validateActivities(parsed);

package/src/activities/validate.ts

@@ -19,27 +19,20 @@ export function validateActivities(input: unknown): ActivityValidationResult {
 
   const raw = input as Record<string, unknown>;
 
-  // ACT-001: notation must be "action" (canonical) or "activities" (deprecated)
+  // ACT-001: notation must be "action"
   if (raw.notation === undefined) {
     errors.push({ code: 'ACT-001', message: 'notation field is required' });
     return { valid: false, errors, warnings };
   }
-  if (raw.notation !== 'action' && raw.notation !== 'activities') {
+  if (raw.notation !== 'action') {
     errors.push({ code: 'ACT-001', message: `notation must be "action", got "${String(raw.notation)}"` });
     return { valid: false, errors, warnings };
   }
-  if (raw.notation === 'activities') {
-    warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation: "activities" is deprecated — migrate to notation: "action"' });
-  }
 
-  // Accept "actions:" (canonical) or "activities:" (deprecated)
-  const rawArray = Array.isArray(raw.actions) ? raw.actions : (Array.isArray(raw.activities) ? raw.activities : undefined);
-  if (Array.isArray(raw.activities) && !Array.isArray(raw.actions)) {
-    warnings.push({ code: 'DEPRECATED_FIELD', message: 'Root key "activities:" is deprecated — rename to "actions:"' });
-  }
+  // Only "actions:" root key is accepted.
+  const rawArray = Array.isArray(raw.actions) ? raw.actions : undefined;
   if (!rawArray) {
-    const canonKey = raw.notation === 'action' ? 'actions' : 'activities';
-    errors.push({ code: 'SCHEMA_INVALID', message: `${canonKey} must be an array`, path: canonKey });
+    errors.push({ code: 'SCHEMA_INVALID', message: 'actions must be an array', path: 'actions' });
     return { valid: false, errors, warnings };
   }
   // Normalise onto raw.activities for the rest of this function (avoids touching downstream code)

package/src/activity-card/__tests__/example.test.ts

@@ -15,7 +15,7 @@ import type { ActivityCardDoc } from '../types.js';
 
 const dir = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
-  '../../../../../tests/fixtures/notation-corpus/activity-card',
+  '../../../../../tests/fixtures/notation-corpus/action-card',
 );
 const load = (f: string): unknown => yaml.load(readFileSync(path.join(dir, f), 'utf-8'));
 
@@ -33,7 +33,7 @@ function loadYamlTree(root: string): unknown[] {
 
 describe('activity-card worked example (eu-programme)', () => {
   it('validates, resolves, and lays out the success-signal card', () => {
-    const card = load('eu-programme.activity-card.transitrix.yaml');
+    const card = load('eu-programme.action-card.transitrix.yaml');
     const elements = loadYamlTree(path.join(dir, 'canon', 'elements'));
     const relations = loadYamlTree(path.join(dir, 'canon', 'relations'));
 
@@ -71,13 +71,11 @@ describe('activity-card worked example (eu-programme)', () => {
     // Description row
     expect(layout.descriptionRow?.label).toBe('Description');
     // Chain sections
-    expect(layout.chainSections.map((s) => s.type)).toEqual(['drivers', 'assessments', 'goals', 'changes']);
+    expect(layout.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
     const driversSection = layout.chainSections.find((s) => s.type === 'drivers')!;
     const goalsSection = layout.chainSections.find((s) => s.type === 'goals')!;
-    const assessmentsSection = layout.chainSections.find((s) => s.type === 'assessments')!;
     expect(driversSection.nodes.map((n) => n.id)).toContain('FACTOR-EU-MDR-1');
     expect(goalsSection.nodes.map((n) => n.id)).toContain('GOAL-EU-MARKET-1');
-    expect(assessmentsSection.isEmpty).toBe(true); // no assessment in this fixture
     // Chain edges
     expect(layout.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'GOAL-EU-MARKET-1' });
     expect(layout.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });

package/src/activity-card/__tests__/layout.test.ts

@@ -94,20 +94,17 @@ describe('layoutActivityCard', () => {
     expect(l.descriptionRow).toBeUndefined();
   });
 
-  it('four chain sections in order: drivers, assessments, goals, changes', () => {
+  it('three chain sections in order: drivers, goals, changes', () => {
     const l = layoutActivityCard(RESOLVED);
-    expect(l.chainSections.map((s) => s.type)).toEqual(['drivers', 'assessments', 'goals', 'changes']);
+    expect(l.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
   });
 
   it('chain sections carry the resolved nodes', () => {
     const l = layoutActivityCard(RESOLVED);
     const drivers = l.chainSections.find((s) => s.type === 'drivers')!;
-    const assessments = l.chainSections.find((s) => s.type === 'assessments')!;
     const goals = l.chainSections.find((s) => s.type === 'goals')!;
     const changes = l.chainSections.find((s) => s.type === 'changes')!;
     expect(drivers.nodes.map((n) => n.id)).toEqual(['FACTOR-EU-MDR-1']);
-    expect(assessments.nodes.map((n) => n.id)).toEqual(['ASSESSMENT-MDR-1']);
-    expect(assessments.nodes[0].meta).toBe('2026-03-01');
     expect(goals.nodes.map((n) => n.id)).toEqual(['GOAL-EU-MARKET-1']);
     expect(changes.nodes.map((n) => n.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
   });
@@ -127,10 +124,6 @@ describe('layoutActivityCard', () => {
     expect(l.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });
   });
 
-  it('builds driver→assessment edge when assessment is linked', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'ASSESSMENT-MDR-1' });
-  });
 
   it('milestone ArchiMate class is set', () => {
     const l = layoutActivityCard(RESOLVED);

package/src/activity-card/__tests__/resolver.test.ts

@@ -217,6 +217,33 @@ describe('resolveActivityCard', () => {
     expect(r.warnings.some((w) => w.code === 'PC-001')).toBe(true);
   });
 
+  it('resolves stakeholders from inline stakeholders: [] on the Action element', () => {
+    const projectWithInlineStakeholders = { ...PROJECT, stakeholders: ['STAKEHOLDER-OPS-1'] };
+    const r = resolveActivityCard(CARD, {
+      elements: [projectWithInlineStakeholders, CHILD, FACTOR, GOAL, CHANGE, STAKEHOLDER],
+      relations: [REL_GOAL],
+    });
+    expect(r.valid).toBe(true);
+    const sh = r.resolved!.stakeholders!;
+    expect(sh).toHaveLength(1);
+    expect(sh[0].id).toBe('STAKEHOLDER-OPS-1');
+    expect(sh[0].name).toBe('Operations');
+    expect(sh[0].role).toBeUndefined();
+  });
+
+  it('REL stakeholder takes precedence over inline duplicate (carries role)', () => {
+    const projectWithInlineStakeholders = { ...PROJECT, stakeholders: ['STAKEHOLDER-OPS-1'] };
+    const r = resolveActivityCard(CARD, {
+      elements: [projectWithInlineStakeholders, CHILD, FACTOR, GOAL, CHANGE, STAKEHOLDER],
+      relations: [REL_GOAL, REL_STAKEHOLDER],
+    });
+    expect(r.valid).toBe(true);
+    const sh = r.resolved!.stakeholders!;
+    // deduplicated — REL entry wins, inline duplicate is dropped
+    expect(sh).toHaveLength(1);
+    expect(sh[0].role).toBe('sponsor');
+  });
+
   it('falls back to the inline goals field when no activity_goal relation exists', () => {
     const projectWithInline = { ...PROJECT, goals: ['GOAL-EU-MARKET-1'] };
     const r = resolveActivityCard(CARD, {

package/src/activity-card/__tests__/validate.test.ts

@@ -2,9 +2,9 @@ import { describe, it, expect } from 'vitest';
 import { validateActivityCard } from '../validate.js';
 
 const VALID = {
-  notation: 'activity-card',
+  notation: 'action-card',
   spec_version: '0.1',
-  activity_card: {
+  action_card: {
     id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
     project: 'ACTIVITY-EU-PROGRAMME-1',
     description: 'Executive summary.',
@@ -20,11 +20,23 @@ const VALID = {
 };
 
 describe('validateActivityCard', () => {
-  it('accepts a well-formed card (deprecated notation: activity-card)', () => {
+  it('accepts a well-formed card (notation: action-card)', () => {
     const r = validateActivityCard(VALID);
     expect(r.valid).toBe(true);
     expect(r.errors).toHaveLength(0);
-    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(true);
+    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+  });
+
+  it('rejects deprecated notation: activity-card', () => {
+    const r = validateActivityCard({
+      notation: 'activity-card',
+      activity_card: {
+        id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
+        project: 'ACTIVITY-EU-PROGRAMME-1',
+      },
+    });
+    expect(r.valid).toBe(false);
+    expect(r.errors.some(e => e.code === 'HDR-002')).toBe(true);
   });
 
   it('accepts notation: action-card with action_card block (canonical)', () => {
@@ -67,21 +79,21 @@ describe('validateActivityCard', () => {
     expect(r.errors.some((e) => e.code === 'HDR-002')).toBe(true);
   });
 
-  it('AC-001 on missing activity_card block', () => {
-    const r = validateActivityCard({ notation: 'activity-card' });
+  it('AC-001 on missing action_card block', () => {
+    const r = validateActivityCard({ notation: 'action-card' });
     expect(r.valid).toBe(false);
     expect(r.errors.some((e) => e.code === 'AC-001')).toBe(true);
   });
 
   it('AC-002 on malformed card id', () => {
-    const r = validateActivityCard({ ...VALID, activity_card: { ...VALID.activity_card, id: 'CARD-1' } });
+    const r = validateActivityCard({ ...VALID, action_card: { ...VALID.action_card, id: 'CARD-1' } });
     expect(r.errors.some((e) => e.code === 'AC-002')).toBe(true);
   });
 
   it('PC-001 on missing project', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: { ...VALID.activity_card, project: undefined },
+      action_card: { ...VALID.action_card, project: undefined },
     });
     expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
   });
@@ -89,7 +101,7 @@ describe('validateActivityCard', () => {
   it('PC-001 on malformed project id', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: { ...VALID.activity_card, project: 'GOAL-1' },
+      action_card: { ...VALID.action_card, project: 'GOAL-1' },
     });
     expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
   });
@@ -97,7 +109,7 @@ describe('validateActivityCard', () => {
   it('AC-003 on milestone missing required fields', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: { ...VALID.activity_card, milestones: [{ id: 'MILESTONE-X-1' }] },
+      action_card: { ...VALID.action_card, milestones: [{ id: 'MILESTONE-X-1' }] },
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some((e) => e.code === 'AC-003')).toBe(true);
@@ -106,8 +118,8 @@ describe('validateActivityCard', () => {
   it('AC-004 on malformed milestone id', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: {
-        ...VALID.activity_card,
+      action_card: {
+        ...VALID.action_card,
         milestones: [{ id: 'MS-1', name: 'x', date: '2027-01-01' }],
       },
     });
@@ -118,7 +130,7 @@ describe('validateActivityCard', () => {
     const m = { id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01' };
     const r = validateActivityCard({
       ...VALID,
-      activity_card: { ...VALID.activity_card, milestones: [m, { ...m }] },
+      action_card: { ...VALID.action_card, milestones: [m, { ...m }] },
     });
     expect(r.errors.some((e) => e.code === 'AC-004' && /Duplicate/.test(e.message))).toBe(true);
   });
@@ -126,8 +138,8 @@ describe('validateActivityCard', () => {
   it('AC-005 on bad milestone date format', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: {
-        ...VALID.activity_card,
+      action_card: {
+        ...VALID.action_card,
         milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '31/01/2027' }],
       },
     });
@@ -137,8 +149,8 @@ describe('validateActivityCard', () => {
   it('AC-006 on malformed delivers_changes entry', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: {
-        ...VALID.activity_card,
+      action_card: {
+        ...VALID.action_card,
         milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01', delivers_changes: ['GOAL-1'] }],
       },
     });
@@ -148,7 +160,7 @@ describe('validateActivityCard', () => {
   it('accepts a card with no milestones', () => {
     const r = validateActivityCard({
       ...VALID,
-      activity_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
+      action_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
     });
     expect(r.valid).toBe(true);
   });