@transitrix/diagrams 1.0.0 → 1.1.0

package/dist/activity-card/layout.d.ts

@@ -1,5 +1,5 @@
 import type { ActivityCardLayout, ActivityCardLayoutOptions, ResolvedActivityCard } from './types.js';
-/** ArchiMate class per §5.1 — derived from element TYPE, never stored. */
+/** §5.1 ArchiMate class — derived from element TYPE, never stored. */
 export declare const ARCHIMATE_CLASS: {
     readonly ACTIVITY: "Work Package";
     readonly MILESTONE: "Implementation Event";

package/dist/activity-card/layout.js

@@ -1,138 +1,244 @@
 // Activity Card — single-page layout (pure geometry; the preview paints SVG).
 //
-// Top-to-bottom card sections (spec §4 / §5):
-//   1. Title         — project name
-//   2. Dates band    — Initiation (valid_from) · Planned start · Planned end
-//   3. Milestones    — narrative timeline, markers left→right by date
-//   4. Motivation    — Factors → Goals → Changes columns with F→G→C edges
-//   5. Child activities — activities whose parent = the project
+// Card structure (top to bottom):
+//   Header  — title row (name + type badge + status badge)
+//             dates row (Initiation · Planned start · Planned end)
+//             roles row (Initiator · Owner · Sponsor · PM)
+//   Body    — description (optional)
+//             chain: Drivers → Assessments → Goals → Changes (vertical)
+//             milestones
+//             child activities
+//   Footer  — notes (optional)
 //
-// The §5.1 ArchiMate-class convention ("(Work Package)", "(Implementation
-// Event)") is applied HERE, derived from element TYPE — there is no
-// archimate_class data field.
+// The §5.1 ArchiMate-class convention is applied here, derived from element
+// TYPE — there is no archimate_class data field.
 const DEFAULTS = {
     cardWidth: 780,
-    columnGap: 28,
-    rowGap: 12,
+    rowGap: 10,
 };
-// Fixed metrics (px). Kept local — the card has no user-tunable spacing yet.
+// Fixed metrics (px).
 const PAD = 20;
-const TITLE_H = 38;
-const DATES_H = 56;
-const SECTION_HEADER_H = 26;
+const TITLE_H = 44;
+const BADGE_H = 22;
+const BADGE_HPAD = 12;
+const BADGE_GAP = 8;
+const DATES_H = 62;
+const ROLES_H = 58;
+const CELL_GAP = 12;
 const SECTION_GAP = 16;
+const CONNECTOR_H = 20;
+const CHAIN_HEADER_H = 24;
+const CHAIN_NODE_H = 48;
+const CHAIN_GAP_H = 32;
+const CHAIN_INNER_PAD = 12;
 const MILESTONE_W = 168;
-const MILESTONE_H = 64;
+const MILESTONE_H = 72;
 const MILESTONE_GAP = 16;
-const CHAIN_NODE_H = 46;
 const CHILD_ROW_H = 42;
-/** ArchiMate class per §5.1 — derived from element TYPE, never stored. */
+const INFO_LINE_H = 18;
+const INFO_ROW_BASE_H = 50;
+const INFO_CHAR_W = 7;
+/** §5.1 ArchiMate class — derived from element TYPE, never stored. */
 export const ARCHIMATE_CLASS = {
     ACTIVITY: 'Work Package',
     MILESTONE: 'Implementation Event',
 };
+function wrapText(text, maxChars, maxLines) {
+    const trimmed = (text ?? '').trim();
+    if (trimmed.length === 0)
+        return [];
+    const budget = Math.max(1, maxChars);
+    const words = trimmed.split(/\s+/);
+    const lines = [];
+    let cur = '';
+    const flush = () => {
+        if (cur.length > 0) {
+            lines.push(cur);
+            cur = '';
+        }
+    };
+    for (const word of words) {
+        if (word.length > budget) {
+            flush();
+            let rest = word;
+            while (rest.length > budget) {
+                lines.push(rest.slice(0, budget));
+                rest = rest.slice(budget);
+            }
+            cur = rest;
+            continue;
+        }
+        const candidate = cur.length > 0 ? `${cur} ${word}` : word;
+        if (candidate.length > budget) {
+            flush();
+            cur = word;
+        }
+        else {
+            cur = candidate;
+        }
+    }
+    flush();
+    if (lines.length > maxLines) {
+        const capped = lines.slice(0, maxLines);
+        const last = capped[maxLines - 1];
+        const clipped = last.length > budget - 1 ? last.slice(0, budget - 1) : last;
+        capped[maxLines - 1] = `${clipped.replace(/…$/, '')}…`;
+        return capped;
+    }
+    return lines;
+}
+function formatBadgeLabel(raw) {
+    return raw.replace(/_/g, ' ');
+}
+function badgeWidth(label) {
+    return Math.max(56, label.length * 7 + BADGE_HPAD * 2);
+}
 export function layoutActivityCard(card, options) {
     const opts = { ...DEFAULTS, ...(options ?? {}) };
     const contentX = PAD;
     const contentW = opts.cardWidth - PAD * 2;
+    const maxChars = Math.max(8, Math.floor(contentW / INFO_CHAR_W));
     let cursorY = PAD;
-    // 1. Title
-    const title = { name: card.project.name, x: contentX, y: cursorY + TITLE_H / 2 };
+    // ── 1. Title row — name + type badge + status badge ──────────────────────
+    const titleRow = { name: card.project.name, x: contentX, y: cursorY + TITLE_H / 2 };
+    let badgeRightX = contentX + contentW;
+    let statusBadge;
+    let activityTypeBadge;
+    if (card.project.status) {
+        const label = formatBadgeLabel(card.project.status);
+        const w = badgeWidth(label);
+        badgeRightX -= w;
+        statusBadge = { label, x: badgeRightX, y: cursorY + (TITLE_H - BADGE_H) / 2, width: w, height: BADGE_H };
+        badgeRightX -= BADGE_GAP;
+    }
+    if (card.project.activity_type) {
+        const label = formatBadgeLabel(card.project.activity_type);
+        const w = badgeWidth(label);
+        badgeRightX -= w;
+        activityTypeBadge = { label, x: badgeRightX, y: cursorY + (TITLE_H - BADGE_H) / 2, width: w, height: BADGE_H };
+    }
     cursorY += TITLE_H;
-    // 2. Dates band — three equal cells.
+    // ── 2. Dates row ─────────────────────────────────────────────────────────
     const dateDefs = [
         { label: 'Initiation', value: card.project.valid_from ?? '—' },
         { label: 'Planned start', value: card.project.start_date ?? '—' },
         { label: 'Planned end', value: card.project.end_date ?? '—' },
     ];
-    const dateGap = 12;
-    const dateCellW = (contentW - dateGap * (dateDefs.length - 1)) / dateDefs.length;
+    const dateCellW = (contentW - CELL_GAP * (dateDefs.length - 1)) / dateDefs.length;
     const dateFields = dateDefs.map((d, i) => ({
-        label: d.label,
-        value: d.value,
-        x: contentX + i * (dateCellW + dateGap),
-        y: cursorY,
-        width: dateCellW,
-        height: DATES_H,
+        label: d.label, value: d.value,
+        x: contentX + i * (dateCellW + CELL_GAP), y: cursorY,
+        width: dateCellW, height: DATES_H,
     }));
-    cursorY += DATES_H + SECTION_GAP;
-    const sectionHeaders = [];
-    const pushHeader = (label) => {
-        sectionHeaders.push({ label, x: contentX, y: cursorY, width: contentW, height: SECTION_HEADER_H });
-        cursorY += SECTION_HEADER_H + 8;
-    };
-    // 3. Milestones — timeline markers, wrapped left→right.
+    cursorY += DATES_H + CELL_GAP;
+    // ── 3. Stakeholder role slots — 2-column grid ────────────────────────────
+    const ROLE_DEFS = [
+        { role: 'initiator', label: 'Initiator' },
+        { role: 'owner', label: 'Owner' },
+        { role: 'sponsor', label: 'Sponsor' },
+        { role: 'project_manager', label: 'PM' },
+    ];
+    const ROLE_COLS = 2;
+    const roleSlotW = (contentW - CELL_GAP * (ROLE_COLS - 1)) / ROLE_COLS;
+    const stakeholderRoleSlots = ROLE_DEFS.map(({ role, label }, i) => {
+        const col = i % ROLE_COLS;
+        const row = Math.floor(i / ROLE_COLS);
+        const match = (card.stakeholders ?? []).find((s) => s.role === role);
+        return {
+            role: label,
+            name: match?.name ?? '—',
+            x: contentX + col * (roleSlotW + CELL_GAP),
+            y: cursorY + row * (ROLES_H + CELL_GAP),
+            width: roleSlotW, height: ROLES_H,
+        };
+    });
+    const roleRows = Math.ceil(ROLE_DEFS.length / ROLE_COLS);
+    cursorY += roleRows * (ROLES_H + CELL_GAP) - CELL_GAP + SECTION_GAP;
+    // ── 4. Description row (optional) ────────────────────────────────────────
+    let descriptionRow;
+    const description = (card.cardDescription ?? '').trim();
+    if (description.length > 0) {
+        const valueLines = wrapText(description, maxChars, 5);
+        const lines = valueLines.length > 0 ? valueLines : ['—'];
+        const height = INFO_ROW_BASE_H + lines.length * INFO_LINE_H;
+        descriptionRow = { label: 'Description', valueLines: lines, x: contentX, y: cursorY, width: contentW, height };
+        cursorY += height + SECTION_GAP;
+    }
+    // ── 5. Chain: Drivers → Assessments → 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.
+    const chainSections = [];
+    const chainEdges = [];
+    function pushChainSection(type, label, subtitle, rawNodes) {
+        const isEmpty = rawNodes.length === 0;
+        const sectionY = cursorY;
+        const nodeStartY = sectionY + CHAIN_HEADER_H + 8;
+        const nodeW = contentW - CHAIN_INNER_PAD * 2;
+        const nodes = isEmpty ? [] : rawNodes.map((n, i) => ({
+            id: n.id,
+            name: n.name,
+            meta: n.meta,
+            x: contentX + CHAIN_INNER_PAD,
+            y: nodeStartY + i * (CHAIN_NODE_H + opts.rowGap),
+            width: nodeW,
+            height: CHAIN_NODE_H,
+        }));
+        const bodyH = isEmpty
+            ? CHAIN_GAP_H
+            : rawNodes.length * (CHAIN_NODE_H + opts.rowGap) - opts.rowGap;
+        const sectionH = CHAIN_HEADER_H + 8 + bodyH + 8;
+        chainSections.push({ type, label, subtitle, nodes, isEmpty, x: contentX, y: sectionY, width: contentW, height: sectionH });
+        cursorY += sectionH + CONNECTOR_H;
+    }
+    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 })));
+    pushChainSection('changes', 'Changes', 'What will change?', changes.map((c) => ({ id: c.id, name: c.name })));
+    // Remove trailing CONNECTOR_H — last section connects to milestones with SECTION_GAP.
+    cursorY = cursorY - CONNECTOR_H + SECTION_GAP;
+    // 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 });
+        }
+    }
+    for (const c of changes) {
+        for (const gid of c.goalIds) {
+            if (goalIdSet.has(gid))
+                chainEdges.push({ sourceId: gid, targetId: c.id });
+        }
+    }
+    // ── 6. Milestones ────────────────────────────────────────────────────────
     const milestones = [];
     if (card.milestones.length > 0) {
-        pushHeader('Milestones');
         const perRow = Math.max(1, Math.floor((contentW + MILESTONE_GAP) / (MILESTONE_W + MILESTONE_GAP)));
-        const rowStartY = cursorY;
         card.milestones.forEach((m, i) => {
             const col = i % perRow;
             const row = Math.floor(i / perRow);
             milestones.push({
-                id: m.id,
-                name: m.name,
-                date: m.date,
+                id: m.id, name: m.name, date: m.date,
                 archimateClass: ARCHIMATE_CLASS.MILESTONE,
                 x: contentX + col * (MILESTONE_W + MILESTONE_GAP),
-                y: rowStartY + row * (MILESTONE_H + opts.rowGap),
-                width: MILESTONE_W,
-                height: MILESTONE_H,
+                y: cursorY + row * (MILESTONE_H + opts.rowGap),
+                width: MILESTONE_W, height: MILESTONE_H,
             });
         });
         const rows = Math.ceil(card.milestones.length / perRow);
-        cursorY = rowStartY + rows * (MILESTONE_H + opts.rowGap) - opts.rowGap + SECTION_GAP;
+        cursorY += rows * (MILESTONE_H + opts.rowGap) - opts.rowGap + SECTION_GAP;
     }
