@transitrix/diagrams 1.1.0 → 1.2.0

package/dist/fgca/validate.js

@@ -22,10 +22,18 @@ export function validateFGCADoc(input) {
         errors.push({ code: 'SCHEMA_INVALID', message: 'goals must be an array', path: 'goals' });
     if (!Array.isArray(raw.changes))
         errors.push({ code: 'SCHEMA_INVALID', message: 'changes must be an array', path: 'changes' });
-    if (!Array.isArray(raw.activities))
-        errors.push({ code: 'SCHEMA_INVALID', message: 'activities must be an array', path: 'activities' });
+    // Accept canonical `actions:` or deprecated `activities:`; warn on the latter.
+    const hasActions = Array.isArray(raw.actions);
+    const hasActivities = Array.isArray(raw.activities);
+    if (!hasActions && !hasActivities) {
+        errors.push({ code: 'SCHEMA_INVALID', message: 'actions must be an array', path: 'actions' });
+    }
+    else if ('activities' in raw) {
+        warnings.push({ code: 'DEPRECATED_NOTATION', message: '"activities" key is deprecated — rename to "actions"' });
+    }
     if (errors.length > 0)
         return { valid: false, errors, warnings };
+    const actionsArr = (hasActions ? raw.actions : raw.activities);
     const doc = raw;
     const collectIds = (arr) => {
         const out = new Set();
@@ -40,7 +48,7 @@ export function validateFGCADoc(input) {
     };
     const factorIds = collectIds(doc.factors);
     const goalIds = collectIds(doc.goals);
-    const activityIds = collectIds(doc.activities);
+    const activityIds = collectIds(actionsArr);
     for (let i = 0; i < doc.factors.length; i++) {
         const f = doc.factors[i];
         if (!f || typeof f !== 'object') {
@@ -95,17 +103,17 @@ export function validateFGCADoc(input) {
             }
         }
     }
-    for (let i = 0; i < doc.activities.length; i++) {
-        const a = doc.activities[i];
+    for (let i = 0; i < actionsArr.length; i++) {
+        const a = actionsArr[i];
         if (!a || typeof a !== 'object') {
-            errors.push({ code: 'SCHEMA_INVALID', message: 'activity entry must be an object', path: `activities[${i}]` });
+            errors.push({ code: 'SCHEMA_INVALID', message: 'action entry must be an object', path: `actions[${i}]` });
             continue;
         }
-        const activity = a;
-        if (typeof activity.id !== 'number' && typeof activity.id !== 'string')
-            errors.push({ code: 'SCHEMA_INVALID', message: 'activity id must be a number or string', path: `activities[${i}]` });
-        if (typeof activity.name !== 'string' || !activity.name.trim())
-            errors.push({ code: 'EMPTY_NAME', message: `Activity ${String(activity.id)} has empty name`, path: `activities[${i}]` });
+        const action = a;
+        if (typeof action.id !== 'number' && typeof action.id !== 'string')
+            errors.push({ code: 'SCHEMA_INVALID', message: 'action id must be a number or string', path: `actions[${i}]` });
+        if (typeof action.name !== 'string' || !action.name.trim())
+            errors.push({ code: 'EMPTY_NAME', message: `Action ${String(action.id)} has empty name`, path: `actions[${i}]` });
     }
     return { valid: errors.length === 0, errors, warnings };
 }

package/dist/theme/index.d.ts

@@ -1,4 +1,4 @@
 export type { AdaptiveTokens } from './tokens.js';
-export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
+export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, TREE_LEVEL_COLORS, TREE_MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
 export type { ThemeId } from './themes.js';
 export { generateWebviewCss, generateSvgEmbedCss } from './themes.js';

package/dist/theme/index.js

@@ -1,2 +1,2 @@
-export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
+export { BRAND, FUNCTIONAL, LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, TREE_LEVEL_COLORS, TREE_MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss } from './tokens.js';
 export { generateWebviewCss, generateSvgEmbedCss } from './themes.js';

package/dist/theme/themes.js

@@ -1,4 +1,4 @@
-import { LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss, } from './tokens.js';
+import { LAYER_COLORS, LEVEL_COLORS, MATURITY_COLORS, TREE_LEVEL_COLORS, TREE_MATURITY_COLORS, STRUCTURAL, TYPOGRAPHY, CSS_VAR, getBaseResetCss, } from './tokens.js';
 const TRANSITRIX_LIGHT = {
     bg: '#ffffff',
     bgSurface: '#f8fafc',
@@ -60,7 +60,19 @@ function diagramVars(variant) {
     const sc = STRUCTURAL;
     const lv = LEVEL_COLORS[variant];
     const mat = MATURITY_COLORS[variant];
+    const treeLevel = TREE_LEVEL_COLORS;
+    const treeMat = TREE_MATURITY_COLORS[variant];
     const levelVars = lv.map((c, i) => `--ts-level-${i}:${c}`).join(';') + ';';
+    const treeVars = [
+        `${CSS_VAR.treeLevel0}:${treeLevel.band0[variant]}`,
+        `${CSS_VAR.treeLevel1}:${treeLevel.band1[variant]}`,
+        `${CSS_VAR.treeLevel2}:${treeLevel.band2[variant]}`,
+        `${CSS_VAR.treeMaturity1}:${treeMat[0]}`,
+        `${CSS_VAR.treeMaturity2}:${treeMat[1]}`,
+        `${CSS_VAR.treeMaturity3}:${treeMat[2]}`,
+        `${CSS_VAR.treeMaturity4}:${treeMat[3]}`,
+        `${CSS_VAR.treeMaturity5}:${treeMat[4]}`,
+    ].join(';') + ';';
     return [
         `${CSS_VAR.layerDriver}:${lc.driver[variant]}`,
         `${CSS_VAR.layerFactor}:${lc.factor[variant]}`,
@@ -77,7 +89,7 @@ function diagramVars(variant) {
         `${CSS_VAR.maturity3}:${mat[2]}`,
         `${CSS_VAR.maturity4}:${mat[3]}`,
         `${CSS_VAR.maturity5}:${mat[4]}`,
-    ].join(';') + ';' + levelVars;
+    ].join(';') + ';' + levelVars + treeVars;
 }
 /** CSS for the webview shell (toolbar, canvas). */
 function shellCss() {
@@ -136,7 +148,18 @@ ${levelRules}
 .compliance-deadline{fill:var(${cv.statusErrorBg});stroke:var(${cv.statusErrorFg});}
 .compliance-deadline text{fill:var(${cv.statusErrorFg});}
 .compliance-badge{fill:var(${cv.statusErrorFg});}
-.compliance-badge-text{fill:var(${cv.textInverse});font-family:${t.fontFamily};font-size:8px;font-weight:700;}`;
+.compliance-badge-text{fill:var(${cv.textInverse});font-family:${t.fontFamily};font-size:8px;font-weight:700;}
+.tree-level-0{fill:var(${cv.treeLevel0});}
+.tree-level-1{fill:var(${cv.treeLevel1});}
+.tree-level-2{fill:var(${cv.treeLevel2});}
+.tree-maturity-1{fill:var(${cv.treeMaturity1});}
+.tree-maturity-2{fill:var(${cv.treeMaturity2});}
+.tree-maturity-3{fill:var(${cv.treeMaturity3});}
+.tree-maturity-4{fill:var(${cv.treeMaturity4});}
+.tree-maturity-5{fill:var(${cv.treeMaturity5});}
+.tree-collapse-btn{cursor:pointer;fill:white;stroke:var(${cv.nodeStroke});stroke-width:1.5;}
+.tree-collapse-btn:hover{fill:var(${cv.bgElevated});}
+.tree-collapse-lbl{fill:var(${cv.textSecondary});font-family:${t.fontFamily};font-size:12px;font-weight:700;dominant-baseline:central;pointer-events:none;}`;
 }
 /**
  * Generates a self-contained CSS block for embedding inside a standalone SVG file.

package/dist/theme/tokens.d.ts

@@ -82,6 +82,38 @@ export declare const MATURITY_COLORS: {
     readonly dark: readonly ["#7f1d1d", "#92400e", "#854d0e", "#3f6212", "#14532d"];
     readonly hc: readonly ["#f87171", "#fb923c", "#facc15", "#a3e635", "#4ade80"];
 };
+/**
+ * DSM-matching capability tree node fill colors, grouped by depth band.
+ *   band0: depth 0–2 (pink)
+ *   band1: depth 3–4 (yellow)
+ *   band2: depth 5+  (blue)
+ */
+export declare const TREE_LEVEL_COLORS: {
+    readonly band0: {
+        readonly light: "#fee0e0";
+        readonly dark: "#3d0f0f";
+        readonly hc: "#ff9999";
+    };
+    readonly band1: {
+        readonly light: "#ffffcb";
+        readonly dark: "#3a3500";
+        readonly hc: "#ffff88";
+    };
+    readonly band2: {
+        readonly light: "#c2f0ff";
+        readonly dark: "#003d4d";
+        readonly hc: "#66ccff";
+    };
+};
+/**
+ * DSM-matching maturity badge fills for the capability tree (L1–L5).
+ * Distinct from MATURITY_COLORS which drives the cards / compliance views.
+ */
+export declare const TREE_MATURITY_COLORS: {
+    readonly light: readonly ["#c1c1c1", "#ff3d67", "#ff9a59", "#fdef59", "#83cca3"];
+    readonly dark: readonly ["#555555", "#cc1040", "#d06020", "#c8c000", "#4d9970"];
+    readonly hc: readonly ["#cccccc", "#ff6699", "#ffbb77", "#ffff44", "#88ddaa"];
+};
 /**
  * Typography hierarchy. All previews resolve text styling from these roles
  * — never from inline font-* attributes on individual <text> elements.
@@ -160,5 +192,13 @@ export declare const CSS_VAR: {
     readonly maturity3: "--ts-maturity-3";
     readonly maturity4: "--ts-maturity-4";
     readonly maturity5: "--ts-maturity-5";
+    readonly treeLevel0: "--ts-tree-level-0";
+    readonly treeLevel1: "--ts-tree-level-1";
+    readonly treeLevel2: "--ts-tree-level-2";
+    readonly treeMaturity1: "--ts-tree-maturity-1";
+    readonly treeMaturity2: "--ts-tree-maturity-2";
+    readonly treeMaturity3: "--ts-tree-maturity-3";
+    readonly treeMaturity4: "--ts-tree-maturity-4";
+    readonly treeMaturity5: "--ts-tree-maturity-5";
 };
 export declare function getBaseResetCss(): string;

package/dist/theme/tokens.js

@@ -42,6 +42,26 @@ export const MATURITY_COLORS = {
     dark: ['#7f1d1d', '#92400e', '#854d0e', '#3f6212', '#14532d'],
     hc: ['#f87171', '#fb923c', '#facc15', '#a3e635', '#4ade80'],
 };
+/**
+ * DSM-matching capability tree node fill colors, grouped by depth band.
+ *   band0: depth 0–2 (pink)
+ *   band1: depth 3–4 (yellow)
+ *   band2: depth 5+  (blue)
+ */
+export const TREE_LEVEL_COLORS = {
+    band0: { light: '#fee0e0', dark: '#3d0f0f', hc: '#ff9999' },
+    band1: { light: '#ffffcb', dark: '#3a3500', hc: '#ffff88' },
+    band2: { light: '#c2f0ff', dark: '#003d4d', hc: '#66ccff' },
+};
+/**
+ * DSM-matching maturity badge fills for the capability tree (L1–L5).
+ * Distinct from MATURITY_COLORS which drives the cards / compliance views.
+ */
+export const TREE_MATURITY_COLORS = {
+    light: ['#c1c1c1', '#ff3d67', '#ff9a59', '#fdef59', '#83cca3'],
+    dark: ['#555555', '#cc1040', '#d06020', '#c8c000', '#4d9970'],
+    hc: ['#cccccc', '#ff6699', '#ffbb77', '#ffff44', '#88ddaa'],
+};
 /**
  * Typography hierarchy. All previews resolve text styling from these roles
  * — never from inline font-* attributes on individual <text> elements.
@@ -101,6 +121,14 @@ export const CSS_VAR = {
     maturity3: '--ts-maturity-3',
     maturity4: '--ts-maturity-4',
     maturity5: '--ts-maturity-5',
+    treeLevel0: '--ts-tree-level-0',
+    treeLevel1: '--ts-tree-level-1',
+    treeLevel2: '--ts-tree-level-2',
+    treeMaturity1: '--ts-tree-maturity-1',
+    treeMaturity2: '--ts-tree-maturity-2',
+    treeMaturity3: '--ts-tree-maturity-3',
+    treeMaturity4: '--ts-tree-maturity-4',
+    treeMaturity5: '--ts-tree-maturity-5',
 };
 export function getBaseResetCss() {
     return `*,*:before,*:after{box-sizing:border-box;}html,body{margin:0;padding:0;}`;

package/dist/webview/render-fgca.js

@@ -20,7 +20,7 @@ const COL_LABELS = {
     driver: 'Drivers (D)',
     goal: 'Goals (G)',
     change: 'Changes (C)',
-    activity: 'Activities (A)',
+    activity: 'Actions (A)',
 };
 /**
  * Canonical FGCA/FGA body — the column headers, node rects and edge paths that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transitrix/diagrams",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "Shared rendering, validation, and pure mutations for Transitrix custom diagram formats.",
   "license": "MIT",

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

@@ -15,9 +15,43 @@ const minimalValid = {
 };
 
 describe('validateActivities', () => {
-  it('ACT-001 — accepts valid notation field', () => {
+  it('ACT-001 — accepts notation: activities (deprecated)', () => {
     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);
+  });
+
+  it('ACT-001 — accepts notation: action (canonical)', () => {
+    const r = validateActivities({
+      notation: 'action',
+      actions: [
+        { id: 'ACTION-001', name: 'Start', duration: 3 },
+        { id: 'ACTION-002', name: 'End', duration: 2, predecessors: ['ACTION-001'] },
+      ],
+    });
+    expect(r.valid).toBe(true);
+    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+  });
+
+  it('ACT-001 — accepts notation: action with deprecated activities: key (emits field warning)', () => {
+    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);
+  });
+
+  it('ACT-001 — normalises action_type to activity_type for downstream layout', () => {
+    const input: Record<string, unknown> = {
+      notation: 'action',
+      actions: [{ id: 'ACTION-001', name: 'Foo', duration: 1, action_type: 'project' }],
+    };
+    const r = validateActivities(input);
+    expect(r.valid).toBe(true);
+    const entry = (input.actions as Array<Record<string, unknown>>)[0];
+    expect(entry['activity_type']).toBe('project');
   });
 
   it('ACT-001 — rejects missing notation', () => {

package/src/activities/validate.ts

@@ -19,20 +19,31 @@ export function validateActivities(input: unknown): ActivityValidationResult {
 
   const raw = input as Record<string, unknown>;
 
-  // ACT-001: notation must equal "activities"
+  // ACT-001: notation must be "action" (canonical) or "activities" (deprecated)
   if (raw.notation === undefined) {
     errors.push({ code: 'ACT-001', message: 'notation field is required' });
     return { valid: false, errors, warnings };
   }
-  if (raw.notation !== 'activities') {
-    errors.push({ code: 'ACT-001', message: `notation must be "activities", got "${String(raw.notation)}"` });
+  if (raw.notation !== 'action' && raw.notation !== 'activities') {
+    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"' });
+  }
 
-  if (!Array.isArray(raw.activities)) {
-    errors.push({ code: 'SCHEMA_INVALID', message: 'activities must be an array', path: 'activities' });
+  // 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:"' });
+  }
+  if (!rawArray) {
+    const canonKey = raw.notation === 'action' ? 'actions' : 'activities';
+    errors.push({ code: 'SCHEMA_INVALID', message: `${canonKey} must be an array`, path: canonKey });
     return { valid: false, errors, warnings };
   }
+  // Normalise onto raw.activities for the rest of this function (avoids touching downstream code)
+  if (!Array.isArray(raw.activities)) raw.activities = raw.actions;
 
   // ACT-014 / ACT-015: project.calendar validation (run before per-activity loop;
   // surfaces clearly even when activities also have issues).
@@ -99,6 +110,11 @@ export function validateActivities(input: unknown): ActivityValidationResult {
     }
     const act = a as Record<string, unknown>;
 
+    // Normalise action_type → activity_type (canonical rename; old name kept for compat)
+    if (act['action_type'] !== undefined && act['activity_type'] === undefined) {
+      act['activity_type'] = act['action_type'];
+    }
+
     // ACT-010: reject single-value forms
     if ('goal' in act) {
       errors.push({ code: 'ACT-010', message: `Use "goals: []" array form instead of "goal:" (activity at index ${i})`, path });

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

@@ -241,7 +241,7 @@ describe('resolveActivityCard', () => {
     expect(pc001!.message).toContain('canon/elements/**');
     expect(pc001!.message).toContain('canon/views/activities/**');
     // Must include actionable hint with expected file pattern (§7 PC-001)
-    expect(pc001!.message).toContain('notation: activity');
+    expect(pc001!.message).toContain('notation: action');
     expect(pc001!.message).toContain(`id: "${CARD.activity_card.project}"`);
   });
 

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

@@ -20,10 +20,34 @@ const VALID = {
 };
 
 describe('validateActivityCard', () => {
-  it('accepts a well-formed card', () => {
+  it('accepts a well-formed card (deprecated notation: activity-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);
+  });
+
+  it('accepts notation: action-card with action_card block (canonical)', () => {
+    const r = validateActivityCard({
+      notation: 'action-card',
+      action_card: {
+        id: 'ACTION_CARD-EU-PROGRAMME-1',
+        project: 'ACTION-EU-PROGRAMME-1',
+      },
+    });
+    expect(r.valid).toBe(true);
+    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+  });
+
+  it('accepts action_card block with legacy ACTIVITY_CARD id prefix', () => {
+    const r = validateActivityCard({
+      notation: 'action-card',
+      action_card: {
+        id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
+        project: 'ACTION-EU-PROGRAMME-1',
+      },
+    });
+    expect(r.valid).toBe(true);
   });
 
   it('rejects non-object input', () => {

package/src/activity-card/resolver.ts

@@ -104,16 +104,17 @@ function collectByNotation(
 }
 
 /**
- * GOAL ids reached by an *active* `activity_goal` relation originating at
- * `fromId`. A relation with a non-null `valid_to` has ended (the activity was
- * re-aimed) and is excluded — the card shows the currently-served goals.
+ * GOAL ids reached by an *active* `action_goal` (or legacy `activity_goal`)
+ * relation originating at `fromId`. A relation with a non-null `valid_to` has
+ * ended (the activity was re-aimed) and is excluded.
  */
 function activeActivityGoals(relations: unknown[], fromId: string): string[] {
   const out: string[] = [];
   for (const doc of relations) {
     if (!isObject(doc)) continue;
     if (str(doc['notation']) !== 'relation') continue;
-    if (str(doc['type']) !== 'activity_goal') continue;
+    const type = str(doc['type']);
+    if (type !== 'action_goal' && type !== 'activity_goal') continue;
     if (str(doc['from']) !== fromId) continue;
     const to = str(doc['to']);
     if (!to) continue;
@@ -125,11 +126,8 @@ function activeActivityGoals(relations: unknown[], fromId: string): string[] {
 }
 
 /**
- * STAKEHOLDER ids + roles reached by an *active* `activity_stakeholder`
- * relation originating at `fromId`. A relation with a non-null `valid_to` has
- * ended and is excluded, so the card shows the project's currently-engaged
- * stakeholders. The optional `role` field on the relation carries the
- * project-role (initiator | owner | sponsor | project_manager).
+ * STAKEHOLDER ids + roles reached by an *active* `action_stakeholder` (or
+ * legacy `activity_stakeholder`) relation originating at `fromId`.
  */
 function activeActivityStakeholders(
   relations: unknown[],
@@ -139,7 +137,8 @@ function activeActivityStakeholders(
   for (const doc of relations) {
     if (!isObject(doc)) continue;
     if (str(doc['notation']) !== 'relation') continue;
-    if (str(doc['type']) !== 'activity_stakeholder') continue;
+    const type = str(doc['type']);
+    if (type !== 'action_stakeholder' && type !== 'activity_stakeholder') continue;
     if (str(doc['from']) !== fromId) continue;
     const to = str(doc['to']);
     if (!to) continue;
@@ -165,20 +164,22 @@ export function resolveActivityCard(
     return { valid: false, errors, warnings };
   }
 
-  const activities = collectByNotation(sources.elements, 'activity');
-  const projectRec = activities.get(projectId);
+  // Look up by canonical `notation: action` first, then legacy `notation: activity`.
+  const actionElements = collectByNotation(sources.elements, 'action');
+  const activityElements = collectByNotation(sources.elements, 'activity');
+  const allActionElements = new Map([...activityElements, ...actionElements]); // action wins on duplicate id
+  const projectRec = allActionElements.get(projectId);
 
-  // PC-001 — project must resolve to an admitted ACTIVITY element after
-  // exhausting the canonical resolution scope (§6.1): canon/elements/**
-  // recursively first, then canon/views/activities/** as secondary fallback.
+  // PC-001 — project must resolve to an admitted ACTION (or legacy ACTIVITY)
+  // element after exhausting the canonical resolution scope (§6.1).
   if (!projectRec) {
     errors.push({
       code: 'PC-001',
       message:
-        `activity_card.project "${projectId}" not found after searching ` +
+        `action_card.project "${projectId}" not found after searching ` +
         `canon/elements/** and canon/views/activities/** — ` +
-        `add a YAML file with notation: activity and id: "${projectId}" ` +
-        `(e.g. canon/elements/05_implementation/activities/${projectId}.yaml)`,
+        `add a YAML file with notation: action and id: "${projectId}" ` +
+        `(e.g. canon/elements/05_implementation/actions/${projectId}.yaml)`,
     });
     return { valid: false, errors, warnings };
   }
@@ -349,13 +350,14 @@ export function resolveActivityCard(
   });
 
   // ── Child activities — parent = project id ──────────────────────────────────
+  // Look in both `notation: action` and legacy `notation: activity` elements.
   const childActivities: ResolvedChildActivity[] = [];
-  for (const [id, rec] of activities) {
+  for (const [id, rec] of allActionElements) {
     if (str(rec['parent']) !== projectId) continue;
     childActivities.push({
       id,
       name: str(rec['name']) ?? id,
-      activity_type: str(rec['activity_type']),
+      activity_type: str(rec['action_type']) ?? str(rec['activity_type']),
       start_date: str(rec['start_date']),
       end_date: str(rec['end_date']),
       owner: str(rec['owner']),
@@ -401,7 +403,7 @@ export function resolveActivityCard(
     valid_to: validToOk ? (validToRaw as string) : undefined,
     start_date: str(projectRec['start_date']),
     end_date: str(projectRec['end_date']),
-    activity_type: str(projectRec['activity_type']),
+    activity_type: str(projectRec['action_type']) ?? str(projectRec['activity_type']),
     status: str(projectRec['status']),
   };
 

package/src/activity-card/validate.ts

@@ -26,8 +26,8 @@ import type { ValidationError, ValidationWarning, ValidationResult } from '../va
 
 export type { ValidationError, ValidationWarning, ValidationResult };
 
-const ACTIVITY_CARD_ID_RE = /^ACTIVITY_CARD(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
-const ACTIVITY_ID_RE = /^ACTIVITY(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const ACTIVITY_CARD_ID_RE = /^(ACTIVITY_CARD|ACTION_CARD)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const ACTIVITY_ID_RE = /^(ACTIVITY|ACTION)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const MILESTONE_ID_RE = /^MILESTONE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CHANGE_ID_RE = /^CHANGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -49,37 +49,46 @@ 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'] !== 'activity-card') {
+  } else if (raw['notation'] !== 'action-card' && raw['notation'] !== 'activity-card') {
     errors.push({
       code: 'HDR-002',
-      message: `notation must be "activity-card", got "${String(raw['notation'])}"`,
+      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"' });
   }
 
-  // ── activity_card block ─────────────────────────────────────────────────────
-  const block = raw['activity_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:"' });
+  }
+  const block = rawBlock;
   if (!block || typeof block !== 'object' || Array.isArray(block)) {
-    errors.push({ code: 'AC-001', message: 'Missing required root key: activity_card (object)' });
+    errors.push({ code: 'AC-001', message: 'Missing required root key: action_card (object)' });
     return { valid: false, errors, warnings };
   }
+  // Normalise onto activity_card for downstream (resolver reads doc.activity_card)
+  if (raw['activity_card'] === undefined) raw['activity_card'] = rawBlock;
   const card = block as Record<string, unknown>;
 
   if (!isNonEmptyString(card['id'])) {
-    errors.push({ code: 'AC-002', message: 'activity_card.id is required' });
+    errors.push({ code: 'AC-002', message: 'action_card.id is required' });
   } else if (!ACTIVITY_CARD_ID_RE.test(card['id'])) {
     errors.push({
       code: 'AC-002',
-      message: `activity_card.id "${card['id']}" must match ACTIVITY_CARD-[<middle>-]<INTEGER>`,
+      message: `action_card.id "${card['id']}" must match ACTION_CARD-[<middle>-]<INTEGER> (or legacy ACTIVITY_CARD-…)`,
     });
   }
 
   // PC-001 (document-local half): project present + well-formed.
   if (!isNonEmptyString(card['project'])) {
-    errors.push({ code: 'PC-001', message: 'activity_card.project is required (an ACTIVITY-… id)' });
+    errors.push({ code: 'PC-001', message: 'action_card.project is required (an ACTION-… id)' });
   } else if (!ACTIVITY_ID_RE.test(card['project'])) {
     errors.push({
       code: 'PC-001',
-      message: `activity_card.project "${card['project']}" is malformed; must match ACTIVITY-[<middle>-]<INTEGER>`,
+      message: `action_card.project "${card['project']}" is malformed; must match ACTION-[<middle>-]<INTEGER> (or legacy ACTIVITY-…)`,
     });
   }
 

package/src/capability-map/index.ts

@@ -6,3 +6,14 @@ export type {
 } from './types.js';
 
 export { validateCapabilityMap } from './validate.js';
+
+export type {
+  CapabilityTreeNode,
+  CapabilityTreeEdge,
+  CapabilityTreeLevelCounts,
+  CapabilityTreeLayout,
+} from './layout-tree.js';
+export { layoutCapabilityTree, TREE_NODE_WIDTH, TREE_NODE_HEIGHT, TREE_RANK_SEP, TREE_NODE_SEP } from './layout-tree.js';
+
+export type { RenderCapabilityTreeOptions } from './render-capability-tree.js';
+export { renderCapabilityTreeSvg } from './render-capability-tree.js';