@transitrix/diagrams 1.14.0-rc.0 → 1.15.0

package/dist/scenarios/validate.js

@@ -24,6 +24,10 @@ export function validateScenario(input) {
     }
     if (errors.length > 0)
         return { valid: false, errors, warnings };
+    if (('view_config' in raw || 'view' in raw || 'scenarios' in raw) && !('scenario' in raw)) {
+        return { valid: true, errors, warnings: [{ code: 'NOTATION-SKIP-001',
+                    message: 'scenarios projection or scenario-set form is unsupported and remains unvalidated.' }] };
+    }
     const scn = raw['scenario'];
     if (!scn || typeof scn !== 'object') {
         errors.push({ code: 'SCN-002', message: 'Missing required field: scenario' });

package/dist/schema-finding.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationError } from './validation-types.js';
+/** Shared schema identity; callers supply the owning form and exact field. */
+export declare function schemaFinding(form: string, path: string, expected: string, actual: unknown): ValidationError;

package/dist/schema-finding.js

@@ -0,0 +1,6 @@
+/** Shared schema identity; callers supply the owning form and exact field. */
+export function schemaFinding(form, path, expected, actual) {
+    const type = actual === null ? 'null' : Array.isArray(actual) ? 'array' : typeof actual;
+    return { code: 'SCHEMA_INVALID', path,
+        message: `${form} field '${path}': expected ${expected}; actual ${type} (${String(actual)}).` };
+}

package/dist/standalone/history.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationResult } from '../validation-types.js';
+import { type StandaloneOptions } from './validate.js';
+export declare function validateHistory(input: unknown, options?: StandaloneOptions): ValidationResult;

package/dist/standalone/history.js