-    // 4. Motivation chain — Factors | Goals | Changes columns.
-    const chainEdges = [];
-    const factorsCol = [];
-    const goalsCol = [];
-    const changesCol = [];
-    const { factors, goals, changes } = card.motivation;
-    if (factors.length + goals.length + changes.length > 0) {
-        pushHeader('Motivation — Factors → Goals → Changes');
-        const colW = (contentW - opts.columnGap * 2) / 3;
-        const colX = [contentX, contentX + colW + opts.columnGap, contentX + (colW + opts.columnGap) * 2];
-        const colStartY = cursorY;
-        const stack = (items, colIndex, into) => {
-            items.forEach((it, i) => {
-                into.push({
-                    id: it.id,
-                    name: it.name,
-                    x: colX[colIndex],
-                    y: colStartY + i * (CHAIN_NODE_H + opts.rowGap),
-                    width: colW,
-                    height: CHAIN_NODE_H,
-                });
-            });
-        };
-        stack(factors, 0, factorsCol);
-        stack(goals, 1, goalsCol);
-        stack(changes, 2, changesCol);
-        // Edges: factor→goal (goal.factorIds), goal→change (change.goalIds).
-        const factorIds = new Set(factorsCol.map((n) => n.id));
-        const goalIds = new Set(goalsCol.map((n) => n.id));
-        for (const g of goals) {
-            for (const fid of g.factorIds) {
-                if (factorIds.has(fid))
-                    chainEdges.push({ sourceId: fid, targetId: g.id });
-            }
-        }
-        for (const c of changes) {
-            for (const gid of c.goalIds) {
-                if (goalIds.has(gid))
-                    chainEdges.push({ sourceId: gid, targetId: c.id });
-            }
-        }
-        const tallest = Math.max(factorsCol.length, goalsCol.length, changesCol.length);
-        cursorY = colStartY + tallest * (CHAIN_NODE_H + opts.rowGap) - opts.rowGap + SECTION_GAP;
-    }
-    // 5. Child activities — full-width rows.
+    // ── 7. Child activities ───────────────────────────────────────────────────
     const childActivities = [];
     if (card.childActivities.length > 0) {
-        pushHeader('Child activities');
-        const rowStartY = cursorY;
         card.childActivities.forEach((a, i) => {
             const metaBits = [];
             if (a.start_date || a.end_date)
@@ -140,28 +246,39 @@ export function layoutActivityCard(card, options) {
             if (a.owner)
                 metaBits.push(a.owner);
             childActivities.push({
-                id: a.id,
-                name: a.name,
+                id: a.id, name: a.name,
                 archimateClass: ARCHIMATE_CLASS.ACTIVITY,
                 meta: metaBits.join(' · '),
                 x: contentX,
-                y: rowStartY + i * (CHILD_ROW_H + opts.rowGap),
-                width: contentW,
-                height: CHILD_ROW_H,
+                y: cursorY + i * (CHILD_ROW_H + opts.rowGap),
+                width: contentW, height: CHILD_ROW_H,
             });
         });
-        cursorY =
-            rowStartY + card.childActivities.length * (CHILD_ROW_H + opts.rowGap) - opts.rowGap + SECTION_GAP;
+        cursorY += card.childActivities.length * (CHILD_ROW_H + opts.rowGap) - opts.rowGap + SECTION_GAP;
+    }
+    // ── 8. Footer — notes ────────────────────────────────────────────────────
+    let footerRow;
+    const notes = (card.notes ?? '').trim();
+    if (notes.length > 0) {
+        const valueLines = wrapText(notes, maxChars, 10);
+        const lines = valueLines.length > 0 ? valueLines : ['—'];
+        const height = INFO_ROW_BASE_H + lines.length * INFO_LINE_H;
+        footerRow = { label: 'Notes', valueLines: lines, x: contentX, y: cursorY, width: contentW, height };
+        cursorY += height + SECTION_GAP;
     }
     const totalHeight = cursorY - SECTION_GAP + PAD;
     return {
         bounds: { x: 0, y: 0, width: opts.cardWidth, height: Math.max(totalHeight, PAD * 2 + TITLE_H) },
-        title,
+        titleRow,
+        activityTypeBadge,
+        statusBadge,
         dateFields,
-        sectionHeaders,
-        milestones,
-        chainColumns: { factors: factorsCol, goals: goalsCol, changes: changesCol },
+        stakeholderRoleSlots,
+        descriptionRow,
+        chainSections,
         chainEdges,
+        milestones,
         childActivities,
+        footerRow,
     };
 }

