@transitrix/diagrams 1.9.18 → 1.11.0

package/dist/process-blueprint/resolve-columns.js

@@ -0,0 +1,138 @@
+/**
+ * Render-time resolution of Process Blueprint column headers and the
+ * compliance-lane join key.
+ *
+ * A `PROCESS-…` column is the process: `name` / `goal` / `result` come from
+ * the child PROCESS element (ELEMENT_PRIMITIVES §7.5), never from restated
+ * view fields. A `STAGE-…` column keeps the authored sketch copy.
+ *
+ * Pure: no I/O. The host (VS Code preview, JCEF, CLI) already owns loading
+ * canon/elements/** — this module only knows how to pick PROCESS / STEP
+ * records out of that pool.
+ *
+ * This is a read model, never storage. Callers render an ephemeral display
+ * copy and must never serialise it back onto the view.
+ */
+const PROCESS_ID_RE = /^PROCESS(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const STAGE_ID_RE = /^STAGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+export function isProcessColumnId(id) {
+    return PROCESS_ID_RE.test(id);
+}
+export function isStageColumnId(id) {
+    return STAGE_ID_RE.test(id);
+}
+function isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function optionalString(v) {
+    return typeof v === 'string' && v.trim().length > 0 ? v.trim() : undefined;
+}
+/**
+ * Collect admitted PROCESS elements from a raw canon/elements/** doc pool,
+ * keyed by id. Malformed documents are skipped.
+ */
+export function collectProcessColumnRecords(docs) {
+    const out = new Map();
+    for (const doc of docs) {
+        if (!isRecord(doc))
+            continue;
+        if (doc['notation'] !== 'process')
+            continue;
+        const id = optionalString(doc['id']);
+        if (!id || !isProcessColumnId(id))
+            continue;
+        const name = optionalString(doc['name']);
+        if (!name)
+            continue;
+        const rec = { name };
+        const goal = optionalString(doc['goal']);
+        const result = optionalString(doc['result']);
+        if (goal)
+            rec.goal = goal;
+        if (result)
+            rec.result = result;
+        out.set(id, rec);
+    }
+    return out;
+}
+/**
+ * Map each STEP id onto the PROCESS that contains it — either inline in
+ * `PROCESS.flow.steps[]` or a promoted `{ notation: step, process }` element.
+ * First writer wins; a later duplicate is ignored.
+ */
+export function collectStepHomeProcess(docs) {
+    const out = new Map();
+    for (const doc of docs) {
+        if (!isRecord(doc))
+            continue;
+        if (doc['notation'] === 'process') {
+            const processId = optionalString(doc['id']);
+            if (!processId || !isProcessColumnId(processId))
+                continue;
+            const flow = isRecord(doc['flow']) ? doc['flow'] : undefined;
+            const steps = flow && Array.isArray(flow['steps']) ? flow['steps'] : [];
+            for (const step of steps) {
+                if (!isRecord(step))
+                    continue;
+                const stepId = optionalString(step['id']);
+                if (!stepId || out.has(stepId))
+                    continue;
+                out.set(stepId, processId);
+            }
+            continue;
+        }
+        if (doc['notation'] === 'step') {
+            const stepId = optionalString(doc['id']);
+            const processId = optionalString(doc['process']);
+            if (!stepId || !processId || !isProcessColumnId(processId))
+                continue;
+            if (!out.has(stepId))
+                out.set(stepId, processId);
+        }
+    }
+    return out;
+}
+/**
+ * Display copy for one column. PROCESS- columns ignore any restated view
+ * fields; missing catalogue falls back to the id (header) and empty
+ * goal/result. STAGE- columns keep authored name/goal/result.
+ */
+export function resolveColumnDisplay(stage, catalog) {
+    const id = typeof stage.id === 'string' ? stage.id.trim() : '';
+    if (isProcessColumnId(id)) {
+        const rec = catalog?.get(id);
+        return {
+            name: rec?.name ?? id,
+            goal: rec?.goal ?? '',
+            result: rec?.result ?? '',
+        };
+    }
+    return {
+        name: typeof stage.name === 'string' ? stage.name : '',
+        goal: typeof stage.goal === 'string' ? stage.goal : '',
+        result: typeof stage.result === 'string' ? stage.result : '',
+    };
+}
+/**
+ * Column indexes a `realised_via` token pins on this blueprint.
+ *
+ * `STAGE-…` is never a join key (ASSERT-004). A `PROCESS-…` token pins that
+ * column. A STEP whose home process is a column pins that column.
+ */
+export function columnIndexesForRealisedVia(ref, stageIndexById, stepHomeProcess) {
+    const token = ref.trim();
+    if (token.length === 0)
+        return [];
+    if (isStageColumnId(token))
+        return [];
+    const direct = stageIndexById.get(token);
+    if (direct !== undefined && isProcessColumnId(token))
+        return [direct];
+    const home = stepHomeProcess?.get(token);
+    if (home && isProcessColumnId(home)) {
+        const idx = stageIndexById.get(home);
+        if (idx !== undefined)
+            return [idx];
+    }
+    return [];
+}

package/dist/process-blueprint/types.d.ts

@@ -27,8 +27,9 @@ export interface ComplianceLaneAssertion {
     /** Compliance realisation status. */
     status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | 'pending_owner' | 'n_a';
     /**
-     * Typed IDs of stages / process steps where the requirement is realised.
-     * When empty/absent, the assertion covers the entire subject, not a specific stage.
+     * Typed IDs of processes or steps where the requirement is realised.
+     * Sketch `STAGE-…` ids are not a join key. When empty/absent, the assertion
+     * covers the entire subject, not a specific column.
      */
     realised_via?: string[];
 }
@@ -89,9 +90,12 @@ export interface ComplianceRow {
 }
 export interface Stage {
     id: string;
-    name: string;
-    goal: string;
-    result: string;
+    /** Required on `STAGE-…` sketch columns (`BP-005`); omitted on `PROCESS-…`. */
+    name?: string;
+    /** Required on `STAGE-…` sketch columns (`BP-005`); omitted on `PROCESS-…`. */
+    goal?: string;
+    /** Required on `STAGE-…` sketch columns (`BP-005`); omitted on `PROCESS-…`. */
+    result?: string;
     description?: string;
 }
 export interface AspectEntry {
@@ -188,6 +192,20 @@ export interface ProcessBlueprintLayoutOptions {
      * When absent, all stages are shown.
      */
     visibleStages?: string[];
+    /**
+     * Catalogue of `PROCESS-…` column records (id → name / optional goal / result).
+     * Required to header catalogued columns; ignored for `STAGE-…` sketches.
+     */
+    processCatalog?: ReadonlyMap<string, {
+        name: string;
+        goal?: string;
+        result?: string;
+    }>;
+    /**
+     * STEP id → home PROCESS id (contained in `PROCESS.flow` or promoted).
+     * Used by the compliance-lane join; omit to skip STEP-level pins.
+     */
+    stepHomeProcess?: ReadonlyMap<string, string>;
 }
 import type { LayoutBounds } from '../geometry.js';
 export type { LayoutBounds };

package/dist/process-blueprint/validate.d.ts

@@ -1,3 +1,21 @@
 import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
+import type { CanonCatalog } from '../typed-id.js';
 export type { ValidationError, ValidationWarning, ValidationResult };
-export declare function validateProcessBlueprint(input: unknown): ValidationResult;
+export interface ProcessParentEdge {
+    /** Child process id (`from`). */
+    from: string;
+    /** Parent process id (`to`). */
+    to: string;
+}
+export interface ProcessBlueprintValidateOptions {
+    /** When provided, BP-012 resolves `PROCESS-…` column ids against admitted canon. */
+    catalog?: CanonCatalog;
+    /**
+     * In-effect `process_parent` edges (child → parent). When provided, BP-014
+     * warns if `process_blueprint.process` is set and a `PROCESS-…` column has
+     * no such edge to that parent. Omit to skip BP-014 (file-scope without the
+     * relation catalogue).
+     */
+    processParentEdges?: readonly ProcessParentEdge[];
+}
+export declare function validateProcessBlueprint(input: unknown, options?: ProcessBlueprintValidateOptions): ValidationResult;

package/dist/process-blueprint/validate.js

@@ -1,13 +1,27 @@
 const ID_GRAMMAR_RE = /^[A-Z][A-Z_]*(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const PROCESS_BLUEPRINT_ID_RE = /^PROCESS_BLUEPRINT(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const STAGE_ID_RE = /^STAGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const PROCESS_ID_RE = /^PROCESS(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const APPLICATION_ID_RE = /^APPLICATION(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const ROLE_ID_RE = /^ROLE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const ASPECT_CATEGORIES = ['systems', 'actors', 'equipment', 'information_entities'];
+const RESTATED_COLUMN_FIELDS = ['name', 'goal', 'result'];
 function isNonEmptyString(v) {
     return typeof v === 'string' && v.trim().length > 0;
 }
-export function validateProcessBlueprint(input) {
+function isProcessColumnId(id) {
+    return PROCESS_ID_RE.test(id);
+}
+function isStageColumnId(id) {
+    return STAGE_ID_RE.test(id);
+}
+function isColumnId(id) {
+    return isStageColumnId(id) || isProcessColumnId(id);
+}
+function fieldIsPresent(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+export function validateProcessBlueprint(input, options = {}) {
     const errors = [];
     const warnings = [];
     if (!input || typeof input !== 'object') {
@@ -47,6 +61,7 @@ export function validateProcessBlueprint(input) {
         return { valid: false, errors, warnings };
     }
     const stageIds = new Set();
+    const processColumnIds = [];
     for (let i = 0; i < stagesRaw.length; i++) {
         const s = stagesRaw[i];
         const path = `stages[${i}]`;
@@ -55,31 +70,68 @@ export function validateProcessBlueprint(input) {
             continue;
         }
         if (!isNonEmptyString(s['id'])) {
-            errors.push({ code: 'BP-005', message: `${path}.id is required` });
+            errors.push({ code: 'BP-006', message: `${path}.id is required` });
+            continue;
+        }
+        const sid = s['id'].trim();
+        if (stageIds.has(sid)) {
+            errors.push({ code: 'BP-006', message: `Duplicate stage id: "${sid}"` });
         }
         else {
-            const sid = s['id'].trim();
-            if (stageIds.has(sid)) {
-                errors.push({ code: 'BP-006', message: `Duplicate stage id: "${sid}"` });
-            }
-            else {
-                stageIds.add(sid);
+            stageIds.add(sid);
+        }
+        if (!isColumnId(sid)) {
+            errors.push({
+                code: 'BP-006',
+                message: `${path}.id "${sid}" must match STAGE-[<middle>-]<INTEGER> or PROCESS-[<middle>-]<INTEGER>`,
+            });
+            continue;
+        }
+        if (isProcessColumnId(sid)) {
+            processColumnIds.push(sid);
+            for (const field of RESTATED_COLUMN_FIELDS) {
+                if (fieldIsPresent(s, field)) {
+                    errors.push({
+                        code: 'BP-013',
+                        message: `${path}.${field} must not be restated on a PROCESS-… column — derive it from the process element`,
+                    });
+                }
             }
-            if (!STAGE_ID_RE.test(sid)) {
-                errors.push({
-                    code: 'BP-006',
-                    message: `${path}.id "${sid}" must match STAGE-[<middle>-]<INTEGER>`,
-                });
+            if (options.catalog) {
+                const resolved = options.catalog.typeOf(sid);
+                if (resolved !== 'PROCESS') {
+                    errors.push({
+                        code: 'BP-012',
+                        message: `${path}.id "${sid}" must resolve to an admitted PROCESS element`,
+                    });
+                }
             }
         }
-        if (!isNonEmptyString(s['name'])) {
-            errors.push({ code: 'BP-005', message: `${path}.name is required` });
-        }
-        if (!isNonEmptyString(s['goal'])) {
-            errors.push({ code: 'BP-005', message: `${path}.goal is required` });
+        else {
+            if (!isNonEmptyString(s['name'])) {
+                errors.push({ code: 'BP-005', message: `${path}.name is required` });
+            }
+            if (!isNonEmptyString(s['goal'])) {
+                errors.push({ code: 'BP-005', message: `${path}.goal is required` });
+            }
+            if (!isNonEmptyString(s['result'])) {
+                errors.push({ code: 'BP-005', message: `${path}.result is required` });
+            }
         }
-        if (!isNonEmptyString(s['result'])) {
-            errors.push({ code: 'BP-005', message: `${path}.result is required` });
+    }
+    const parentProcess = isNonEmptyString(pb['process']) ? pb['process'].trim() : undefined;
+    if (parentProcess && options.processParentEdges && processColumnIds.length > 0) {
+        const linked = new Set(options.processParentEdges
+            .filter((e) => e.to === parentProcess)
+            .map((e) => e.from));
+        for (const child of processColumnIds) {
+            if (!linked.has(child)) {
+                warnings.push({
+                    code: 'BP-014',
+                    message: `Column "${child}" is a PROCESS-… id and process_blueprint.process is "${parentProcess}", ` +
+                        `but no in-effect process_parent REL links that column to that parent`,
+                });
+            }
         }
     }
     const usedStageIds = new Set();
@@ -105,7 +157,7 @@ export function validateProcessBlueprint(input) {
             if (!Array.isArray(entryStages) || entryStages.length === 0) {
                 errors.push({
                     code: 'BP-007',
-                    message: `${path}.stages must be a non-empty array of STAGE-… ids`,
+                    message: `${path}.stages must be a non-empty array of declared column ids`,
                 });
             }
             else {

package/dist/repo-validate/check-candidate-fields.d.ts

@@ -0,0 +1,6 @@
+import type { RepoFinding, RepoModelInput } from './types.js';
+/**
+ * `ADMIT-009` — a candidate-only field present on an admitted (`zone: canon`)
+ * element, of any TYPE. Appends findings; pure, deterministic order.
+ */
+export declare function checkCandidateFields(input: RepoModelInput, findings: RepoFinding[]): void;

package/dist/repo-validate/check-candidate-fields.js

@@ -0,0 +1,87 @@
+// Candidate-only fields on admitted canon — `ADMIT-009`.
+//
+// `ELEMENT_PRIMITIVES.md` §7.29 (methodology v3.6.0) states it normatively for
+// `RELEASE` and then generalises it to every TYPE:
+//
+//   > `RELEASE` has no `extraction_confidence` field — and neither does any
+//   > other canon element, of any TYPE. `extraction_confidence` is a review
+//   > flag on an ingest candidate (`candidate.extraction_confidence`,
+//   > vocabulary.yaml); it is surfaced in the review queue, drives
+//   > reviewer-authority routing (CONTRACT.md §6.2), and is never persisted
+//   > into canon. An admitted element carrying it is a defect in whatever
+//   > wrote it, not a precedent to follow.
+//
+// Nothing enforced that mechanically. The ingest pipeline that produces the
+// field lives in `methodology`'s `packages/ingest-cli` and only ever writes
+// *candidates*; admission into `canon/elements/**` happens in an adopter's own
+// tooling, which is `@transitrix/cli validate`'s side of the fence — so this is
+// where the rule has to bite.
+//
+// **Why the check keys on `zone`, not on the folder.** `extraction_confidence`
+// is legitimate on a candidate and meaningless — but not a defect — elsewhere;
+// only the *admitted* form is wrong. `zone: canon` is the admission marker
+// every standalone element carries (`ELEMENT_PRIMITIVES.md` §3, required
+// envelope field, `ELEM-001`), and it is the discriminator against the two
+// zones that may legitimately carry harvest metadata: `zone: field`, whose
+// provenance contract owns `source_quality` (CONTRACT.md §5/§11.2), and
+// `zone: codex`. Sidecars (`*.history.yaml`, `*.runstate.yaml`) carry no
+// `zone` and no `id`, so they fall out for free — the same "no id -> not an
+// element" split `docId` already makes for every sibling check in this folder.
+//
+// **Rule code.** Studio-authored as `ELEM-CANDIDATE-FIELD-001` (in the shape
+// methodology already uses for a named element-envelope rule outside the
+// numbered run — `ELEM-ALIAS-001`, `ELEM-FORMER-ID-001` — deliberately not
+// `ELEM-006`, since the numbered `ELEM-*` run is methodology's to extend and
+// squatting the next free number would collide with whatever it registers
+// there next). Renamed to `ADMIT-009` (transitrix/methodology#505, merged
+// 2026-08-19) now that methodology has registered a code of its own for
+// §7.29 — no functional change, this is that alias.
+import { docId } from './validate-repo.js';
+const PScope = 'repo';
+/**
+ * Fields that belong to an ingest candidate and are never persisted into
+ * canon. Each entry names the field and the provenance pattern that replaces
+ * it, so the finding points at the correct shape rather than only failing
+ * closed. One entry today; the list is the extension point if methodology
+ * closes another candidate-side field out of canon the same way.
+ */
+const CANDIDATE_ONLY_FIELDS = [
+    {
+        field: 'extraction_confidence',
+        instead: "cite the evidence through 'derived_from' (ELEMENT_PRIMITIVES.md §3) — " +
+            'an OBSERVATION or another Field/Codex artefact; the review flag stays on the ' +
+            'ingest candidate and is not carried across admission',
+    },
+];
+/** True when the doc is an admitted canon element — `zone: canon` per
+ *  `ELEMENT_PRIMITIVES.md` §3. Deliberately narrow: a doc with no `zone`
+ *  (a sidecar) or a non-canon zone (`field`, `codex`) is not admitted canon
+ *  and this rule says nothing about it. */
+function isAdmittedCanonElement(doc) {
+    return doc.data?.['zone'] === 'canon';
+}
+/**
+ * `ADMIT-009` — a candidate-only field present on an admitted (`zone: canon`)
+ * element, of any TYPE. Appends findings; pure, deterministic order.
+ */
+export function checkCandidateFields(input, findings) {
+    for (const doc of input.elements) {
+        if (!doc.data)
+            continue;
+        if (!isAdmittedCanonElement(doc))
+            continue;
+        const id = docId(doc) ?? '';
+        for (const { field, instead } of CANDIDATE_ONLY_FIELDS) {
+            if (doc.data[field] === undefined)
+                continue;
+            findings.push({
+                scope: PScope,
+                id,
+                ruleId: 'ADMIT-009',
+                message: `ADMIT-009: admitted element '${id || doc.path}' carries '${field}', ` +
+                    `which is an ingest-candidate review flag and is never persisted into canon ` +
+                    `(ELEMENT_PRIMITIVES.md §7.29). Remove it and ${instead}.`,
+            });
+        }
+    }
+}

package/dist/repo-validate/check-process-parent.d.ts

@@ -0,0 +1,8 @@
+import type { ProcessParentEdge } from '../process-blueprint/validate.js';
+import type { RepoFinding, RepoModelInput } from './types.js';
+/** Inclusive window: in effect at `asOf` iff valid_from ≤ asOf and (valid_to is null or asOf ≤ valid_to). */
+export declare function relationInEffectAt(data: Record<string, unknown>, asOf: string): boolean;
+export declare function todayIsoDate(now?: Date): string;
+/** In-effect `process_parent` edges (child → parent) among loaded REL files. */
+export declare function collectInEffectProcessParentEdges(input: RepoModelInput, asOf?: string): ProcessParentEdge[];
+export declare function checkProcessParentSemantics(input: RepoModelInput, findings: RepoFinding[]): void;

package/dist/repo-validate/check-process-parent.js

@@ -0,0 +1,172 @@
+// process_parent relation checks — 17-relations.md §3 / §5 (REL-007, REL-008)
+// and endpoint TYPE (PROCESS → PROCESS), plus the in-effect edge collector
+// that process-blueprint BP-014 consumes.
+//
+// REL-007 is single-file (from === to). REL-008 is cross-cutting over the
+// admitted process_parent graph and is a warning, parallel to REL-006.
+import { docId, endpointId } from './validate-repo.js';
+const PScope = 'repo';
+function isProcessNotation(n) {
+    return n === 'process';
+}
+function isoDate(value) {
+    return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}/.test(value) ? value.slice(0, 10) : undefined;
+}
+/** Inclusive window: in effect at `asOf` iff valid_from ≤ asOf and (valid_to is null or asOf ≤ valid_to). */
+export function relationInEffectAt(data, asOf) {
+    const from = isoDate(data['valid_from']);
+    if (from && from > asOf)
+        return false;
+    const to = data['valid_to'];
+    if (to === null || to === undefined)
+        return true;
+    const toDate = isoDate(to);
+    if (!toDate)
+        return true;
+    return asOf <= toDate;
+}
+export function todayIsoDate(now = new Date()) {
+    return now.toISOString().slice(0, 10);
+}
+/** In-effect `process_parent` edges (child → parent) among loaded REL files. */
+export function collectInEffectProcessParentEdges(input, asOf = todayIsoDate()) {
+    const edges = [];
+    for (const doc of input.relations) {
+        if (!doc.data)
+            continue;
+        if (doc.data['type'] !== 'process_parent')
+            continue;
+        if (!relationInEffectAt(doc.data, asOf))
+            continue;
+        const fromId = endpointId(doc.data['from']) ?? endpointId(doc.data['source']);
+        const toId = endpointId(doc.data['to']) ?? endpointId(doc.data['target']);
+        if (!fromId || !toId)
+            continue;
+        edges.push({ from: fromId, to: toId });
+    }
+    return edges;
+}
+function processParentRels(input) {
+    const out = [];
+    for (const doc of input.relations) {
+        if (!doc.data)
+            continue;
+        if (doc.data['type'] !== 'process_parent')
+            continue;
+        const fromId = endpointId(doc.data['from']) ?? endpointId(doc.data['source']);
+        const toId = endpointId(doc.data['to']) ?? endpointId(doc.data['target']);
+        if (!fromId || !toId)
+            continue;
+        out.push({ relId: docId(doc) ?? '', fromId, toId });
+    }
+    return out;
+}
+/** REL-007 — process_parent self-reference. */
+function checkSelfReference(rels, findings) {
+    for (const rel of rels) {
+        if (rel.fromId === rel.toId) {
+            findings.push({
+                scope: PScope,
+                id: rel.relId,
+                ruleId: 'REL-007',
+                message: `REL-007: process_parent relation '${rel.relId}' has from equal to to ('${rel.fromId}').`,
+            });
+        }
+    }
+}
+/** REL-008 — cycle in the process_parent graph (warning). */
+function checkCycle(rels, findings) {
+    const childrenOf = new Map();
+    const relByChildParent = new Map();
+    const nodes = new Set();
+    for (const rel of rels) {
+        if (rel.fromId === rel.toId)
+            continue;
+        nodes.add(rel.fromId);
+        nodes.add(rel.toId);
+        const list = childrenOf.get(rel.fromId);
+        if (list)
+            list.push(rel.toId);
+        else
+            childrenOf.set(rel.fromId, [rel.toId]);
+        relByChildParent.set(`${rel.fromId}\0${rel.toId}`, rel.relId);
+    }
+    const UNVISITED = 0;
+    const VISITING = 1;
+    const DONE = 2;
+    const state = new Map();
+    let hit;
+    function walk(id) {
+        const s = state.get(id) ?? UNVISITED;
+        if (s === DONE)
+            return false;
+        if (s === VISITING) {
+            hit = id;
+            return true;
+        }
+        state.set(id, VISITING);
+        for (const parent of childrenOf.get(id) ?? []) {
+            if (nodes.has(parent) && walk(parent))
+                return true;
+        }
+        state.set(id, DONE);
+        return false;
+    }
+    for (const id of nodes) {
+        if (walk(id))
+            break;
+    }
+    if (!hit)
+        return;
+    const relId = [...relByChildParent.entries()].find(([key]) => key.startsWith(`${hit}\0`))?.[1] ?? hit;
+    findings.push({
+        scope: PScope,
+        id: relId,
+        ruleId: 'REL-008',
+        severity: 'warning',
+        message: `REL-008: process_parent graph contains a cycle involving '${hit}'.`,
+    });
+}
+/**
+ * Endpoint TYPE for process_parent: both ends must be PROCESS when they
+ * resolve. Unknown endpoints stay with referential integrity; this pass only
+ * fires when the element exists and is the wrong notation.
+ */
+function checkEndpointTypes(input, rels, findings) {
+    const elementById = new Map();
+    for (const doc of input.elements) {
+        const id = docId(doc);
+        if (id && doc.data)
+            elementById.set(id, doc.data);
+    }
+    for (const rel of rels) {
+        const from = elementById.get(rel.fromId);
+        if (from && !isProcessNotation(from['notation'])) {
+            findings.push({
+                scope: PScope,
+                id: rel.relId,
+                ruleId: 'REL-002',
+                message: `Layer-semantics: '${rel.relId}' type 'process_parent' requires from to be ` +
+                    `PROCESS; got notation='${from['notation']}'.`,
+            });
+        }
+        const to = elementById.get(rel.toId);
+        if (to && !isProcessNotation(to['notation'])) {
+            findings.push({
+                scope: PScope,
+                id: rel.relId,
+                ruleId: 'REL-002',
+                message: `Layer-semantics: '${rel.relId}' type 'process_parent' requires to to be ` +
+                    `PROCESS; got notation='${to['notation']}'.`,
+            });
+        }
+    }
+}
+export function checkProcessParentSemantics(input, findings) {
+    const rels = processParentRels(input);
+    if (rels.length === 0)
+        return;
+    checkSelfReference(rels, findings);
+    checkCycle(rels, findings);
+    checkEndpointTypes(input, rels, findings);
+}

package/dist/repo-validate/index.d.ts

@@ -1,3 +1,4 @@
 export { validateRepoModel } from './validate-repo.js';
 export { resolveRepoModel } from './resolve-model.js';
+export { checkProcessParentSemantics, collectInEffectProcessParentEdges, todayIsoDate, } from './check-process-parent.js';
 export type { RepoDoc, RepoFinding, RepoModelInput, ResolvedElementRecord, ResolvedRelationRecord, ResolvedRepoModel } from './types.js';

package/dist/repo-validate/index.js

@@ -1,2 +1,3 @@
 export { validateRepoModel } from './validate-repo.js';
 export { resolveRepoModel } from './resolve-model.js';
+export { checkProcessParentSemantics, collectInEffectProcessParentEdges, todayIsoDate, } from './check-process-parent.js';

package/dist/repo-validate/validate-repo.js

@@ -29,6 +29,8 @@
 import { checkStrategyChainSemantics } from './check-strategy-chain.js';
 import { checkElementHygiene } from './check-element-hygiene.js';
 import { checkVersionedAttributes } from './check-versioned-attributes.js';
+import { checkCandidateFields } from './check-candidate-fields.js';
+import { checkProcessParentSemantics } from './check-process-parent.js';
 const PScope = 'repo';
 /** Statuses that, per lint.py's policy check, require an owner. */
 const OWNER_REQUIRED_STATUSES = new Set(['Active', 'Production']);
@@ -153,6 +155,7 @@ function checkReferentialIntegrity(input, findings) {
  *   realizes        — BUSINESS_SERVICE → CAPABILITY           (25-business-services.md)
  *   hosts           — NODE → TECHNOLOGY_SERVICE               (25-nodes.md / 26-technology-services.md)
  *   uses            — APPLICATION → TECHNOLOGY_SERVICE        (26-technology-services.md)
+ *   process_parent  — PROCESS → PROCESS (17-relations.md §3; REL-007/008)
  *
  * Implemented element checks:
  *   TSVC-003        — TECHNOLOGY_SERVICE.node must resolve to NODE notation
@@ -406,6 +409,7 @@ export function validateRepoModel(input) {
     checkAtomicity(input, findings);
     checkReferentialIntegrity(input, findings);
     checkLayerSemantics(input, findings);
+    checkProcessParentSemantics(input, findings);
     checkPolicy(input, findings);
     // Phase 7 — strategy-chain semantic rules ported from DSM's Go Validate*
     // functions (GOALS-010, ACT-006..009, FGCA-008..011).
@@ -415,5 +419,8 @@ export function validateRepoModel(input) {
     checkElementHygiene(input, findings);
     // Phase 9 — versioned-attribute sidecar rules (CONTRACT.md §9, VERSIONED-001..005).
     checkVersionedAttributes(input, findings);
+    // Phase 10 — candidate-only fields on admitted canon (ELEMENT_PRIMITIVES.md
+    // §7.29, ADMIT-009).
+    checkCandidateFields(input, findings);
     return findings;
 }