@@ -0,0 +1,67 @@
+import { mapping, isoDate } from './validate.js';
+import { validateAttributeArray } from '../versioned-attribute/validate.js';
+import { isCanonicalIdOfType } from '../typed-id.js';
+export function validateHistory(input, options = {}) {
+    const errors = [], warnings = [];
+    const fail = (field, expected, actual, code = 'SCHEMA_INVALID') => errors.push({ code, message: `history sidecar: ${field}: expected ${expected}; actual ${JSON.stringify(actual) ?? 'missing'}.`, path: field });
+    if (!mapping(input)) {
+        fail('$', 'mapping', input);
+        return { valid: false, errors, warnings };
+    }
+    const d = input;
+    if (typeof d.target !== 'string' || !d.target.trim())
+        fail('target', 'canonical target ID', d.target, 'VERSIONED-001');
+    const target = typeof d.target === 'string' ? options.documents?.get(d.target) : undefined;
+    if (options.documents && (!target || !options.catalog?.typeOf(d.target)))
+        fail('target', 'admitted primitive', d.target, 'VERSIONED-001');
+    const notation = target?.notation;
+    const attributes = { capability: ['current_maturity', 'target_maturity', 'target_date', 'owner_role'], application: ['maturity', 'vendor', 'owner_role'] };
+    const allowed = typeof notation === 'string' ? attributes[notation] : undefined;
+    if (!allowed)
+        warnings.push({ code: 'NOTATION-SKIP-001', message: 'History target schema is unavailable; attribute coverage remains unvalidated.' });
+    if (!mapping(d.attribute_versions))
+        fail('attribute_versions', 'mapping', d.attribute_versions);
+    else
+        for (const [attribute, entries] of Object.entries(d.attribute_versions)) {
+            const field = `attribute_versions.${attribute}`;
+            if (allowed && !allowed.includes(attribute))
+                fail(field, 'declared time_varying attribute', attribute);
+            if (!Array.isArray(entries)) {
+                fail(field, 'array', entries);
+                continue;
+            }
+            const checked = [];
+            for (const [i, entry] of entries.entries()) {
+                const key = `${field}[${i}]`;
+                if (!mapping(entry)) {
+                    fail(key, 'mapping', entry);
+                    continue;
+                }
+                if (!isoDate(entry.valid_from))
+                    fail(`${key}.valid_from`, 'ISO calendar date', entry.valid_from);
+                const value = entry.value;
+                const scalar = value === null || ['string', 'number', 'boolean'].includes(typeof value);
+                if (!('value' in entry) || !scalar)
+                    fail(`${key}.value`, 'scalar or null', value);
+                if (scalar && isoDate(entry.valid_from))
+                    checked.push({ valid_from: entry.valid_from, value: value });
+                if (value === null || !allowed?.includes(attribute))
+                    continue;
+                if (['current_maturity', 'target_maturity', 'maturity'].includes(attribute) && !(Number.isInteger(value) && Number(value) >= 1 && Number(value) <= 5))
+                    fail(`${key}.value`, 'integer 1..5 or null', value);
+                if (attribute === 'target_date' && !isoDate(value))
+                    fail(`${key}.value`, 'ISO calendar date or null', value);
+                if (attribute === 'vendor' && typeof value !== 'string')
+                    fail(`${key}.value`, 'string or null', value);
+                if (attribute === 'owner_role' && (!isCanonicalIdOfType(value, 'ROLE') || (options.catalog && options.catalog.typeOf(value) !== 'ROLE')))
+                    fail(`${key}.value`, 'admitted ROLE reference or null', value);
+            }
+            for (const finding of validateAttributeArray(attribute, checked, typeof target?.valid_from === 'string' ? target.valid_from : undefined, target?.valid_to === null || typeof target?.valid_to === 'string' ? target.valid_to : undefined)) {
+                (finding.severity === 'error' ? errors : warnings).push({ code: finding.code, message: finding.message });
+            }
+        }
+    for (const key of ['notation', 'id', 'zone', 'admitted_at', 'admitted_by', 'valid_from', 'valid_to'])
+        if (key in d)
+            fail(key, 'absent on headerless history sidecar', d[key]);
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/standalone/validate.d.ts

@@ -0,0 +1,9 @@
+import { type CanonCatalog } from '../typed-id.js';
+import type { ValidationResult } from '../validation-types.js';
+export declare const mapping: (v: unknown) => v is Record<string, unknown>;
+export declare const isoDate: (v: unknown) => v is string;
+export interface StandaloneOptions {
+    catalog?: CanonCatalog;
+    documents?: ReadonlyMap<string, Record<string, unknown>>;
+}
+export declare function validateStandalone(notation: string, input: unknown, options?: StandaloneOptions): ValidationResult;

package/dist/standalone/validate.js

@@ -0,0 +1,146 @@
+// Standalone forms from ELEMENT_PRIMITIVES and CONTRACT (Methodology 7).
+// Field payloads are opaque: only their published identity/admission contract is checked.
+import { isCanonicalIdOfType, typeOfId } from '../typed-id.js';
+export const mapping = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const text = (v) => typeof v === 'string' && v.trim().length > 0;
+export const isoDate = (v) => typeof v === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(v) && Number.isFinite(Date.parse(v)) && new Date(v).toISOString().slice(0, 10) === v;
+const capabilityId = (v) => typeof v === 'string' && /^CAPABILITY-[VH][1-9]\d*(?:\.[1-9]\d*)*$/.test(v);
+export function validateStandalone(notation, input, options = {}) {
+    const errors = [], warnings = [];
+    const fail = (field, expected, actual, code = 'SCHEMA_INVALID') => errors.push({ code, message: `${notation} standalone: ${field}: expected ${expected}; actual ${JSON.stringify(actual) ?? 'missing'}.`, path: field });
+    if (!mapping(input)) {
+        fail('$', 'mapping', input);
+        return { valid: false, errors, warnings };
+    }
+    const d = input, field = ['draft', 'observation'].includes(notation);
+    const requiredText = (key) => { if (!text(d[key]))
+        fail(key, 'nonempty string', d[key]); };
+    const optionalText = (key) => { if (key in d && !text(d[key]))
+        fail(key, 'nonempty string', d[key]); };
+    if (d.notation !== notation && !(field && d.notation === undefined && d.type === notation.toUpperCase()))
+        fail('notation', notation, d.notation);
+    if (!(notation === 'capability' ? capabilityId(d.id) : isCanonicalIdOfType(d.id, notation.toUpperCase())))
+        fail('id', `${notation.toUpperCase()} canonical ID`, d.id);
+    if (!field)
+        requiredText('name');
+    else
+        optionalText('name');
+    if (d.zone !== (field ? 'field' : 'canon'))
+        fail('zone', field ? 'field' : 'canon', d.zone);
+    requiredText('admitted_by');
+    if (!isoDate(d.admitted_at))
+        fail('admitted_at', 'ISO calendar date', d.admitted_at);
+    if (!mapping(d.gate_checks))
+        fail('gate_checks', 'mapping', d.gate_checks);
+    else
+        for (const key of field ? ['provenance'] : ['uniqueness', 'consistency', 'completeness']) {
+            if (!text(d.gate_checks[key]))
+                fail(`gate_checks.${key}`, 'nonempty check outcome', d.gate_checks[key]);
+        }
+    if (!field) {
+        if (!isoDate(d.valid_from))
+            fail('valid_from', 'ISO calendar date', d.valid_from, 'LIFECYCLE-001');
+        if (!(d.valid_to === null || isoDate(d.valid_to)))
+            fail('valid_to', 'ISO calendar date or null', d.valid_to, 'LIFECYCLE-002');
+        if (isoDate(d.valid_from) && isoDate(d.valid_to) && d.valid_to < d.valid_from)
+            fail('valid_to', 'date on or after valid_from', d.valid_to, 'LIFECYCLE-003');
+    }
+    const ref = (key, value, types) => {
+        const type = typeOfId(value);
+        if (!type || !types.includes(type) || !(type === 'CAPABILITY' ? capabilityId(value) : isCanonicalIdOfType(value, type))) {
+            fail(key, types.join('|') + ' canonical reference', value);
+            return;
+        }
+        if (options.catalog && !types.includes(options.catalog.typeOf(value) ?? ''))
+            fail(key, 'reference to admitted ' + types.join('|'), value);
+    };
+    const reference = (key, types, required = false) => { if (required || key in d)
+        ref(key, d[key], types); };
+    const references = (key, types, required = false) => {
+        if (!required && !(key in d))
+            return;
+        const values = d[key];
+        if (!Array.isArray(values) || (required && values.length === 0)) {
+            fail(key, required ? 'nonempty list of references' : 'list of references', values);
+            return;
+        }
+        values.forEach((v, i) => ref(`${key}[${i}]`, v, types));
+    };
+    optionalText('description');
+    if (notation === 'product') {
+        if (!['digital_product', 'service', 'platform', 'bundle'].includes(d.type))
+            fail('type', '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 === 'capability') {
+        if (!['domain', 'supporting'].includes(d.type))
+            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');
+        reference('business_process', ['PROCESS']);
+        references('applications', ['APPLICATION']);
+    }
+    else if (notation === 'role') {
+        optionalText('responsibility_area');
+        reference('unit', ['ACTOR']);
+        const unit = typeof d.unit === 'string' ? options.documents?.get(d.unit) : undefined;
+        if (unit && unit.type !== 'business_unit')
+            fail('unit', 'ACTOR of type business_unit', d.unit);
+    }
+    else if (notation === 'assessment') {
+        requiredText('description');
+        reference('assesses', ['DRIVER', 'FACTOR'], true);
+        for (const key of ['method', 'source'])
+            optionalText(key);
+        if ('observed_at' in d && !isoDate(d.observed_at))
+            fail('observed_at', 'ISO calendar date', d.observed_at);
+        for (const key of ['polarity', 'swot', 'type'])
+            if (key in d)
+                fail(key, 'absent on assessment', d[key]);
+        if ('geographic_scope' in d) {
+            const values = d.geographic_scope;
+            // Country vocabulary is checked by the shared jurisdiction set below.
+            if (!Array.isArray(values) || !values.length || values.some(v => typeof v !== 'string' || !COUNTRIES.has(v.toLowerCase())) || (values.some(v => typeof v === 'string' && v.toLowerCase() === 'global') && values.length !== 1))
+                fail('geographic_scope', 'nonempty ISO country/eu list, or [global]', values, 'ASSESS-001');
+        }
+    }
+    else if (notation === 'scenario') {
+        references('pursues', ['GOAL'], true);
+        reference('arrives_at', ['TARGET_STATE'], true);
+        references('steps', ['ACTION', 'CHANGE'], true);
+        const target = typeof d.arrives_at === 'string' ? options.documents?.get(d.arrives_at) : undefined;
+        if (target?.type === 'base')
+            fail('arrives_at', 'target plateau, not base', d.arrives_at);
+        for (const key of ['type', 'vision', 'factors_view', 'status', 'drivers', 'capabilities', 'processes', 'applications', 'products'])
+            if (key in d)
+                fail(key, 'absent on standalone scenario', d[key]);
+        optionalText('link');
+    }
+    else if (field) {
+        const provenance = d.provenance;
+        if (provenance === undefined || provenance === null || (typeof provenance === 'string' && !provenance.trim()) || (mapping(provenance) && Object.keys(provenance).length === 0))
+            fail('provenance', 'recorded source evidence', provenance);
+        else if (!mapping(provenance))
+            warnings.push({ code: 'NOTATION-SKIP-001', message: 'Field provenance form is unsupported; source evidence remains unvalidated.' });
+        else {
+            // Two supported evidence forms: captured source and versioned source import.
+            // Other forms remain visible as unsupported, not falsely validated or forbidden.
+            const captured = text(provenance.captured_by) && isoDate(provenance.captured_on) && text(provenance.setting);
+            const imported = text(provenance.source_revision) && text(provenance.original_path) && text(provenance.source_hash) && isoDate(provenance.captured_on);
+            if (!captured && !imported)
+                warnings.push({ code: 'NOTATION-SKIP-001', message: 'Field provenance form is unsupported: source, capture date and context cannot all be checked.' });
+        }
+        if ('source_quality' in d && !['authoritative', 'corroborated', 'single_source', 'unverified'].includes(d.source_quality))
+            fail('source_quality', 'authoritative|corroborated|single_source|unverified', d.source_quality);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+// ISO 3166-1 alpha-2 vocabulary, plus the published eu/global scope tokens.
+const COUNTRIES = new Set(('ad ae af ag ai al am ao aq ar as at au aw ax az ba bb bd be bf bg bh bi bj bl bm bn bo bq br bs bt bv bw by bz ca cc cd cf cg ch ci ck cl cm cn co cr cu cv cw cx cy cz de dj dk dm do dz ec ee eg eh er es et fi fj fk fm fo fr ga gb gd ge gf gg gh gi gl gm gn gp gq gr gs gt gu gw gy hk hm hn hr ht hu id ie il im in io iq ir is it je jm jo jp ke kg kh ki km kn kp kr kw ky kz la lb lc li lk lr ls lt lu lv ly ma mc md me mf mg mh mk ml mm mn mo mp mq mr ms mt mu mv mw mx my mz na nc ne nf ng ni nl no np nr nu nz om pa pe pf pg ph pk pl pm pn pr ps pt pw py qa re ro rs ru rw sa sb sc sd se sg sh si sj sk sl sm sn so sr ss st sv sx sy sz tc td tf tg th tj tk tl tm tn to tr tt tv tw tz ua ug um us uy uz va vc ve vg vi vn vu wf ws ye yt za zm zw eu global').split(' '));

package/dist/webview/entry.js

@@ -185,8 +185,13 @@ function dispatchValidate(kind, doc) {
             return renderFromValidation('process-map', validateProcessMap(doc), () => renderProcessMapHtml(doc.process_map));
         case 'scenarios':
             return renderFromValidation('scenarios', validateScenario(doc), () => renderScenarioHtml(doc.scenario));
-        case 'capability-map':
-            return renderFromValidation('capability-map', validateCapabilityMap(doc), () => renderCapabilityMapHtml(doc.capability_map));
+        case 'capability-map': {
+            const validation = validateCapabilityMap(doc);
+            const unresolved = validation.warnings.find(w => w.code === 'NOTATION-SKIP-001');
+            if (validation.valid && unresolved)
+                return errorResult('capability-map', unresolved.code, unresolved.message);
+            return renderFromValidation('capability-map', validation, () => renderCapabilityMapHtml(doc.capability_map));
+        }
         default:
             return errorResult(kind, 'NOTATION-NOT-WIRED', `Notation '${kind}' is not wired into the IntelliJ bundle yet.`);
     }

package/dist/webview/render-goals.js

@@ -41,7 +41,8 @@ export function renderGoalsSvg(tree, options = {}) {
     const title = treeName
         ? `<text class="text-header" x="${PAD}" y="${PAD - 6}">${escXml(`Goal tree — ${treeName}`)}</text>`
         : '';
-    return renderGoalsLayoutSvg(layout, { curvature, entryCurvature, edgeStyle, title, embedCssTheme: 'transitrix' });
+    // Reserve a separate header row; the theme centers text on its y coordinate.
+    return renderGoalsLayoutSvg(layout, { curvature, entryCurvature, edgeStyle, title, topInset: title ? PAD : 0, embedCssTheme: 'transitrix' });
 }
 /**
  * The single goals SVG emitter shared by every host. Takes an already-computed

package/package.json

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

package/src/activities/action-fields.ts

@@ -0,0 +1,31 @@
+/** ACTION field types and the manifest-selected 7.0.0 numeric boundary. */
+export function validateActionFields(
+  action: Record<string, unknown>, methodologyVersion?: string,
+): Array<{ code: string; message: string; path: string }> {
+  const errors: Array<{ code: string; message: string; path: string }> = [];
+  const version = /^(\d+)\.(\d+)\.(\d+)(-[^+]+)?(?:\+.*)?$/.exec(methodologyVersion ?? '');
+  const nonnegative = version !== null && (Number(version[1]) > 7 ||
+    (Number(version[1]) === 7 && (Number(version[2]) > 0 || Number(version[3]) > 0 || !version[4])));
+  const type = (value: unknown): string => value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+  const schema = (path: string, expected: string, value: unknown) => errors.push({
+    code: 'SCHEMA_INVALID', path,
+    message: `ACTION field '${path}' expected ${expected}, actual ${type(value)} (${String(value)}).`,
+  });
+  for (const field of ['duration', 'duration_days', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort']) {
+    const value = action[field];
+    if (value === undefined || (value === null && (field === 'duration' || field === 'duration_days'))) continue;
+    const integer = field === 'score' || field === 'sort';
+    if (typeof value !== 'number' || !Number.isFinite(value) || (integer && !Number.isInteger(value))) {
+      schema(field, integer ? 'finite integer' : 'finite number', value);
+    } else if (nonnegative && field !== 'sort' && value < 0) {
+      errors.push({ code: 'ACTION-011', path: field, message: `ACTION field '${field}' is negative (${value}).` });
+    }
+  }
+  if (action.predecessors !== undefined) {
+    if (!Array.isArray(action.predecessors)) schema('predecessors', 'array of strings', action.predecessors);
+    else action.predecessors.forEach((value, index) => {
+      if (typeof value !== 'string') schema(`predecessors[${index}]`, 'string', value);
+    });
+  }
+  return errors;
+}

package/src/activities/validate.ts

@@ -1,3 +1,4 @@
+import { validateActionFields } from './action-fields.js';
 import type {
   ActivityDoc,
   Activity,
@@ -8,6 +9,11 @@ import type {
 import { isObject, str, reachesRootViaParent } from '../canon-resolver-utils.js';
 import { ACT_021_OMITTED_KEY } from './resolver.js';
 
+function validDate(value: string): boolean {
+  const date = new Date(value);
+  return DATE_RE.test(value) && Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const VALID_WEEKDAYS = new Set(['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']);
 
@@ -61,7 +67,7 @@ function collectAct021FromAuthored(
   return out;
 }
 
-export function validateActivities(input: unknown): ActivityValidationResult {
+export function validateActivities(input: unknown, options: { methodologyVersion?: string } = {}): ActivityValidationResult {
   const errors: ActivityValidationError[] = [];
   const warnings: ActivityValidationWarning[] = [];
 
@@ -104,7 +110,7 @@ export function validateActivities(input: unknown): ActivityValidationResult {
     warnings.push(...collectAct021FromAuthored(raw, rawArray));
   }
 
-  // ACT-014 / ACT-015: project.calendar validation (run before per-activity loop;
+  // ACT-007 / ACT-008: project.calendar validation (run before per-activity loop;
   // surfaces clearly even when activities also have issues).
   if (raw.project && typeof raw.project === 'object') {
     const project = raw.project as Record<string, unknown>;
@@ -113,7 +119,7 @@ export function validateActivities(input: unknown): ActivityValidationResult {
       const calendar = cal as Record<string, unknown>;
       if (calendar.working_days !== undefined) {
         if (!Array.isArray(calendar.working_days)) {
-          errors.push({ code: 'ACT-014', message: 'project.calendar.working_days must be an array of weekday names', path: 'project.calendar.working_days' });
+          errors.push({ code: 'ACT-007', message: 'project.calendar.working_days must be an array of weekday names', path: 'project.calendar.working_days' });
         } else {
           const seen = new Set<string>();
           for (let i = 0; i < calendar.working_days.length; i++) {
@@ -121,13 +127,13 @@ export function validateActivities(input: unknown): ActivityValidationResult {
             const day = typeof raw === 'string' ? raw.toLowerCase() : '';
             if (!VALID_WEEKDAYS.has(day)) {
               errors.push({
-                code: 'ACT-014',
+                code: 'ACT-007',
                 message: `project.calendar.working_days[${i}] "${String(raw)}" must be one of: mon, tue, wed, thu, fri, sat, sun`,
                 path: `project.calendar.working_days[${i}]`,
               });
             } else if (seen.has(day)) {
               errors.push({
-                code: 'ACT-014',
+                code: 'ACT-007',
                 message: `project.calendar.working_days has duplicate entry "${day}"`,
                 path: `project.calendar.working_days[${i}]`,
               });
@@ -139,13 +145,13 @@ export function validateActivities(input: unknown): ActivityValidationResult {
       }
       if (calendar.holidays !== undefined) {
         if (!Array.isArray(calendar.holidays)) {
-          errors.push({ code: 'ACT-015', message: 'project.calendar.holidays must be an array of ISO 8601 dates', path: 'project.calendar.holidays' });
+          errors.push({ code: 'ACT-008', message: 'project.calendar.holidays must be an array of ISO 8601 dates', path: 'project.calendar.holidays' });
         } else {
           for (let i = 0; i < calendar.holidays.length; i++) {
             const h = calendar.holidays[i];
-            if (typeof h !== 'string' || !DATE_RE.test(h)) {
+            if (typeof h !== 'string' || !validDate(h)) {
               errors.push({
-                code: 'ACT-015',
+                code: 'ACT-008',
                 message: `project.calendar.holidays[${i}] "${String(h)}" must be an ISO 8601 date (YYYY-MM-DD)`,
                 path: `project.calendar.holidays[${i}]`,
               });
@@ -204,15 +210,8 @@ export function validateActivities(input: unknown): ActivityValidationResult {
       idSet.add(id);
     }
 
-    // ACT-009: non-negative numeric fields
-    const numericFields = ['duration', 'duration_days', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort'] as const;
-    for (const field of numericFields) {
-      const val = act[field];
-      if (val !== undefined && val !== null) {
-        if (typeof val !== 'number' || val < 0) {
-          errors.push({ code: 'ACT-009', message: `Activity "${id}" field "${field}" must be a non-negative number, got ${String(val)}`, path });
-        }
-      }
+    for (const error of validateActionFields(act, options.methodologyVersion)) {
+      errors.push({ ...error, message: `Inline action actions[${i}].${error.path}: ${error.message}`, path: `actions[${i}].${error.path}` });
     }
 
     // ACT-011: warn if no duration (duration_days is accepted as an alias)
@@ -229,19 +228,23 @@ export function validateActivities(input: unknown): ActivityValidationResult {
     const a = doc.activities[i];
     const path = `activities[${i}]`;
 
-    // ACT-007: self-loop
+    // ACTION-009: self-loop
     if (Array.isArray(a.predecessors) && a.predecessors.includes(a.id)) {
-      errors.push({ code: 'ACT-007', message: `Activity "${a.id}" lists itself as a predecessor`, path });
+      errors.push({ code: 'ACTION-009', message: `Activity "${a.id}" lists itself as a predecessor`, path });
+    }
+
+    if (typeof a.parent === 'string' && !idSet.has(a.parent)) {
+      warnings.push({ code: 'ACTION-007', message: `Action "${a.id}" parent "${a.parent}" does not resolve`, path: `${path}.parent` });
     }
 
-    // ACT-005: predecessor existence (intra-document)
+    // ACTION-007: predecessor existence (intra-document)
     for (const predId of (a.predecessors ?? [])) {
       if (!idSet.has(predId)) {
-        errors.push({ code: 'ACT-005', message: `Activity "${a.id}" references unknown predecessor "${predId}"`, path });
+        warnings.push({ code: 'ACTION-007', message: `Activity "${a.id}" references unknown predecessor "${predId}"`, path });
       }
     }
 
-    // ACT-008: date format validation + end_date >= start_date.
+    // ACTION-010: date format validation + end_date >= start_date.
     // The orchestrator's pre-release review flagged that the raw lexicographic
     // string compare is only correct for strict YYYY-MM-DD, with no format
     // check applied. Now we validate the format first; the order compare runs
@@ -249,28 +252,28 @@ export function validateActivities(input: unknown): ActivityValidationResult {
     // be misleading).
     let startValid = true;
     let endValid = true;
-    if (a.start_date !== undefined) {
-      if (typeof a.start_date !== 'string' || !DATE_RE.test(a.start_date)) {
-        errors.push({ code: 'ACT-008', message: `Activity "${a.id}" start_date "${String(a.start_date)}" must be ISO 8601 YYYY-MM-DD`, path });
+    if (a.start_date !== undefined && a.start_date !== null) {
+      if (typeof a.start_date !== 'string' || !validDate(a.start_date)) {
+        errors.push({ code: 'ACTION-010', message: `Activity "${a.id}" start_date "${String(a.start_date)}" must be ISO 8601 YYYY-MM-DD`, path });
         startValid = false;
       }
     }
-    if (a.end_date !== undefined) {
-      if (typeof a.end_date !== 'string' || !DATE_RE.test(a.end_date)) {
-        errors.push({ code: 'ACT-008', message: `Activity "${a.id}" end_date "${String(a.end_date)}" must be ISO 8601 YYYY-MM-DD`, path });
+    if (a.end_date !== undefined && a.end_date !== null) {
+      if (typeof a.end_date !== 'string' || !validDate(a.end_date)) {
+        errors.push({ code: 'ACTION-010', message: `Activity "${a.id}" end_date "${String(a.end_date)}" must be ISO 8601 YYYY-MM-DD`, path });
         endValid = false;
       }
     }
     if (a.start_date && a.end_date && startValid && endValid) {
       if (a.end_date < a.start_date) {
-        errors.push({ code: 'ACT-008', message: `Activity "${a.id}" end_date "${a.end_date}" is before start_date "${a.start_date}"`, path });
+        errors.push({ code: 'ACTION-010', message: `Activity "${a.id}" end_date "${a.end_date}" is before start_date "${a.start_date}"`, path });
       }
     }
   }
 
   if (errors.length > 0) return { valid: false, errors, warnings };
 
-  // ACT-006: no cycles
+  // ACTION-008: no cycles
   const cycleError = detectCycle(doc.activities);
   if (cycleError) errors.push(cycleError);
 
@@ -375,7 +378,7 @@ export function validateActivities(input: unknown): ActivityValidationResult {
     }
   }
 
-  // ACT-019: Gantt view will not render when neither project.start_date nor
+  // ACT-009: Gantt view will not render when neither project.start_date nor
   // any per-activity pinned date pair is present. Network view is unaffected.
   const hasProjectStart = typeof doc.project?.start_date === 'string' && doc.project.start_date.length > 0;
   const hasPinnedActivity = doc.activities.some(
@@ -383,7 +386,7 @@ export function validateActivities(input: unknown): ActivityValidationResult {
   );
   if (!hasProjectStart && !hasPinnedActivity) {
     warnings.push({
-      code: 'ACT-019',
+      code: 'ACT-009',
       message: 'Gantt view will not render: project.start_date is absent and no activity has both start_date and end_date pinned. Network view is unaffected.',
     });
   }
@@ -408,7 +411,7 @@ function detectCycle(activities: Activity[]): ActivityValidationError | null {
   for (const a of activities) inDegree.set(a.id, 0);
   for (const a of activities) {
     for (const pred of (a.predecessors ?? [])) {
-      inDegree.set(a.id, (inDegree.get(a.id) ?? 0) + 1);
+      if (successors.has(pred)) inDegree.set(a.id, (inDegree.get(a.id) ?? 0) + 1);
     }
   }
 
@@ -430,7 +433,7 @@ function detectCycle(activities: Activity[]): ActivityValidationError | null {
 
   if (processed < activities.length) {
     const cycleNodes = activities.filter(a => (inDegree.get(a.id) ?? 0) > 0).map(a => a.id);
-    return { code: 'ACT-006', message: `Cycle detected in activity dependency graph involving: ${cycleNodes.join(', ')}` };
+    return { code: 'ACTION-008', message: `Cycle detected in activity dependency graph involving: ${cycleNodes.join(', ')}` };
   }
   return null;
 }