package/dist/activity-card/resolver.js

@@ -107,6 +107,35 @@ function activeActivityGoals(relations, fromId) {
     }
     return out;
 }
+/**
+ * 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).
+ */
+function activeActivityStakeholders(relations, fromId) {
+    const out = [];
+    for (const doc of relations) {
+        if (!isObject(doc))
+            continue;
+        if (str(doc['notation']) !== 'relation')
+            continue;
+        if (str(doc['type']) !== 'activity_stakeholder')
+            continue;
+        if (str(doc['from']) !== fromId)
+            continue;
+        const to = str(doc['to']);
+        if (!to)
+            continue;
+        const validTo = doc['valid_to'];
+        if (validTo !== undefined && validTo !== null)
+            continue; // ended relation
+        if (!out.some((s) => s.id === to))
+            out.push({ id: to, role: str(doc['role']) });
+    }
+    return out;
+}
 export function resolveActivityCard(doc, sources) {
     const errors = [];
     const warnings = [];
@@ -119,27 +148,19 @@ export function resolveActivityCard(doc, sources) {
     }
     const activities = collectByNotation(sources.elements, 'activity');
     const projectRec = activities.get(projectId);
-    // PC-001 — project must resolve to an admitted ACTIVITY element in canon.
+    // 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.
     if (!projectRec) {
         errors.push({
             code: 'PC-001',
-            message: `activity_card.project "${projectId}" does not resolve to an ACTIVITY element in the canon element store`,
+            message: `activity_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)`,
         });
         return { valid: false, errors, warnings };
     }
-    // PC-002 — the resolved Activity should be the project scale. In the element
-    // model all activity scales (initiative / programme / project / task) share
-    // one ACTIVITY TYPE and `activity_type` references an ActivityType element,
-    // so a missing/non-literal value is acceptable; only an explicit, clearly
-    // non-project marker is flagged. (Canonical project-identification semantics
-    // are tracked as a follow-up internally.)
-    const activityType = str(projectRec['activity_type']);
-    if (activityType !== undefined && activityType !== 'Project' && activityType !== 'project') {
-        errors.push({
-            code: 'PC-002',
-            message: `Activity "${projectId}" has activity_type "${activityType}", expected the project scale`,
-        });
-    }
     // LIFECYCLE-001..003 on the project Activity.
     const validFrom = projectRec['valid_from'];
     const validToRaw = projectRec['valid_to'];
@@ -230,8 +251,11 @@ export function resolveActivityCard(doc, sources) {
     if (errors.length > 0) {
         return { valid: false, errors, warnings };
     }
-    // ── Motivation chain — expand against canon FACTOR / GOAL / CHANGE elements ──
-    const factorElems = collectByNotation(sources.elements, 'factor');
+    // ── Motivation chain — expand against canon DRIVER / GOAL / CHANGE elements ──
+    // Canon elements use `notation: driver`; `notation: factor` accepted for backward compat.
+    const driverElemsLegacy = collectByNotation(sources.elements, 'factor');
+    const driverElemsNew = collectByNotation(sources.elements, 'driver');
+    const driverElems = new Map([...driverElemsLegacy, ...driverElemsNew]);
     const goalElems = collectByNotation(sources.elements, 'goal');
     const changeElems = collectByNotation(sources.elements, 'change');
     const changes = [];
@@ -247,7 +271,7 @@ export function resolveActivityCard(doc, sources) {
         changes.push({ id: cid, name: str(rec['name']) ?? cid, goalIds: strArray(rec['goals']) });
     }
     // Goals shown = the project's declared goals ∪ goals referenced by in-scope
-    // changes (so the F→G→C chain stays connected).
+    // changes (so the D→G→C chain stays connected).
     const goalIdSet = new Set(projectGoalIds);
     for (const ch of changes)
         for (const g of ch.goalIds)
@@ -262,18 +286,47 @@ export function resolveActivityCard(doc, sources) {
             });
             continue;
         }
