@transitrix/diagrams 1.8.13 → 1.8.19

package/dist/repo-validate/check-strategy-chain.js

@@ -0,0 +1,491 @@
+// Strategy-chain semantic checks — the error-severity subset of DSM's Go
+// `Validate*` functions (`api02/internal/importer/{goals,activities,fgca}.go`
+// in transitrix-dsm), ported onto the standalone-element repo shape
+// (`canon/elements/**`) that `validate --scope=repo` already loads, so DSM
+// can drop those Go functions without regressing the checks they enforce
+// today.
+//
+// Rule codes are DSM's own (`GOALS-010`, `ACT-006`..`009`, `FGCA-008`..`011`)
+// — not invented here — so DSM can map a CLI finding straight back onto its
+// import-log taxonomy (`RepoFinding.ruleId`).
+//
+// Scope — DSM's full rule set is now ported except GOALS-008 (see below).
+// `RepoFinding` grew a `severity` field precisely so DSM's warn-severity
+// rules could land without becoming blocking: every finding from before that
+// field existed stays implicitly `'error'` (`types.ts`), and the six rules
+// below set `severity: 'warning'` explicitly, matching DSM's own
+// 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-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
+// match the type's declared level") need the `goal_types[]` catalogue, which
+// lives on the goals-tree *view* (`canon/views/goals/**`,
+// notations/views/04-goals.md §5.2) — a zone this validator's `RepoModelInput`
+// does not load (only `canon/elements/**` and `canon/relations/**`, per
+// `validate-repo.ts`). There is no standalone-element-shape data this rule
+// could run against without the validator growing a third input zone — a
+// bigger architectural change than adapting a predicate to data already in
+// scope, unlike every other ported rule here. This is flagged for a
+// per-rule call: skip it (status quo) or scope a follow-up that loads
+// `canon/views/goals/**`'s `goal_types[]` into the repo-scope model.
+//
+// Ported (error-severity, blocking):
+//   GOALS-010 — GOAL `parent` chain contains a cycle.
+//   ACT-006   — ACTION `predecessors` graph contains a cycle.
+//   ACT-007   — ACTION lists itself as its own predecessor.
+//   ACT-008   — ACTION `start_date`/`end_date` unparseable, or end before start.
+//   ACT-009   — ACTION numeric field (`duration`/`duration_days`, `labor_cost`,
+//               `resources_cost`, `effort`, `score`) is negative.
+//   FGCA-008  — GOAL.factors references an undefined DRIVER.
+//   FGCA-009  — CHANGE.goals references an undefined GOAL.
+//   FGCA-010  — ACTION.delivers_changes references an undefined CHANGE.
+//   FGCA-011  — ACTION.goals references an undefined GOAL.
+//
+// Ported (warning-severity, advisory):
+//   GOALS-009 — GOAL.parent is set but does not resolve to a known GOAL (orphan).
+//   GOALS-011 — GOAL has no `parent` and `level` >= 1 (backlog).
+//   ACT-005   — ACTION.predecessors entry or ACTION.parent does not resolve
+//               to a known ACTION (orphan).
+//   FGCA-012  — a DRIVER is not referenced by any GOAL.factors (unreferenced).
+//   FGCA-013  — a GOAL is not referenced by any CHANGE.goals or ACTION.goals
+//               (unreferenced).
+//   FGCA-014  — a CHANGE is not referenced by any ACTION.delivers_changes
+//               (unreferenced).
+import { docId } from './validate-repo.js';
+const PScope = 'repo';
+function isGoalNotation(n) {
+    return n === 'goal';
+}
+function isActionNotation(n) {
+    // 'activity' is the deprecated pre-2026-06-25 alias (elements/24-action.md §5).
+    return n === 'action' || n === 'activity';
+}
+function isDriverNotation(n) {
+    // 'factor' is the pre-rename notation value (Factor -> Driver rename, in progress).
+    return n === 'driver' || n === 'factor';
+}
+function isChangeNotation(n) {
+    return n === 'change';
+}
+function readStringArray(data, key) {
+    const v = data[key];
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === 'string' && x.length > 0);
+}
+function readString(data, key) {
+    const v = data[key];
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function readFiniteNumber(data, key) {
+    const v = data[key];
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+function collectByNotation(elements, matches) {
+    const out = [];
+    for (const doc of elements) {
+        if (!doc.data)
+            continue;
+        if (!matches(doc.data['notation']))
+            continue;
+        const id = docId(doc);
+        if (!id)
+            continue;
+        out.push({ id, doc, data: doc.data });
+    }
+    return out;
+}
+/** DFS cycle detection over a single-parent edge (GOAL.parent), 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) {
+    const parentOf = new Map();
+    const known = new Set();
+    for (const g of goals) {
+        known.add(g.id);
+        parentOf.set(g.id, readString(g.data, 'parent'));
+    }
+    const UNVISITED = 0;
+    const VISITING = 1;
+    const DONE = 2;
+    const state = new Map();
+    function walk(id) {
+        const s = state.get(id) ?? UNVISITED;
+        if (s === DONE)
+            return undefined;
+        if (s === VISITING)
+            return id;
+        state.set(id, VISITING);
+        const parent = parentOf.get(id);
+        if (parent && known.has(parent)) {
+            const hit = walk(parent);
+            if (hit)
+                return hit;
+        }
+        state.set(id, DONE);
+        return undefined;
+    }
+    for (const g of goals) {
+        const hit = walk(g.id);
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+/** DFS cycle detection over a multi-predecessor edge list (ACTION.predecessors),
+ *  matching DSM's `findActivityCycle` (activities.go). Unresolved predecessors
+ *  are skipped, same rationale as `findParentCycle`. */
+function findPredecessorCycle(actions) {
+    const predsOf = new Map();
+    const known = new Set();
+    for (const a of actions) {
+        known.add(a.id);
+        predsOf.set(a.id, readStringArray(a.data, 'predecessors'));
+    }
+    const UNVISITED = 0;
+    const VISITING = 1;
+    const DONE = 2;
+    const state = new Map();
+    function walk(id) {
+        const s = state.get(id) ?? UNVISITED;
+        if (s === DONE)
+            return undefined;
+        if (s === VISITING)
+            return id;
+        state.set(id, VISITING);
+        for (const p of predsOf.get(id) ?? []) {
+            if (!known.has(p))
+                continue;
+            const hit = walk(p);
+            if (hit)
+                return hit;
+        }
+        state.set(id, DONE);
+        return undefined;
+    }
+    for (const a of actions) {
+        const hit = walk(a.id);
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+/** GOALS-010 — the GOAL `parent` chain must not contain a cycle. */
+function checkGoalParentCycle(goals, findings) {
+    const cyc = findParentCycle(goals);
+    if (cyc) {
+        findings.push({
+            scope: PScope,
+            id: cyc,
+            ruleId: 'GOALS-010',
+            message: `GOALS-010: parent chain contains a cycle involving goal '${cyc}'.`,
+        });
+    }
+}
+/** GOALS-009 / GOALS-011 — GOAL `parent` resolution (warning). Mirrors DSM's
+ *  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, findings) {
+    const knownIds = new Set(goals.map((g) => g.id));
+    for (const g of goals) {
+        const parent = readString(g.data, 'parent');
+        if (!parent) {
+            const level = readFiniteNumber(g.data, 'level');
+            if (level !== undefined && level >= 1) {
+                findings.push({
+                    scope: PScope,
+                    id: g.id,
+                    ruleId: 'GOALS-011',
+                    severity: 'warning',
+                    message: `GOALS-011: goal '${g.id}' (level ${level}) has no parent; treated as backlog until attached.`,
+                });
+            }
+            continue;
+        }
+        if (!knownIds.has(parent)) {
+            findings.push({
+                scope: PScope,
+                id: g.id,
+                ruleId: 'GOALS-009',
+                severity: 'warning',
+                message: `GOALS-009: goal '${g.id}' parent '${parent}' does not resolve to a known goal; treated as orphan.`,
+            });
+        }
+    }
+}
+/** ACT-007 — an ACTION cannot list itself as its own predecessor. */
+function checkActionSelfPredecessor(actions, findings) {
+    for (const a of actions) {
+        if (readStringArray(a.data, 'predecessors').includes(a.id)) {
+            findings.push({
+                scope: PScope,
+                id: a.id,
+                ruleId: 'ACT-007',
+                message: `ACT-007: action '${a.id}' lists itself as a predecessor.`,
+            });
+        }
+    }
+}
+/** ACT-006 — the ACTION `predecessors` graph must not contain a cycle. */
+function checkActionPredecessorCycle(actions, findings) {
+    const cyc = findPredecessorCycle(actions);
+    if (cyc) {
+        findings.push({
+            scope: PScope,
+            id: cyc,
+            ruleId: 'ACT-006',
+            message: `ACT-006: predecessor graph contains a cycle involving action '${cyc}'.`,
+        });
+    }
+}
+/** ACT-005 — an ACTION `predecessors` entry or `parent` that does not resolve
+ *  to a known ACTION is an orphan reference (warning — advisory in DSM, same
+ *  as the goal-parent orphan checks above). */
+function checkActionOrphanReferences(actions, findings) {
+    const knownIds = new Set(actions.map((a) => a.id));
+    for (const a of actions) {
+        for (const p of readStringArray(a.data, 'predecessors')) {
+            if (!knownIds.has(p)) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'ACT-005',
+                    severity: 'warning',
+                    message: `ACT-005: action '${a.id}' predecessor '${p}' does not resolve to a known action.`,
+                });
+            }
+        }
+        const parent = readString(a.data, 'parent');
+        if (parent && !knownIds.has(parent)) {
+            findings.push({
+                scope: PScope,
+                id: a.id,
+                ruleId: 'ACT-005',
+                severity: 'warning',
+                message: `ACT-005: action '${a.id}' parent '${parent}' does not resolve to a known action.`,
+            });
+        }
+    }
+}
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+/** Parse a strict ISO `YYYY-MM-DD` date, rejecting calendar-invalid dates
+ *  (e.g. `2026-02-30`) the way Go's `time.Parse(dateLayout, …)` does — a
+ *  regex match alone accepts those. Returns `undefined` when invalid. */
+function parseIsoDate(value) {
+    if (!ISO_DATE_RE.test(value))
+        return undefined;
+    const [y, m, d] = value.split('-').map(Number);
+    const dt = new Date(Date.UTC(y, m - 1, d));
+    if (dt.getUTCFullYear() !== y || dt.getUTCMonth() !== m - 1 || dt.getUTCDate() !== d) {
+        return undefined;
+    }
+    return dt;
+}
+/** ACT-008 — `start_date`/`end_date` must be valid ISO dates, and `end_date`
+ *  must not be before `start_date` (equal is allowed — e.g. a milestone). */
+function checkActionDates(actions, findings) {
+    for (const a of actions) {
+        const startRaw = readString(a.data, 'start_date');
+        const endRaw = readString(a.data, 'end_date');
+        let start;
+        let end;
+        if (startRaw !== undefined) {
+            start = parseIsoDate(startRaw);
+            if (!start) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'ACT-008',
+                    message: `ACT-008: action '${a.id}' start_date '${startRaw}' is not a valid YYYY-MM-DD date.`,
+                });
+            }
+        }
+        if (endRaw !== undefined) {
+            end = parseIsoDate(endRaw);
+            if (!end) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'ACT-008',
+                    message: `ACT-008: action '${a.id}' end_date '${endRaw}' is not a valid YYYY-MM-DD date.`,
+                });
+            }
+        }
+        if (start && end && end.getTime() < start.getTime()) {
+            findings.push({
+                scope: PScope,
+                id: a.id,
+                ruleId: 'ACT-008',
+                message: `ACT-008: action '${a.id}' end_date '${endRaw}' is before start_date '${startRaw}'.`,
+            });
+        }
+    }
+}
+/** ACT-009 — numeric scheduling/cost fields must not be negative. `duration`
+ *  and `duration_days` are both checked — the canonical field is `duration`
+ *  (elements/24-action.md §2), but `duration_days` is an accepted alias in
+ *  this codebase's document-form validator (activities/validate.ts) and is
+ *  the field acme_corp's own ACTION elements actually use. */
+function checkActionNegativeNumbers(actions, findings) {
+    const fields = ['duration', 'duration_days', 'labor_cost', 'resources_cost', 'effort', 'score'];
+    for (const a of actions) {
+        for (const field of fields) {
+            const v = readFiniteNumber(a.data, field);
+            if (v !== undefined && v < 0) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'ACT-009',
+                    message: `ACT-009: action '${a.id}' field '${field}' is negative (${v}).`,
+                });
+            }
+        }
+    }
+}
+/** FGCA-008..011 — inline strategy-chain cross-references must resolve within
+ *  the repo: GOAL.factors -> DRIVER, CHANGE.goals -> GOAL, ACTION.goals ->
+ *  GOAL, ACTION.delivers_changes -> CHANGE (ELEMENT_PRIMITIVES.md §7.1-§7.4). */
+function checkStrategyChainReferences(goals, actions, drivers, changes, findings) {
+    const driverIds = new Set(drivers.map((d) => d.id));
+    const goalIds = new Set(goals.map((g) => g.id));
+    const changeIds = new Set(changes.map((c) => c.id));
+    for (const g of goals) {
+        for (const f of readStringArray(g.data, 'factors')) {
+            if (!driverIds.has(f)) {
+                findings.push({
+                    scope: PScope,
+                    id: g.id,
+                    ruleId: 'FGCA-008',
+                    message: `FGCA-008: goal '${g.id}' references undefined driver '${f}'.`,
+                });
+            }
+        }
+    }
+    for (const c of changes) {
+        for (const g of readStringArray(c.data, 'goals')) {
+            if (!goalIds.has(g)) {
+                findings.push({
+                    scope: PScope,
+                    id: c.id,
+                    ruleId: 'FGCA-009',
+                    message: `FGCA-009: change '${c.id}' references undefined goal '${g}'.`,
+                });
+            }
+        }
+    }
+    for (const a of actions) {
+        for (const c of readStringArray(a.data, 'delivers_changes')) {
+            if (!changeIds.has(c)) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'FGCA-010',
+                    message: `FGCA-010: action '${a.id}' references undefined change '${c}'.`,
+                });
+            }
+        }
+        for (const g of readStringArray(a.data, 'goals')) {
+            if (!goalIds.has(g)) {
+                findings.push({
+                    scope: PScope,
+                    id: a.id,
+                    ruleId: 'FGCA-011',
+                    message: `FGCA-011: action '${a.id}' references undefined goal '${g}'.`,
+                });
+            }
+        }
+    }
+}
+/** FGCA-012..014 — a DRIVER/GOAL/CHANGE defined but never referenced
+ *  downstream in the strategy chain is unreferenced (warning — advisory in
+ *  DSM, mirroring the orphan-reference checks above). */
+function checkStrategyChainOrphans(goals, actions, drivers, changes, findings) {
+    const referencedDrivers = new Set();
+    for (const g of goals) {
+        for (const f of readStringArray(g.data, 'factors'))
+            referencedDrivers.add(f);
+    }
+    for (const d of drivers) {
+        if (!referencedDrivers.has(d.id)) {
+            findings.push({
+                scope: PScope,
+                id: d.id,
+                ruleId: 'FGCA-012',
+                severity: 'warning',
+                message: `FGCA-012: driver '${d.id}' is not referenced by any goal.`,
+            });
+        }
+    }
+    const referencedGoals = new Set();
+    for (const c of changes) {
+        for (const g of readStringArray(c.data, 'goals'))
+            referencedGoals.add(g);
+    }
+    for (const a of actions) {
+        for (const g of readStringArray(a.data, 'goals'))
+            referencedGoals.add(g);
+    }
+    for (const g of goals) {
+        if (!referencedGoals.has(g.id)) {
+            findings.push({
+                scope: PScope,
+                id: g.id,
+                ruleId: 'FGCA-013',
+                severity: 'warning',
+                message: `FGCA-013: goal '${g.id}' is not referenced by any change or action.`,
+            });
+        }
+    }
+    const referencedChanges = new Set();
+    for (const a of actions) {
+        for (const c of readStringArray(a.data, 'delivers_changes'))
+            referencedChanges.add(c);
+    }
+    for (const c of changes) {
+        if (!referencedChanges.has(c.id)) {
+            findings.push({
+                scope: PScope,
+                id: c.id,
+                ruleId: 'FGCA-014',
+                severity: 'warning',
+                message: `FGCA-014: change '${c.id}' is not referenced by any action.`,
+            });
+        }
+    }
+}
+/**
+ * Run the strategy-chain semantic checks (GOALS-009..011, ACT-005..009,
+ * FGCA-008..014 except GOALS-008 — see the module header) over the loaded
+ * element set and append findings. Called from `validateRepoModel` after the
+ * structural phases. Pure, deterministic order.
+ */
+export function checkStrategyChainSemantics(input, findings) {
+    const goals = collectByNotation(input.elements, isGoalNotation);
+    const actions = collectByNotation(input.elements, isActionNotation);
+    const drivers = collectByNotation(input.elements, isDriverNotation);
+    const changes = collectByNotation(input.elements, isChangeNotation);
+    checkGoalParentCycle(goals, findings);
+    checkGoalParentResolution(goals, findings);
+    checkActionSelfPredecessor(actions, findings);
+    checkActionPredecessorCycle(actions, findings);
+    checkActionOrphanReferences(actions, findings);
+    checkActionDates(actions, findings);
+    checkActionNegativeNumbers(actions, findings);
+    checkStrategyChainReferences(goals, actions, drivers, changes, findings);
+    checkStrategyChainOrphans(goals, actions, drivers, changes, findings);
+}

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

