@transitrix/diagrams 1.15.0 → 1.16.1

package/src/compliance/requirement-chain.ts

@@ -7,7 +7,8 @@ import { validateVerification } from '../verification/validate.js';
 
 export const CHAIN_STAGES = ['Source document', 'Driver', 'Need', 'Stakeholder requirement',
   'System requirement', 'Software requirement', 'Unclassified requirement', 'Verification definition', 'Result'] as const;
-export interface ChainScope { catalogue: string; product?: string; release?: string; project?: string }
+export interface ChainSubject { type: 'PRODUCT' | 'APPLICATION'; id: string }
+export interface ChainScope { catalogue: string; subject?: ChainSubject; product?: string; release?: string; project?: string }
 export interface ChainInput {
   index: ComplianceIndex; scope: ChainScope; asAt: string; snapshotId: string;
   sourceRevision?: string; complete: boolean;
@@ -23,7 +24,7 @@ export interface RequirementChainEdge {
 }
 export interface ChainAssignment { requirement: string; nearest: string; depth: number; relations: string[] }
 export interface RequirementChainProjection {
-  contract: 'requirement-chain/0.2'; contractRevision: string; asAt: string; snapshotId: string; sourceRevision?: string;
+  contract: 'requirement-chain/0.2' | 'requirement-chain/0.3'; contractRevision: string; asAt: string; snapshotId: string; sourceRevision?: string;
   scope: ChainScope; completeness: 'complete' | 'incomplete'; scopeFindings: string[];
   populations: { product: ChainSet; release: ChainSet; selected: ChainSet; inactive: ChainSet; unresolved: ChainSet };
   assignments: { here: ChainSet; otherReleaseOnly: ChainSet; unassigned: ChainSet; invalid: ChainSet; provenance: ChainAssignment[] };
@@ -53,9 +54,26 @@ function freeze<T>(value: T): T {
 const CODEX = ['LAW', 'REGULATION', 'STANDARD', 'POLICY', 'INTERNAL_STANDARD', 'PRINCIPLE'];
 const FIELD = ['INTERVIEW', 'SURVEY', 'OBSERVATION', 'DRAFT'];
 
-/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+/** Explicit PRODUCT compatibility adapter for requirement-chain/0.2. */
 export function buildRequirementChain(input: ChainInput): RequirementChainProjection {
+  if (input.scope.subject) throw new Error('Use buildSubjectRequirementChain for explicit subjects');
+  return projectRequirementChain(input);
+}
+
+/** Subject-aware 0.3 entry point; both versions use the same deterministic projection. */
+export function buildSubjectRequirementChain(input: ChainInput & { scope: ChainScope & { subject: ChainSubject } }): RequirementChainProjection {
+  if (input.scope.product !== undefined) throw new Error('Conflicting product and subject selectors');
+  if (!['PRODUCT', 'APPLICATION'].includes(input.scope.subject.type)) throw new Error('Unsupported subject type');
+  return projectRequirementChain(input);
+}
+
+/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+function projectRequirementChain(input: ChainInput): RequirementChainProjection {
   const { index, asAt, scope } = input;
+  const subject = scope.subject ?? { type: 'PRODUCT', id: scope.product };
+  const membershipKind = subject.type === 'APPLICATION' ? 'application_scope' : 'product_scope';
+  const pairKind = subject.type === 'APPLICATION' ? 'project_application' : 'project_product';
+  const subjectWord = scope.subject ? 'subject' : 'product';
   const findings = structuredClone(index.findings);
   const scopeFindings: string[] = [];
   const records = new Map<string, ChainRecord>();
@@ -64,7 +82,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     const id = `${owner}.${field}`;
     if (!findings.some(f => f.id === id && f.code === code)) findings.push({ id, owner, field, code, message, reference, severity: warning ? 'warning' : 'error' });
   };
-  for (const [id, versions] of index.recordsById) {
+  for (const [id, versions] of [...index.recordsById].sort(([a], [b]) => a.localeCompare(b))) {
     if (versions.length !== 1) {
       finding(id, 'id', 'DUPLICATE', 'Ambiguous catalogue identity'); complete = false;
     } else records.set(id, structuredClone(versions[0]));
@@ -114,7 +132,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
       if (r.raw.level !== undefined && level < 0) finding(r.id, 'level', 'REQ-LEVEL', 'Invalid level; displayed as unclassified');
     } else if (r.type === 'NEED') node(r, 2);
     else if (r.type === 'DRIVER') node(r, 1);
-    else if (['PRODUCT', 'RELEASE', 'ACTION'].includes(r.type)) node(r, -1);
+    else if (['PRODUCT', 'APPLICATION', 'RELEASE', 'ACTION'].includes(r.type)) node(r, -1);
     else if (CODEX.includes(r.type) || FIELD.includes(r.type)) {
       node(r, 0);
       if (r.raw.source_document !== undefined) {
@@ -162,6 +180,8 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     const src = records.get(from), dst = records.get(to);
     const endpoints = kind === 'requirement_parent' ? is(from, 'REQUIREMENT') && is(to, 'REQUIREMENT') :
       kind === 'serves' ? is(from, 'REQUIREMENT') && is(to, 'NEED') :
+      kind === 'application_scope' ? is(from, 'REQUIREMENT') && is(to, 'APPLICATION') :
+      kind === 'project_application' ? isProject(from) && is(to, 'APPLICATION') :
       kind === 'product_scope' ? is(from, 'REQUIREMENT') && is(to, 'PRODUCT') :
       kind === 'project_scope' ? is(from, 'REQUIREMENT') && isProject(to) :
       kind === 'project_product' ? isProject(from) && is(to, 'PRODUCT') :
@@ -198,38 +218,38 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     }
   }
   const memberships = (id: string, kind: string) => rels.filter(r => usable.has(r.id) && r.raw.type === kind && r.raw.from === id).map(r => String(r.raw.to));
-  const unresolved = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').length === 0).map(r => r.id);
-  const P = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').includes(scope.product ?? '')).map(r => r.id);
+  const unresolved = requirements.filter(r => active.get(r.id) && memberships(r.id, 'product_scope').length === 0 && (!scope.subject || memberships(r.id, 'application_scope').length === 0)).map(r => r.id);
+  const P = requirements.filter(r => active.get(r.id) && memberships(r.id, membershipKind).includes(subject.id ?? '')).map(r => r.id);
   let productComplete = complete && unresolved.length === 0;
-  if (unresolved.length) scopeFindings.push('Unresolved product membership');
-  if (requirements.some(r => !envelope.get(r.id)) || rels.some(r => r.raw.type === 'product_scope' && active.get(r.id) && !usable.has(r.id))) productComplete = false;
+  if (unresolved.length) scopeFindings.push(`Unresolved ${subjectWord} membership`);
+  if (requirements.some(r => !envelope.get(r.id)) || rels.some(r => r.raw.type === membershipKind && active.get(r.id) && !usable.has(r.id))) productComplete = false;
   const invalidAssignments = new Set<string>();
   for (const r of rels.filter(r => r.raw.type === 'required_for')) {
     const from = String(r.raw.from), to = records.get(String(r.raw.to));
     const historical = chainDate(r.raw.valid_to) && r.raw.valid_to < asAt;
     const future = chainDate(r.raw.valid_from) && r.raw.valid_from > asAt;
-    if (!historical && !future && (!usable.has(r.id) || !memberships(from, 'product_scope').includes(String(to?.raw.of)))) {
+    if (!historical && !future && (!usable.has(r.id) || ![...memberships(from, 'product_scope'), ...(scope.subject ? memberships(from, 'application_scope') : [])].includes(String(to?.raw.of)))) {
       invalidAssignments.add(from);
-      finding(r.id, 'to', 'ASSIGNMENT', 'Invalid, dangling or wrong-product assignment', true);
+      finding(r.id, 'to', 'ASSIGNMENT', `Invalid, dangling or wrong-${subjectWord} assignment`, true);
       if (!envelope.get(r.id)) productComplete = false;
     }
   }
   let selectedComplete = complete;
-  if (!is(scope.product, 'PRODUCT')) { productComplete = false; selectedComplete = false; scopeFindings.push('Product unselected or unresolved'); }
-  if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== scope.product) {
-    selectedComplete = false; scopeFindings.push('Release unselected, unresolved or wrong product');
+  if (!is(subject.id, subject.type)) { productComplete = false; selectedComplete = false; scopeFindings.push(scope.subject ? 'Subject unselected or unresolved' : 'Product unselected or unresolved'); }
+  if (!is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== subject.id) {
+    selectedComplete = false; scopeFindings.push(`Release unselected, unresolved or wrong ${subjectWord}`);
   }
-  if (scope.project && (!isProject(scope.project) || !memberships(scope.project, 'project_product').includes(scope.product ?? ''))) {
-    selectedComplete = false; scopeFindings.push('Invalid or unmodelled project/product pair');
+  if (scope.project && (!isProject(scope.project) || !memberships(scope.project, pairKind).includes(subject.id ?? ''))) {
+    selectedComplete = false; scopeFindings.push(`Invalid or unmodelled project/${subjectWord} pair`);
   }
   function query(release: string): { ids: string[]; provenance: ChainAssignment[]; complete: boolean } {
     const chain: string[] = []; let cursor: string | undefined = release; let valid = true;
     while (cursor) {
       const r: ChainRecord | undefined = records.get(cursor);
-      if (chain.includes(cursor) || !is(cursor, 'RELEASE') || r?.raw.of !== scope.product) {
+      if (chain.includes(cursor) || !is(cursor, 'RELEASE') || r?.raw.of !== subject.id) {
         valid = false;
         finding(chain[chain.length - 1] ?? release, 'predecessor', 'RELEASE-SCOPE',
-          chain.includes(cursor) ? 'Release predecessor cycle' : 'Missing, invalid or cross-product predecessor');
+          chain.includes(cursor) ? 'Release predecessor cycle' : `Missing, invalid or cross-${subjectWord} predecessor`);
         break;
       }
       chain.push(cursor);
@@ -251,13 +271,13 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
   if (scope.project && L.some(id => memberships(id, 'project_scope').length === 0 || rels.some(r => r.raw.type === 'project_scope' && r.raw.from === id && active.get(r.id) && !usable.has(r.id)))) {
     selectedComplete = false; scopeFindings.push('Unresolved project membership');
   }
-  if (rels.some(r => ['product_scope', 'project_scope', 'required_for'].includes(String(r.raw.type)) && !envelope.get(r.id))) selectedComplete = false;
-  if (scope.project && L.some(id => memberships(id, 'project_scope').some(project => !memberships(project, 'project_product').includes(scope.product ?? '')))) {
-    selectedComplete = false; scopeFindings.push('Inconsistent project/product membership');
+  if (rels.some(r => [membershipKind, 'project_scope', 'required_for'].includes(String(r.raw.type)) && !envelope.get(r.id))) selectedComplete = false;
+  if (scope.project && L.some(id => memberships(id, 'project_scope').some(project => !memberships(project, pairKind).includes(subject.id ?? '')))) {
+    selectedComplete = false; scopeFindings.push(`Inconsistent project/${subjectWord} membership`);
   }
   const S = L.filter(id => !scope.project || memberships(id, 'project_scope').includes(scope.project));
   const elsewhere = new Set<string>();
-  for (const release of records.values()) if (release.type === 'RELEASE' && release.raw.of === scope.product) {
+  for (const release of records.values()) if (release.type === 'RELEASE' && release.raw.of === subject.id) {
     const q = query(release.id); productComplete &&= q.complete; q.ids.forEach(id => elsewhere.add(id));
   }
   const unassigned = P.filter(id => !elsewhere.has(id) && !invalidAssignments.has(id));
@@ -307,7 +327,7 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
     const owners = new Set(ancestors);
     for (const v of verifications) if (v.raw.verifies === r.id) owners.add(v.id);
     for (const rel of rels) {
-      const ownScope = ['product_scope', 'project_scope', 'required_for'].includes(String(rel.raw.type));
+      const ownScope = [membershipKind, 'project_scope', 'required_for'].includes(String(rel.raw.type));
       if (ownScope ? rel.raw.from === r.id : owners.has(String(rel.raw.from))) owners.add(rel.id);
     }
     for (const f of findings) if (owners.has(f.owner)) (affectedRequirements[f.id] ??= []).push(r.id);
@@ -326,15 +346,16 @@ export function buildRequirementChain(input: ChainInput): RequirementChainProjec
   const selectedRefs = refs.filter(f => affectedRequirements[f.id]?.some(id => S.includes(id)));
   const broken = S.filter(id => selectedRefs.some(f => affectedRequirements[f.id]?.includes(id)));
   for (const n of nodes) if (records.get(n.recordId)?.type === 'REQUIREMENT' && !S.includes(n.recordId)) {
-    n.context.push(!active.get(n.recordId) ? 'inactive' : !P.includes(n.recordId) ? 'unresolved or other product' :
+    n.context.push(!active.get(n.recordId) ? 'inactive' : !P.includes(n.recordId) ? `unresolved or other ${subjectWord}` :
       !L.includes(n.recordId) ? 'other release or unassigned' : 'other project');
   }
+  if (scope.subject && (!is(subject.id, subject.type) || !is(scope.release, 'RELEASE') || records.get(scope.release ?? '')?.raw.of !== subject.id)) productComplete = false;
   const unassignedSet = set(unassigned, productComplete);
   const result: RequirementChainProjection = {
-    contract: 'requirement-chain/0.2', contractRevision: '97c9d41819011ead8fe192c266cba32707eae82f', asAt, snapshotId: input.snapshotId, sourceRevision: input.sourceRevision,
+    contract: scope.subject ? 'requirement-chain/0.3' : 'requirement-chain/0.2', contractRevision: scope.subject ? 'a131b1862d86f34be8feb729e1cc6ebc994c3891' : '97c9d41819011ead8fe192c266cba32707eae82f', asAt, snapshotId: input.snapshotId, sourceRevision: input.sourceRevision,
     scope: structuredClone(scope), completeness: productComplete && selectedComplete ? 'complete' : 'incomplete', scopeFindings: sorted(scopeFindings),
     populations: { product: set(P, productComplete), release: set(L, selectedComplete), selected: set(S, selectedComplete),
-      inactive: set(requirements.filter(r => envelope.get(r.id) && !active.get(r.id) && rels.some(rel => rel.raw.type === 'product_scope' && rel.raw.from === r.id && rel.raw.to === scope.product && envelope.get(rel.id))).map(r => r.id), complete),
+      inactive: set(requirements.filter(r => envelope.get(r.id) && !active.get(r.id) && rels.some(rel => rel.raw.type === membershipKind && rel.raw.from === r.id && rel.raw.to === subject.id && envelope.get(rel.id))).map(r => r.id), complete),
       unresolved: set(unresolved, complete) },
     assignments: { here: set(L, selectedComplete), otherReleaseOnly: set(P.filter(id => elsewhere.has(id) && !L.includes(id)), productComplete),
       unassigned: unassignedSet, invalid: set(P.filter(id => invalidAssignments.has(id)), complete), provenance: selected.provenance.sort((a, b) => a.requirement.localeCompare(b.requirement)) },
@@ -408,6 +429,7 @@ export function requirementReleaseCounts(p: RequirementChainProjection) {
   const contextUnits = { 0: 'source documents', 1: 'drivers', 2: 'needs', 7: 'definition parts', 8: 'result parts' } as const;
   for (const stage of [0, 1, 2, 7, 8] as const) add('context-' + stage, CHAIN_STAGES[stage],
     set(view.nodes.filter(n => n.stage === stage).map(n => n.id), p.populations.selected.completeness === 'complete'), contextUnits[stage]);
+  if (p.scope.subject) for (const count of Object.values(counts)) count.label = count.label.replace(/whole product/g, 'whole subject').replace('Product requirements', 'Subject requirements');
   return freeze(counts);
 }
 
@@ -421,7 +443,10 @@ export class RequirementChainSnapshot {
     try {
       const input = await load();
       if (generation !== this.generation) return false;
-      this.current = buildRequirementChain(input); this.stale = false; return true;
+      this.current = input.scope.subject
+        ? buildSubjectRequirementChain({ ...input, scope: { ...input.scope, subject: input.scope.subject } })
+        : buildRequirementChain(input);
+      this.stale = false; return true;
     } catch {
       if (generation === this.generation) this.stale = true;
       return false;

package/src/goals/resolver.ts

@@ -48,6 +48,7 @@ export interface GoalsViewConfig {
 
 export interface GoalsCanonSources {
   elements: unknown[];
+  relations?: unknown[];
 }
 
 /** GOAL elements by id (`notation: goal`). */
@@ -58,11 +59,53 @@ function collectGoalElements(docs: unknown[]): Map<string, Record<string, unknow
     if (str(doc['notation']) !== 'goal') continue;
     const id = str(doc['id']);
     if (!id) continue;
-    if (!out.has(id)) out.set(id, doc); // first definition wins
+    if (!out.has(id)) out.set(id, { ...doc }); // never mutate the caller's catalogue
   }
   return out;
 }
 
+/** Materialize canonical child -> parent links for a single-parent tree.
+ * Never mutate canon or silently linearize an ambiguous hierarchy.
+ */
+function applyGoalParentRelations(
+  goals: Map<string, Record<string, unknown>>,
+  relations: unknown[],
+  validAt: string | undefined,
+): void {
+  const declaredChildren = new Set<string>();
+  const parents = new Map<string, Set<string>>();
+  for (const doc of relations) {
+    if (!isObject(doc) || doc['notation'] !== 'relation' || doc['type'] !== 'goal_parent') continue;
+    const child = str(doc['from']);
+    const parent = str(doc['to']);
+    if (!child || !parent || !goals.has(child) || !goals.has(parent)) {
+      throw new Error(`goal_parent relation ${str(doc['id']) ?? '(unnamed)'} must reference two existing goals`);
+    }
+    declaredChildren.add(child);
+    const from = str(doc['valid_from']);
+    const to = str(doc['valid_to']);
+    if (validAt && ((from && validAt < from) || (to && validAt > to))) continue;
+    const choices = parents.get(child) ?? new Set<string>();
+    choices.add(parent);
+    parents.set(child, choices);
+  }
+  for (const child of declaredChildren) {
+    const goal = goals.get(child)!;
+    const choices = parents.get(child) ?? new Set<string>();
+    if (choices.size > 1) {
+      throw new Error(`goal_parent for ${child} has multiple parents in this scope; narrow valid_at or use a graph view`);
+    }
+    const parent = [...choices][0];
+    const legacyParent = str(goal['parent']);
+    if (parent && legacyParent && parent !== legacyParent) {
+      throw new Error(`goal_parent for ${child} conflicts with its inline parent`);
+    }
+    // Declared but inactive links must not fall back to an undated parent.
+    if (parent) goal['parent'] = parent;
+    else delete goal['parent'];
+  }
+}
+
 /**
  * Returns true when the parsed view document uses the canon-projection form
  * (`view_config` key present, no inline `goals[]`). Used by the preview and
@@ -91,6 +134,8 @@ export function resolveGoals(
   const scope = isObject(vc['scope']) ? vc['scope'] : {};
 
   const allGoals = collectGoalElements(sources.elements);
+  const validAt = str(scope['valid_at']);
+  applyGoalParentRelations(allGoals, sources.relations ?? [], validAt);
 
   // 1. Scope by root_goal (this goal + its descendants), or every goal when
   // omitted (§5.1: "Omit to show all root goals").
@@ -126,7 +171,6 @@ export function resolveGoals(
   // 4. Narrow by valid_at — only goals in effect on that date. Goals with no
   // valid_from are not lifecycle-tracked and are kept (permissive default,
   // matching the action/dgca resolvers' stance).
-  const validAt = str(scope['valid_at']);
   if (validAt) {
     candidateIds = new Set(
       [...candidateIds].filter((id) => {

package/src/products/types.ts

@@ -1,4 +1,4 @@
-export type ProductType = 'digital_product' | 'service' | 'platform' | 'bundle';
+export type ProductType = 'physical_product' | 'digital_product' | 'service' | 'platform' | 'bundle';
 export type ProductStatus = 'Draft' | 'Active' | 'Deprecated';
 
 export interface Product {

package/src/products/validate.ts

@@ -4,7 +4,7 @@ import type { ValidationError, ValidationWarning, ValidationResult } from '../va
 
 export type { ValidationError, ValidationWarning, ValidationResult };
 
-const VALID_TYPES = new Set<ProductType>(['digital_product', 'service', 'platform', 'bundle']);
+const VALID_TYPES = new Set<ProductType>(['physical_product', 'digital_product', 'service', 'platform', 'bundle']);
 const VALID_STATUSES = new Set<ProductStatus>(['Draft', 'Active', 'Deprecated']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 

package/src/repo-validate/check-strategy-chain.ts

@@ -17,16 +17,11 @@ import { validateActionFields } from '../activities/action-fields.js';
 // classification (`Issue.Severity` in the Go source) and its "import
 // anyway, record the warning" policy.
 //
-// GOALS-009/011 (orphan / missing parent) are ported at warning severity even
-// though most standalone GOAL elements legitimately have no `parent` field —
-// GOAL.parent is "v0.x transitional" (ELEMENT_PRIMITIVES.md §7.2; canonical
-// home is a `goal_parent` REL file or the goals-tree view's inline `parent`).
-// `organizations/acme_corp`'s GOAL-CUST-1/GOAL-OPS-1/GOAL-EU-1 are exactly
-// this shape and do surface GOALS-011 warnings — that noise is the accepted
-// cost of a *warning* level rule (non-blocking, advisory), unlike the ERROR
-// tier this repo held the line on. This is a deliberate call, not an
-// oversight: keep the coverage rather than drop it, now that it can be
-// non-blocking.
+// GOALS-010 checks canonical and legacy edges in overlapping lifecycle slices.
+// GOALS-009/011 respect the canonical goal_parent records already loaded
+// from canon/relations. Static catalogue coverage considers those links;
+// date-scoped hierarchy selection and ambiguity are checked by Goals views.
+// Legacy inline parents remain supported for transitional catalogues.
 //
 // GOALS-008 (type/level mismatch) is still NOT ported, at either severity.
 // Both of DSM's cases ("type not declared in goal_types" / "level doesn't
@@ -124,17 +119,15 @@ function collectByNotation(
   return out;
 }
 
-/** DFS cycle detection over a single-parent edge (GOAL.parent), matching DSM's
+/** DFS cycle detection over resolved parent edges, matching DSM's
  *  `findCycle` (goals.go): only walks an edge to a parent that itself resolves
  *  within the set — an edge into an unresolved (orphan) parent is not walked,
  *  so an orphan can never be mistaken for a cycle. Returns the id where a
  *  back-edge was hit, or `undefined` if the graph is acyclic. */
-function findParentCycle(goals: ChainElement[]): string | undefined {
-  const parentOf = new Map<string, string | undefined>();
+function findParentCycle(goals: ChainElement[], parents: Map<string, string[]>): string | undefined {
   const known = new Set<string>();
   for (const g of goals) {
     known.add(g.id);
-    parentOf.set(g.id, readString(g.data, 'parent'));
   }
   const UNVISITED = 0;
   const VISITING = 1;
@@ -146,8 +139,8 @@ function findParentCycle(goals: ChainElement[]): string | undefined {
     if (s === DONE) return undefined;
     if (s === VISITING) return id;
     state.set(id, VISITING);
-    const parent = parentOf.get(id);
-    if (parent && known.has(parent)) {
+    for (const parent of parents.get(id) ?? []) {
+      if (!known.has(parent)) continue;
       const hit = walk(parent);
       if (hit) return hit;
     }
@@ -198,16 +191,40 @@ function findPredecessorCycle(actions: ChainElement[]): string | undefined {
   return undefined;
 }
 
-/** GOALS-010 — the GOAL `parent` chain must not contain a cycle. */
-function checkGoalParentCycle(goals: ChainElement[], findings: RepoFinding[]): void {
-  const cyc = findParentCycle(goals);
-  if (cyc) {
+/** GOALS-010 — parent links must be acyclic in every effective date slice.
+ * A cycle can first appear only when an edge starts. Inspect those boundaries
+ * and the unbounded past; do not union disjoint historical parent relations.
+ */
+function checkGoalParentCycle(goals: ChainElement[], relations: RepoDoc[], findings: RepoFinding[]): void {
+  const known = new Set(goals.map(g => g.id));
+  const links = relations.flatMap(rel => {
+    const d = rel.data;
+    if (!d || d['notation'] !== 'relation' || d['type'] !== 'goal_parent') return [];
+    const child = readString(d, 'from'), parent = readString(d, 'to');
+    if (!child || !parent || !known.has(child) || !known.has(parent)) return [];
+    return [{ child, parent, from: readString(d, 'valid_from'), to: readString(d, 'valid_to') }];
+  });
+  const declared = new Set(links.map(link => link.child));
+  const dates = [...new Set(['0000-01-01', ...links.flatMap(link => link.from ? [link.from] : [])])].sort();
+  for (const date of dates) {
+    const parents = new Map<string, string[]>();
+    for (const g of goals) {
+      const legacy = readString(g.data, 'parent');
+      if (!declared.has(g.id) && legacy) parents.set(g.id, [legacy]);
+    }
+    for (const link of links) {
+      if ((link.from && date < link.from) || (link.to && date > link.to)) continue;
+      parents.set(link.child, [...(parents.get(link.child) ?? []), link.parent]);
+    }
+    const cyc = findParentCycle(goals, parents);
+    if (!cyc) continue;
     findings.push({
       scope: PScope,
       id: cyc,
       ruleId: 'GOALS-010',
       message: `GOALS-010: parent chain contains a cycle involving goal '${cyc}'.`,
     });
+    return;
   }
 }
 
@@ -215,11 +232,20 @@ function checkGoalParentCycle(goals: ChainElement[], findings: RepoFinding[]): v
  *  goals.go: the two are mutually exclusive per goal — a goal with no
  *  `parent` is checked for GOALS-011 (backlog, level >= 1); a goal with a
  *  `parent` is checked for GOALS-009 (orphan, parent unresolved) instead. */
-function checkGoalParentResolution(goals: ChainElement[], findings: RepoFinding[]): void {
+function checkGoalParentResolution(goals: ChainElement[], relations: RepoDoc[], findings: RepoFinding[]): void {
   const knownIds = new Set(goals.map((g) => g.id));
+  const linkedChildren = new Set<string>();
+  for (const rel of relations) {
+    const data = rel.data;
+    if (!data || data['notation'] !== 'relation' || data['type'] !== 'goal_parent') continue;
+    const child = readString(data, 'from');
+    const parent = readString(data, 'to');
+    if (child && parent && knownIds.has(child) && knownIds.has(parent)) linkedChildren.add(child);
+  }
   for (const g of goals) {
     const parent = readString(g.data, 'parent');
     if (!parent) {
+      if (linkedChildren.has(g.id)) continue;
       const level = readFiniteNumber(g.data, 'level');
       if (level !== undefined && level >= 1) {
         findings.push({
@@ -504,8 +530,8 @@ export function checkStrategyChainSemantics(input: RepoModelInput, findings: Rep
   const drivers = collectByNotation(input.elements, isDriverNotation);
   const changes = collectByNotation(input.elements, isChangeNotation);
 
-  checkGoalParentCycle(goals, findings);
-  checkGoalParentResolution(goals, findings);
+  checkGoalParentCycle(goals, input.relations, findings);
+  checkGoalParentResolution(goals, input.relations, findings);
   checkActionSelfPredecessor(actions, findings);
   checkActionPredecessorCycle(actions, findings);
   checkActionOrphanReferences(actions, findings);

package/src/standalone/validate.ts

@@ -1,6 +1,6 @@
 // Standalone forms from ELEMENT_PRIMITIVES and CONTRACT (Methodology 7).
 // Field payloads are opaque: only their published identity/admission contract is checked.
-import { isCanonicalIdOfType, typeOfId, type CanonCatalog } from '../typed-id.js';
+import { isCanonicalId, isCanonicalIdOfType, typeOfId, type CanonCatalog } from '../typed-id.js';
 import type { ValidationResult } from '../validation-types.js';
 
 export const mapping = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
@@ -45,10 +45,46 @@ export function validateStandalone(notation: string, input: unknown, options: St
   };
   optionalText('description');
   if (notation === 'product') {
-    if (!['digital_product','service','platform','bundle'].includes(d.type as string)) fail('type', 'digital_product|service|platform|bundle', d.type);
+    if (!['physical_product', 'digital_product','service','platform','bundle'].includes(d.type as string)) fail('type', 'physical_product|digital_product|service|platform|bundle', d.type);
     optionalText('domain'); reference('owner_role', ['ROLE']);
     if ('maturity' in d && !(Number.isInteger(d.maturity) && Number(d.maturity) >= 1 && Number(d.maturity) <= 5)) fail('maturity', 'integer 1..5', d.maturity);
     references('capabilities', ['CAPABILITY']); references('processes', ['PROCESS']); references('supporting_apps', ['APPLICATION']);
+  } else if (notation === 'process') {
+    reference('owner_role', ['ROLE']); reference('capability', ['CAPABILITY']);
+    references('participants', ['ROLE', 'ACTOR']);
+    optionalText('goal'); optionalText('result');
+    for (const key of ['parent', 'bpmn_file', 'maturity']) if (key in d) fail(key, 'absent inline; use canonical relations, flow or history', d[key]);
+    if (Array.isArray(d.participants) && new Set(d.participants).size !== d.participants.length) fail('participants', 'unique references', d.participants);
+    if ('flow' in d) {
+      if (!mapping(d.flow)) fail('flow', 'mapping', d.flow);
+      else {
+        const flow = d.flow;
+        const steps = Array.isArray(flow.steps) ? flow.steps : [];
+        const sequence = Array.isArray(flow.sequence) ? flow.sequence : [];
+        if (!Array.isArray(flow.steps) || !steps.length) fail('flow.steps', 'nonempty list', flow.steps);
+        if (!Array.isArray(flow.sequence)) fail('flow.sequence', 'list', flow.sequence);
+        const ids = new Set<string>();
+        const types = ['startEvent', 'endEvent', 'task', 'userTask', 'serviceTask', 'exclusiveGateway', 'parallelGateway'];
+        steps.forEach((step, i) => {
+          const key = `flow.steps[${i}]`;
+          if (!mapping(step)) { fail(key, 'mapping', step); return; }
+          if (!isCanonicalId(step.id) || ids.has(step.id)) fail(`${key}.id`, 'unique canonical step ID', step.id);
+          else ids.add(step.id);
+          if (!types.includes(step.type as string)) fail(`${key}.type`, types.join('|'), step.type);
+          if ((!['startEvent','endEvent'].includes(step.type as string) || 'name' in step) && !text(step.name)) fail(`${key}.name`, 'nonempty string', step.name);
+          ref(`${key}.performed_by`, step.performed_by, ['ROLE','ACTOR']);
+          if (!Array.isArray(d.participants) || !d.participants.includes(step.performed_by)) fail(`${key}.performed_by`, 'member of participants', step.performed_by);
+          if ('supported_by_application' in step) ref(`${key}.supported_by_application`, step.supported_by_application, ['APPLICATION']);
+        });
+        sequence.forEach((edge, i) => {
+          const key = `flow.sequence[${i}]`;
+          if (!mapping(edge)) { fail(key, 'mapping', edge); return; }
+          for (const end of ['from', 'to']) if (typeof edge[end] !== 'string' || !ids.has(edge[end] as string)) fail(`${key}.${end}`, 'ID in flow.steps', edge[end]);
+          if ('condition' in edge && !text(edge.condition)) fail(`${key}.condition`, 'nonempty string', edge.condition);
+          if ('default' in edge && typeof edge.default !== 'boolean') fail(`${key}.default`, 'boolean', edge.default);
+        });
+      }
+    }
   } else if (notation === 'capability') {
     if (!['domain','supporting'].includes(d.type as string)) fail('type', 'domain|supporting', d.type);
     for (const key of ['current_maturity','target_maturity','owner_role','target_date']) if (key in d) fail(key, 'attribute in history sidecar, absent inline', d[key], 'VERSIONED-004');

package/src/webview/render-activities.ts

@@ -26,7 +26,7 @@ import type {
 } from '../activities/types.js';
 import { horizontalCubicEdgePath, bowedCubicEdgePath, DEFAULT_EDGE_CURVATURE } from '../edge-path.js';
 import { parseNodeSizePreset, resolveActionNodeSize, type NodeSizePreset } from '../node-size-presets.js';
-import { generateSvgEmbedCss } from '../theme/index.js';
+import { generateSvgEmbedCss, type ThemeId } from '../theme/index.js';
 import { emitCenteredTextSvg, layoutCenteredEntityText } from './entity-text-layout.js';
 import { escXml } from './render-util.js';
 
@@ -235,6 +235,11 @@ export interface RenderActivitiesOptions {
    * Action name in the view header.
    */
   suppressProjectNodes?: boolean;
+  /**
+   * Theme CSS embedded as `<style>` so the SVG is self-contained.
+   * Defaults to `'transitrix'`. VS Code live preview uses body emitters + webview CSS instead.
+   */
+  embedCssTheme?: ThemeId;
 }
 
 /**
@@ -259,6 +264,7 @@ export function renderActivitiesSvg(doc: ActivityDoc, options: RenderActivitiesO
     curvature = DEFAULT_EDGE_CURVATURE,
     entryCurvature,
     suppressProjectNodes = true,
+    embedCssTheme = 'transitrix',
   } = options;
   const nodeSize = resolveActionNodeSize(parseNodeSizePreset(nodeSizePreset));
   const layoutGaps: ActivitiesLayoutOptions = {
@@ -300,7 +306,7 @@ export function renderActivitiesSvg(doc: ActivityDoc, options: RenderActivitiesO
   // drop the SVG into the DOM and styling resolves without any cooperation from
   // the host stylesheet. Matches what the VS Code path produces via
   // `prepareSvgForExport`.
-  const embedCss = generateSvgEmbedCss('transitrix') + ACTIVITIES_NETWORK_CSS;
+  const embedCss = generateSvgEmbedCss(embedCssTheme) + ACTIVITIES_NETWORK_CSS;
 
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
 <style>${embedCss}</style>

package/src/webview/render-activity-card.ts

@@ -31,7 +31,7 @@ import type {
   ResolvedActivityCard,
   ResolvedMilestone,
 } from '../activity-card/types.js';
-import { generateSvgEmbedCss } from '../theme/index.js';
+import { generateSvgEmbedCss, type ThemeId } from '../theme/index.js';
 import { escXml } from './render-util.js';
 
 const PAD = 24;
@@ -39,6 +39,11 @@ const EMPTY_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0"
 
 export interface RenderActivityCardOptions {
   title?: string;
+  /**
+   * Theme CSS embedded as `<style>` so the SVG is self-contained.
+   * Defaults to `'transitrix'`. VS Code live preview uses body emitters + webview CSS instead.
+   */
+  embedCssTheme?: ThemeId;
 }
 
 function truncate(text: string, maxChars: number): string {
@@ -241,7 +246,7 @@ export function renderActivityCardSvg(
   // §5.1 class convention the layout applies; keeps the import meaningful.
   void ARCHIMATE_CLASS;
 
-  const { title = '' } = options;
+  const { title = '', embedCssTheme = 'transitrix' } = options;
   const resolved = resolveSingleDoc(doc);
   const layout = layoutActivityCard(resolved);
 
@@ -259,7 +264,7 @@ export function renderActivityCardSvg(
     ? `<text class="text-header" x="${PAD}" y="${PAD + 14}">${escXml(`Activity Card — ${title}`)}</text>`
     : '';
 
-  const embedCss = generateSvgEmbedCss('transitrix');
+  const embedCss = generateSvgEmbedCss(embedCssTheme);
 
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">
 <style>${embedCss}</style>

package/src/webview/render-blocks.ts

@@ -41,6 +41,11 @@ export interface RenderBlocksOptions {
   title?: string;
   nodeSizePreset?: NodeSizePreset;
   layoutOptions?: BlocksLayoutOptions;
+  /**
+   * Theme CSS embedded via {@link renderBlocksLayoutSvg}.
+   * Defaults to `'transitrix'` for self-contained host-neutral SVG.
+   */
+  embedCssTheme?: ThemeId;
 }
 
 /**
@@ -133,7 +138,7 @@ ${parts.join('\n')}
  * with the shared theme CSS embedded so the output is self-contained.
  */
 export function renderBlocksSvg(doc: BlocksFile, options: RenderBlocksOptions = {}): string {
-  const { title = '', nodeSizePreset = 'normal', layoutOptions } = options;
+  const { title = '', nodeSizePreset = 'normal', layoutOptions, embedCssTheme = 'transitrix' } = options;
   const leaf = resolveBlocksLeafSize(parseNodeSizePreset(nodeSizePreset));
 
   const layout: BlocksLayout = layoutNestedBlocks(doc, {
@@ -150,7 +155,7 @@ export function renderBlocksSvg(doc: BlocksFile, options: RenderBlocksOptions =
     ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Nested Blocks — ${title}`)}</text>`
     : '';
 
-  return renderBlocksLayoutSvg(layout, { title: titleSvg, embedCssTheme: 'transitrix' });
+  return renderBlocksLayoutSvg(layout, { title: titleSvg, embedCssTheme });
 }
 
 /**
@@ -285,11 +290,16 @@ ${body}
 export interface RenderGridOptions {
   title?: string;
   layoutOptions?: GridLayoutOptions;
+  /**
+   * Theme CSS embedded via {@link renderGridLayoutSvg}.
+   * Defaults to `'transitrix'` for self-contained host-neutral SVG.
+   */
+  embedCssTheme?: ThemeId;
 }
 
 /** Host-neutral grid (matrix subset) renderer (IntelliJ/UI). */
 export function renderGridSvg(doc: GridFile, options: RenderGridOptions = {}): string {
-  const { title = '', layoutOptions } = options;
+  const { title = '', layoutOptions, embedCssTheme = 'transitrix' } = options;
   const layout = layoutGrid(doc, layoutOptions);
 
   if (layout.columns.length === 0 || layout.rows.length === 0) {
@@ -300,5 +310,5 @@ export function renderGridSvg(doc: GridFile, options: RenderGridOptions = {}): s
     ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Nested Blocks — ${title}`)}</text>`
     : '';
 
-  return renderGridLayoutSvg(layout, { title: titleSvg, embedCssTheme: 'transitrix' });
+  return renderGridLayoutSvg(layout, { title: titleSvg, embedCssTheme });
 }