-        goals.push({ id: gid, name: str(rec['name']) ?? gid, factorIds: strArray(rec['factors']) });
+        goals.push({ id: gid, name: str(rec['name']) ?? gid, driverIds: strArray(rec['factors']) });
     }
-    // Factors shown = those referenced by the in-scope goals.
-    const factorIdSet = new Set();
+    // Drivers shown = those referenced by the in-scope goals.
+    const driverIdSet = new Set();
     for (const g of goals)
-        for (const f of g.factorIds)
-            factorIdSet.add(f);
-    const factors = [];
-    for (const fid of factorIdSet) {
-        const rec = factorElems.get(fid);
-        factors.push({ id: fid, name: rec ? str(rec['name']) ?? fid : fid });
+        for (const d of g.driverIds)
+            driverIdSet.add(d);
+    const drivers = [];
+    for (const did of driverIdSet) {
+        const rec = driverElems.get(did);
+        drivers.push({ id: did, name: rec ? str(rec['name']) ?? did : did });
+    }
+    // ── Assessments — findings that assess an in-scope Driver ────────────────────
+    // Assessments answer "what specific problem are we solving?" They are resolved
+    // from ASSESSMENT elements whose `assesses` field matches a Driver id that
+    // appeared in the motivation chain above. Empty when none exist — the gap is
+    // intentionally visible on the card so the author knows it needs filling.
+    const driverIdLookup = new Set(drivers.map((d) => d.id));
+    const assessmentElems = collectByNotation(sources.elements, 'assessment');
+    const assessments = [];
+    for (const [aid, rec] of assessmentElems) {
+        const driverId = str(rec['assesses']);
+        if (!driverId || !driverIdLookup.has(driverId))
+            continue;
+        assessments.push({
+            id: aid,
+            name: str(rec['name']) ?? aid,
+            driverId,
+            description: str(rec['description']),
+            observed_at: str(rec['observed_at']),
+        });
     }
+    assessments.sort((a, b) => {
+        if (!a.observed_at && !b.observed_at)
+            return 0;
+        if (!a.observed_at)
+            return 1;
+        if (!b.observed_at)
+            return -1;
+        return a.observed_at < b.observed_at ? -1 : a.observed_at > b.observed_at ? 1 : 0;
+    });
     // ── Child activities — parent = project id ──────────────────────────────────
     const childActivities = [];
     for (const [id, rec] of activities) {
@@ -289,6 +342,34 @@ export function resolveActivityCard(doc, sources) {
         });
     }
     childActivities.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    // ── Project goal text field — names of the DIRECTLY-served goals ────────────