@@ -1,4 +1,4 @@
-/** A single repo-scope validation finding. Shape is frozen at `{ scope, id, message }`. */
+/** A single repo-scope validation finding. */
 export interface RepoFinding {
     /** Always `'repo'` — the execution axis this finding came from. */
     scope: 'repo';
@@ -9,6 +9,19 @@ export interface RepoFinding {
     id: string;
     /** Human-readable description of the violation. */
     message: string;
+    /**
+     * Stable rule code (e.g. `GOALS-010`, `ACT-006`, `FGCA-008`), for a consumer
+     * that maps findings onto its own rule taxonomy (`docs/validation.md`).
+     * Omitted for checks that don't yet have one.
+     */
+    ruleId?: string;
+    /**
+     * `'error'` (blocking) or `'warning'` (advisory). Omitted is equivalent to
+     * `'error'` — every check that predates this field never sets it and must
+     * stay blocking. Only the warn-severity strategy-chain rules set this to
+     * `'warning'` today (`docs/validation.md` § repo-scope rule list).
+     */
+    severity?: 'error' | 'warning';
 }
 /** A parsed canon document fed to the repo validator. IO (the filesystem walk)
  *  lives in the CLI; the validator itself stays pure and testable. */

package/dist/repo-validate/types.js

@@ -7,7 +7,26 @@
 // runtime (methodology ADR "Validation Two-Axis Model"; Studio decision
 // "Validation Runtime Convergence").
 //
-// The finding shape is deliberately minimal — `{ scope, id, message }`. The
-// richer `target` / `category` reporting taxonomy is explicitly DEFERRED per the
-// ADR until a real consumer needs it; do not add it here.
+// The finding shape was originally frozen minimal — `{ scope, id, message }` —
+// with the richer `target` / `category` reporting taxonomy explicitly DEFERRED
+// per the ADR until a real consumer needed it. This un-freezes one field,
+// `ruleId`: DSM (migrating off its own Go `Validate*` functions) needs a
+// stable code per finding to map onto its existing import-log rule taxonomy
+// (`api02/internal/importer/{goals,activities,fgca}.go`). The richer
+// `target`/`category` taxonomy stays deferred — only `ruleId` is added.
+// `ruleId` is optional: only checks with a stable, documented code set it
+// (`docs/validation.md` § repo-scope rule list); the original structural
+// checks (syntax/uniqueness/atomicity/referential-integrity/policy) stay
+// uncoded rather than being retrofitted with invented codes.
+//
+// A second field, `severity`, is un-frozen for the same reason: DSM's
+// warn-severity strategy-chain rules (GOALS-009/011, ACT-005, FGCA-012..014
+// — see check-strategy-chain.ts) are non-fatal by
+// DSM's own taxonomy ("import anyway, record the warning"); without a
+// severity field, porting them here would silently make them blocking,
+// since every existing repo-scope finding is implicitly blocking. `severity`
+// is optional and defaults to `'error'` when omitted — every finding from
+// before this field existed (syntax/uniqueness/atomicity/referential-
+// integrity/policy, plus the error-tier strategy-chain rules and
+// TSVC-003/INT-002) stays blocking with no code change at the call site.
 export {};

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

@@ -12,7 +12,8 @@ export declare function endpointId(value: unknown): string | null;
 /**
  * Run all repo-scope checks over a loaded canon model and return the findings.
  * Pure: no IO, deterministic order (syntax, uniqueness, atomicity, referential,
- * semantics, policy). Reaches parity with `lint.py` on the `acme_corp` fixture
- * (zero findings on a clean tree).
+ * semantics, policy, strategy-chain). Reaches parity with `lint.py` on the
+ * `acme_corp` fixture (zero findings on a clean tree from the original
+ * lint.py-ported phases).
  */
 export declare function validateRepoModel(input: RepoModelInput): RepoFinding[];

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

@@ -23,8 +23,11 @@
 //   6. Policy             (phase 6) — element marked Active/Production with no
 //                                     owner.
 //
-// Findings stay `{ scope, id, message }` — no severity, no target/category
-// taxonomy (deferred per the ADR).
+// Findings stay `{ scope, id, message }` plus the two un-frozen optional
+// fields `ruleId` and `severity` — the richer target/category taxonomy stays
+// deferred per the ADR.
+import { checkStrategyChainSemantics } from './check-strategy-chain.js';
+import { checkElementHygiene } from './check-element-hygiene.js';
 const PScope = 'repo';
 /** Statuses that, per lint.py's policy check, require an owner. */
 const OWNER_REQUIRED_STATUSES = new Set(['Active', 'Production']);
@@ -330,6 +333,7 @@ function checkLayerSemantics(input, findings) {
             findings.push({
                 scope: PScope,
                 id: svcId,
+                ruleId: 'TSVC-003',
                 message: `TSVC-003: TECHNOLOGY_SERVICE '${svcId}' node '${nodeRef}' ` +
                     `must resolve to a NODE element; got notation='${resolved['notation']}'.`,
             });
@@ -354,6 +358,7 @@ function checkLayerSemantics(input, findings) {
                 findings.push({
                     scope: PScope,
                     id: intId,
+                    ruleId: 'INT-002',
                     message: `INT-002: INTEGRATION '${intId}' interface_semantics endpoint '${endpointId}' ` +
                         `(${field}) must resolve to an APPLICATION element; got notation='${resolved['notation']}'.`,
                 });
@@ -384,8 +389,9 @@ function checkPolicy(input, findings) {
 /**
  * Run all repo-scope checks over a loaded canon model and return the findings.
  * Pure: no IO, deterministic order (syntax, uniqueness, atomicity, referential,
- * semantics, policy). Reaches parity with `lint.py` on the `acme_corp` fixture
- * (zero findings on a clean tree).
+ * semantics, policy, strategy-chain). Reaches parity with `lint.py` on the
+ * `acme_corp` fixture (zero findings on a clean tree from the original
+ * lint.py-ported phases).
  */
 export function validateRepoModel(input) {
     const findings = [];
@@ -400,5 +406,11 @@ export function validateRepoModel(input) {
     checkReferentialIntegrity(input, findings);
     checkLayerSemantics(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).
+    checkStrategyChainSemantics(input, findings);
+    // Phase 8 — standalone-element envelope rules ported from DSM's Go
+    // Validate*Element functions (GOAL-ELEM-001..003, ACTION-001/002/005).
+    checkElementHygiene(input, findings);
     return findings;
 }

package/dist/webview/render-activities.d.ts

@@ -10,6 +10,15 @@ import { type NodeSizePreset } from '../node-size-presets.js';
 export declare const ACTIVITIES_NETWORK_CSS = "\n  .act-node { fill: var(--ts-layer-activity, #d4edda); stroke: var(--ts-node-stroke, #004d67); stroke-width: 1; }\n  .critical-node { fill: var(--ts-brand-orange-tint, #ffeee5); stroke: var(--ts-brand-orange, #ff4d00); stroke-width: 1; }\n  .milestone-node { fill: #ecfeff; stroke: var(--ts-text-muted, #64748b); stroke-dasharray: 4 2; }\n  .critical-edge { stroke: var(--ts-brand-orange, #ff4d00); stroke-width: 1.5; }\n  .arrow-fill-critical { fill: var(--ts-brand-orange, #ff4d00); }\n";
 /** Arrowhead marker defs shared by both hosts for the network view. */
 export declare const ACTIVITIES_NETWORK_DEFS = "<defs>\n  <marker id=\"arrow\" markerWidth=\"8\" markerHeight=\"8\" refX=\"8\" refY=\"3\" orient=\"auto\">\n    <path d=\"M0,0 L0,6 L8,3 z\" class=\"arrow-fill\"/>\n  </marker>\n  <marker id=\"arrow-crit\" markerWidth=\"8\" markerHeight=\"8\" refX=\"8\" refY=\"3\" orient=\"auto\">\n    <path d=\"M0,0 L0,6 L8,3 z\" class=\"arrow-fill-critical\"/>\n  </marker>\n</defs>";
+/**
+ * Extra top padding (px) a network-view canvas must add so skip-edge bows
+ * (see `blockingNodes`/`bowY` above) never draw above the SVG's y=0 and get
+ * clipped. `oyBase` is the canvas's Y offset *before* this padding — the
+ * historical `-bounds.y + N_PAD + titleH` both hosts compute — since a bow
+ * near the topmost row can reach above the diagram's own node bounds.
+ * Callers add the returned value to both `oyBase` and the canvas height.
+ */
+export declare function computeNetworkTopPad(layout: ActivitiesLayout, oyBase: number): number;
 /**
  * Canonical Network (PSND) body — the node rects and edge paths that go inside
  * the `<svg>`, shared verbatim by the VS Code preview and the host-neutral