+    // The "Project goal" field shows the goals the project itself serves (the
+    // `activity_goal` targets), not the wider F→G→C chain (which also pulls in
+    // goals referenced only by in-scope changes). Resolve each id to its GOAL
+    // 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 ──
+    const stakeholderElems = collectByNotation(sources.elements, 'stakeholder');
+    const stakeholders = [];
+    for (const { id: sid, role } of activeActivityStakeholders(sources.relations, projectId)) {
+        const rec = stakeholderElems.get(sid);
+        if (!rec) {
+            warnings.push({
+                code: 'PC-001',
+                message: `Stakeholder "${sid}" not found as a STAKEHOLDER element in canon; shown by id`,
+            });
+            stakeholders.push({ id: sid, name: sid, role });
+            continue;
+        }
+        stakeholders.push({
+            id: sid,
+            name: str(rec['name']) ?? sid,
+            type: str(rec['type']),
+            interest: str(rec['interest']),
+            influence: str(rec['influence']),
+            role,
+        });
+    }
     const project = {
         id: projectId,
         name: str(projectRec['name']) ?? projectId,
@@ -297,14 +378,20 @@ export function resolveActivityCard(doc, sources) {
         valid_to: validToOk ? validToRaw : undefined,
         start_date: str(projectRec['start_date']),
         end_date: str(projectRec['end_date']),
+        activity_type: str(projectRec['activity_type']),
+        status: str(projectRec['status']),
     };
     const resolved = {
         cardId: str(card.id) ?? '',
         cardDescription: str(card.description),
         project,
         milestones,
-        motivation: { factors, goals, changes },
+        motivation: { drivers, goals, changes },
+        assessments,
         childActivities,
+        goalNames,
+        stakeholders,
+        notes: str(card.notes),
     };
     return { valid: true, errors, warnings, resolved };
 }