@elevasis/core 0.23.0 → 0.24.0

package/src/organization-model/__tests__/recursive-system-schema.test.ts

@@ -1,520 +1,549 @@
-/**
- * recursive-system-schema.test.ts
- *
- * Tests for B3, B4, B5, L19, and D2 content-node refines in OrganizationModelSchema.
- * Each constraint has ≥1 positive (passes) and ≥1 negative (error) assertion.
- *
- * B3 — Cycle detection: parentContentId chain must not form a cycle.
- * B4 — Same-system-only: parentContentId must resolve within the same content map.
- * B5 — Payload validation: registered (kind, type) pairs validate data.
- * L19 — Same-meta-kind parent constraint.
- * D2 — Unregistered (kind, type) passes through without error.
- */
+/**
+ * recursive-system-schema.test.ts
+ *
+ * Tests for B3, B4, B5, L19, and D2 content-node refines in OrganizationModelSchema.
+ * Each constraint has ≥1 positive (passes) and ≥1 negative (error) assertion.
+ *
+ * B3 — Cycle detection: parentContentId chain must not form a cycle.
+ * B4 — Same-system-only: parentContentId must resolve within the same content map.
+ * B5 — Payload validation: registered (kind, type) pairs validate data.
+ * L19 — Same-meta-kind parent constraint.
+ * D2 — Unregistered (kind, type) passes through without error.
+ */
 import { describe, expect, it } from 'vitest'
 import { resolveOrganizationModel } from '../resolve'
+import { getSystem, listAllSystems } from '../helpers'
 import { OrganizationModelSchema } from '../schema'
-import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
-
-// Phase 4 (D8): sales, prospecting, projects top-level OM fields removed.
-// DEFAULT_ORGANIZATION_MODEL_SALES / _PROSPECTING / _PROJECTS no longer exported.
-// makeMinimalModel no longer includes those fields — they were extra props that
-// the schema stripped anyway. Removing them has no effect on the test fixtures.
-
-// ---------------------------------------------------------------------------
-// Minimal model factory (shared with schema.test.ts convention)
-// ---------------------------------------------------------------------------
-
-function makeSystem(id: string, path = `/${id.replaceAll('.', '/')}`) {
-  return {
-    id,
-    order: 10,
-    label: id,
-    enabled: true,
-    lifecycle: 'active' as const,
-    path
-  }
-}
-
-function makeMinimalModel(systems: Record<string, unknown> = {}, extra: Record<string, unknown> = {}) {
-  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
-  return {
-    version: 1 as const,
-    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-    entities: {
-      'crm.deal': { id: 'crm.deal', order: 10, label: 'Deal', ownedBySystemId: entityOwnerId },
-      'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: entityOwnerId },
-      'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: entityOwnerId },
-      'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: entityOwnerId },
-      'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: entityOwnerId },
-      'delivery.milestone': {
-        id: 'delivery.milestone',
-        order: 60,
-        label: 'Milestone',
-        ownedBySystemId: entityOwnerId
-      },
-      'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: entityOwnerId }
-    },
-    systems,
-    ...extra
-  }
-}
-
-function getIssueMessages(data: unknown): string[] {
-  const result = OrganizationModelSchema.safeParse(data)
-  if (result.success) return []
-  return result.error.issues.map((issue) => issue.message)
-}
-
-function parseSucceeds(data: unknown): boolean {
-  return OrganizationModelSchema.safeParse(data).success
-}
-
-// ---------------------------------------------------------------------------
-// 2-level subsystem + content fixture round-trips
-// ---------------------------------------------------------------------------
-
-describe('2-level subsystems + content (positive, structural)', () => {
-  it('parses a model with a top-level system that has a subsystem via resolveOrganizationModel', () => {
-    const model = resolveOrganizationModel({
-      systems: {
-        ops: { id: 'ops', order: 99, label: 'Ops', enabled: true, path: '/ops' },
-        'ops.sub': {
-          id: 'ops.sub',
-          order: 100,
-          label: 'Sub',
-          enabled: true,
-          path: '/ops/sub',
-          parentSystemId: 'ops'
-        }
-      }
-    })
-    expect(model.systems['ops']).toBeDefined()
-    expect(model.systems['ops.sub']).toBeDefined()
-  })
-
-  it('parses a system with a content map carrying a valid registered node', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          'main-pipeline': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Main Pipeline',
-            data: { entityId: 'crm.deal' }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
+import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
+
+// Phase 4 (D8): sales, prospecting, projects top-level OM fields removed.
+// DEFAULT_ORGANIZATION_MODEL_SALES / _PROSPECTING / _PROJECTS no longer exported.
+// makeMinimalModel no longer includes those fields — they were extra props that
+// the schema stripped anyway. Removing them has no effect on the test fixtures.
+
+// ---------------------------------------------------------------------------
+// Minimal model factory (shared with schema.test.ts convention)
+// ---------------------------------------------------------------------------
+
+function makeSystem(id: string, path = `/${id.replaceAll('.', '/')}`) {
+  return {
+    id,
+    order: 10,
+    label: id,
+    enabled: true,
+    lifecycle: 'active' as const,
+    path
+  }
+}
+
+function makeMinimalModel(systems: Record<string, unknown> = {}, extra: Record<string, unknown> = {}) {
+  const entityOwnerId = Object.keys(systems)[0] ?? 'dashboard'
+  return {
+    version: 1 as const,
+    branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+    entities: {
+      'crm.deal': { id: 'crm.deal', order: 10, label: 'Deal', ownedBySystemId: entityOwnerId },
+      'leadgen.list': { id: 'leadgen.list', order: 20, label: 'Lead List', ownedBySystemId: entityOwnerId },
+      'leadgen.company': { id: 'leadgen.company', order: 30, label: 'Lead Company', ownedBySystemId: entityOwnerId },
+      'leadgen.contact': { id: 'leadgen.contact', order: 40, label: 'Lead Contact', ownedBySystemId: entityOwnerId },
+      'delivery.project': { id: 'delivery.project', order: 50, label: 'Project', ownedBySystemId: entityOwnerId },
+      'delivery.milestone': {
+        id: 'delivery.milestone',
+        order: 60,
+        label: 'Milestone',
+        ownedBySystemId: entityOwnerId
+      },
+      'delivery.task': { id: 'delivery.task', order: 70, label: 'Task', ownedBySystemId: entityOwnerId }
+    },
+    systems,
+    ...extra
+  }
+}
+
+function getIssueMessages(data: unknown): string[] {
+  const result = OrganizationModelSchema.safeParse(data)
+  if (result.success) return []
+  return result.error.issues.map((issue) => issue.message)
+}
+
+function parseSucceeds(data: unknown): boolean {
+  return OrganizationModelSchema.safeParse(data).success
+}
+
+// ---------------------------------------------------------------------------
+// 2-level subsystem + content fixture round-trips
+// ---------------------------------------------------------------------------
+
+describe('2-level subsystems + content (positive, structural)', () => {
+  it('parses a model with a top-level system that has a subsystem via resolveOrganizationModel', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        ops: { id: 'ops', order: 99, label: 'Ops', enabled: true, path: '/ops' },
+        'ops.sub': {
+          id: 'ops.sub',
+          order: 100,
+          label: 'Sub',
+          enabled: true,
+          path: '/ops/sub',
+          parentSystemId: 'ops'
+        }
+      }
+    })
+    expect(model.systems['ops']).toBeDefined()
+    expect(model.systems['ops.sub']).toBeDefined()
+  })
+
+  it('parses a system with a content map carrying a valid registered node', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'main-pipeline': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Main Pipeline',
+            data: { entityId: 'crm.deal' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
   it('parses a 2-level subsystem hierarchy with content at each level', () => {
-    const data = makeMinimalModel({
-      parent: {
-        ...makeSystem('parent', '/parent'),
-        content: {
-          'parent-config': {
-            kind: 'config',
-            type: 'kv',
-            label: 'Parent Config',
-            data: { entries: { maxBatch: 10 } }
-          }
-        }
-      },
-      'parent.child': {
-        ...makeSystem('parent.child', '/parent/child'),
-        parentSystemId: 'parent',
-        content: {
-          'child-config': {
-            kind: 'config',
-            type: 'kv',
-            label: 'Child Config',
-            data: { entries: { timeout: 5000 } }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// B3 — parentContentId cycle detection
-// ---------------------------------------------------------------------------
-
-describe('B3 — parentContentId cycle detection', () => {
-  it('POSITIVE: linear parentContentId chain (A → B, B has no parent) parses', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          flow: {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Flow',
-            data: { appliesTo: 'project' }
-          },
-          status: {
-            kind: 'schema',
-            type: 'status',
-            label: 'Active',
-            parentContentId: 'flow',
-            data: { semanticClass: 'active' }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('NEGATIVE: direct self-cycle (node points to itself) produces cycle error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          'self-ref': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Self Ref',
-            parentContentId: 'self-ref'
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
-  })
-
-  it('NEGATIVE: indirect 2-node cycle (A → B → A) produces cycle error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          alpha: {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Alpha',
-            parentContentId: 'beta'
-          },
-          beta: {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Beta',
-            parentContentId: 'alpha'
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// B4 — parentContentId must resolve within the same system content map
-// ---------------------------------------------------------------------------
-
-describe('B4 — parentContentId cross-system reference error', () => {
-  it('POSITIVE: parentContentId referencing a sibling in the same content map parses', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          parent: {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Status Flow',
-            data: { appliesTo: 'task' }
-          },
-          child: {
-            kind: 'schema',
-            type: 'status',
-            label: 'Open',
-            parentContentId: 'parent',
-            data: { semanticClass: 'active' }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('NEGATIVE: parentContentId referencing a non-existent localId produces B4 error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          orphan: {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Orphan',
-            parentContentId: 'does-not-exist-in-this-system'
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(
-      messages.some((m) => m.includes('does not resolve within the same system') || m.includes('parentContentId'))
-    ).toBe(true)
-  })
-
-  it('NEGATIVE: cross-system localId reference (sibling system content is a different map)', () => {
-    // "other-system" has "shared-node" but "hub" does NOT — so parentContentId is cross-system
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          child: {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Child',
-            parentContentId: 'shared-node' // exists in other-system, not hub
-          }
-        }
-      },
-      other: {
-        ...makeSystem('other', '/other'),
-        content: {
-          'shared-node': {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Shared Node'
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('parentContentId'))).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// B5 — Payload validation for registered (kind, type) pairs
-// ---------------------------------------------------------------------------
-
-describe('B5 — payload validation for registered kinds', () => {
-  it('POSITIVE: valid schema:pipeline data passes payload validation', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          pipe: {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Pipeline',
-            data: { entityId: 'crm.deal' }
-          }
-        }
-      }
-    })
+    const data = makeMinimalModel({
+      parent: {
+        ...makeSystem('parent', '/parent'),
+        content: {
+          'parent-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Parent Config',
+            data: { entries: { maxBatch: 10 } }
+          }
+        }
+      },
+      'parent.child': {
+        ...makeSystem('parent.child', '/parent/child'),
+        parentSystemId: 'parent',
+        content: {
+          'child-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Child Config',
+            data: { entries: { timeout: 5000 } }
+          }
+        }
+      }
+    })
     expect(parseSucceeds(data)).toBe(true)
   })
 
-  it('NEGATIVE: invalid schema:pipeline data (missing required entityId) produces payload error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          pipe: {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Pipeline',
-            data: { kanbanColor: 'blue' } // entityId is required
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('data failed payload validation') || m.includes('payload'))).toBe(true)
-  })
-
-  it('POSITIVE: valid config:kv data passes payload validation', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          cfg: {
-            kind: 'config',
-            type: 'kv',
-            label: 'Config',
-            data: { entries: { flag: true, limit: 100 } }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('NEGATIVE: invalid config:kv data (entries contains an object value) produces payload error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          cfg: {
-            kind: 'config',
-            type: 'kv',
-            label: 'Config',
-            data: { entries: { nested: { key: 'value' } } } // object not allowed, only primitives
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
-  })
-
-  it('POSITIVE: valid schema:status-flow data passes', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          flow: {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Flow',
-            data: { appliesTo: 'project' }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('NEGATIVE: invalid schema:status-flow data (bad appliesTo value)', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          flow: {
-            kind: 'schema',
-            type: 'status-flow',
-            label: 'Flow',
-            data: { appliesTo: 'organization' } // not in enum
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// D2 — Unregistered (kind, type) passes through without error
-// ---------------------------------------------------------------------------
-
-describe('D2 — unregistered (kind, type) passes through (no error)', () => {
-  it('unregistered tenant kind passes schema validation without error', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          custom: {
-            kind: 'tenant',
-            type: 'custom-thing',
-            label: 'Custom Thing',
-            data: { anything: 'goes', nested: { ok: true } }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('unregistered kind with invalid-looking data still passes through (no payload schema to validate against)', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          unknown: {
-            kind: 'experimental',
-            type: 'prototype',
-            label: 'Prototype',
-            data: { malformed: [1, 2, 3], extra: null }
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-
-  it('unregistered kind with parentContentId that resolves in same system also passes', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          parent: {
-            kind: 'tenant',
-            type: 'group',
-            label: 'Parent Group'
-          },
-          child: {
-            kind: 'tenant',
-            type: 'item',
-            label: 'Child Item',
-            parentContentId: 'parent'
-          }
-        }
-      }
-    })
-    expect(parseSucceeds(data)).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// L19 — Same-meta-kind parent constraint
-// ---------------------------------------------------------------------------
-
-describe('L19 — same-meta-kind parent constraint', () => {
-  it('POSITIVE: schema:stage under schema:pipeline shares same kind (schema)', () => {
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          pipe: {
-            kind: 'schema',
-            type: 'pipeline',
-            label: 'Pipeline',
-            data: { entityId: 'crm.deal' }
-          },
-          stage: {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Stage',
-            parentContentId: 'pipe',
-            data: { semanticClass: 'open' }
+  it('parses canonical systems children and keeps subsystems as a compatibility alias', () => {
+    const model = resolveOrganizationModel({
+      systems: {
+        parent: {
+          ...makeSystem('parent', '/parent'),
+          systems: {
+            child: {
+              ...makeSystem('child', '/parent/child'),
+              content: {
+                pipeline: {
+                  kind: 'schema',
+                  type: 'pipeline',
+                  label: 'Pipeline',
+                  data: { entityId: 'crm.deal' }
+                }
+              }
+            }
           }
         }
       }
     })
-    expect(parseSucceeds(data)).toBe(true)
-  })
 
-  it('NEGATIVE: registered child under registered parent with different meta-kind produces L19 error', () => {
-    // schema:stage (meta-kind: schema) trying to parent under config:kv (meta-kind: config)
-    const data = makeMinimalModel({
-      hub: {
-        ...makeSystem('hub', '/hub'),
-        content: {
-          'my-config': {
-            kind: 'config',
-            type: 'kv',
-            label: 'Config',
-            data: { entries: { enabled: true } }
-          },
-          'my-stage': {
-            kind: 'schema',
-            type: 'stage',
-            label: 'Stage',
-            parentContentId: 'my-config',
-            data: { semanticClass: 'open' }
-          }
-        }
-      }
-    })
-    const messages = getIssueMessages(data)
-    expect(messages.some((m) => m.includes('same-meta-kind') || m.includes('parentContentId'))).toBe(true)
+    expect(model.systems.parent?.systems?.child).toBeDefined()
+    expect(model.systems.parent?.subsystems?.child).toBeDefined()
+    expect(getSystem(model, 'parent.child')?.label).toBe('child')
+    expect(listAllSystems(model).map((entry) => entry.path)).toContain('parent.child')
   })
 })
+
+// ---------------------------------------------------------------------------
+// B3 — parentContentId cycle detection
+// ---------------------------------------------------------------------------
+
+describe('B3 — parentContentId cycle detection', () => {
+  it('POSITIVE: linear parentContentId chain (A → B, B has no parent) parses', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'project' }
+          },
+          status: {
+            kind: 'schema',
+            type: 'status',
+            label: 'Active',
+            parentContentId: 'flow',
+            data: { semanticClass: 'active' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: direct self-cycle (node points to itself) produces cycle error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'self-ref': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Self Ref',
+            parentContentId: 'self-ref'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
+  })
+
+  it('NEGATIVE: indirect 2-node cycle (A → B → A) produces cycle error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          alpha: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Alpha',
+            parentContentId: 'beta'
+          },
+          beta: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Beta',
+            parentContentId: 'alpha'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId cycle'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B4 — parentContentId must resolve within the same system content map
+// ---------------------------------------------------------------------------
+
+describe('B4 — parentContentId cross-system reference error', () => {
+  it('POSITIVE: parentContentId referencing a sibling in the same content map parses', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          parent: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Status Flow',
+            data: { appliesTo: 'task' }
+          },
+          child: {
+            kind: 'schema',
+            type: 'status',
+            label: 'Open',
+            parentContentId: 'parent',
+            data: { semanticClass: 'active' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: parentContentId referencing a non-existent localId produces B4 error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          orphan: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Orphan',
+            parentContentId: 'does-not-exist-in-this-system'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(
+      messages.some((m) => m.includes('does not resolve within the same system') || m.includes('parentContentId'))
+    ).toBe(true)
+  })
+
+  it('NEGATIVE: cross-system localId reference (sibling system content is a different map)', () => {
+    // "other-system" has "shared-node" but "hub" does NOT — so parentContentId is cross-system
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          child: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Child',
+            parentContentId: 'shared-node' // exists in other-system, not hub
+          }
+        }
+      },
+      other: {
+        ...makeSystem('other', '/other'),
+        content: {
+          'shared-node': {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Shared Node'
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('parentContentId'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// B5 — Payload validation for registered (kind, type) pairs
+// ---------------------------------------------------------------------------
+
+describe('B5 — payload validation for registered kinds', () => {
+  it('POSITIVE: valid schema:pipeline data passes payload validation', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { entityId: 'crm.deal' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid schema:pipeline data (missing required entityId) produces payload error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { kanbanColor: 'blue' } // entityId is required
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('data failed payload validation') || m.includes('payload'))).toBe(true)
+  })
+
+  it('POSITIVE: valid config:kv data passes payload validation', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          cfg: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { flag: true, limit: 100 } }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid config:kv data (entries contains an object value) produces payload error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          cfg: {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { nested: { key: 'value' } } } // object not allowed, only primitives
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
+  })
+
+  it('POSITIVE: valid schema:status-flow data passes', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'project' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: invalid schema:status-flow data (bad appliesTo value)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          flow: {
+            kind: 'schema',
+            type: 'status-flow',
+            label: 'Flow',
+            data: { appliesTo: 'organization' } // not in enum
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('payload') || m.includes('data'))).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// D2 — Unregistered (kind, type) passes through without error
+// ---------------------------------------------------------------------------
+
+describe('D2 — unregistered (kind, type) passes through (no error)', () => {
+  it('unregistered tenant kind passes schema validation without error', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          custom: {
+            kind: 'tenant',
+            type: 'custom-thing',
+            label: 'Custom Thing',
+            data: { anything: 'goes', nested: { ok: true } }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('unregistered kind with invalid-looking data still passes through (no payload schema to validate against)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          unknown: {
+            kind: 'experimental',
+            type: 'prototype',
+            label: 'Prototype',
+            data: { malformed: [1, 2, 3], extra: null }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('unregistered kind with parentContentId that resolves in same system also passes', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          parent: {
+            kind: 'tenant',
+            type: 'group',
+            label: 'Parent Group'
+          },
+          child: {
+            kind: 'tenant',
+            type: 'item',
+            label: 'Child Item',
+            parentContentId: 'parent'
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// L19 — Same-meta-kind parent constraint
+// ---------------------------------------------------------------------------
+
+describe('L19 — same-meta-kind parent constraint', () => {
+  it('POSITIVE: schema:stage under schema:pipeline shares same kind (schema)', () => {
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          pipe: {
+            kind: 'schema',
+            type: 'pipeline',
+            label: 'Pipeline',
+            data: { entityId: 'crm.deal' }
+          },
+          stage: {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Stage',
+            parentContentId: 'pipe',
+            data: { semanticClass: 'open' }
+          }
+        }
+      }
+    })
+    expect(parseSucceeds(data)).toBe(true)
+  })
+
+  it('NEGATIVE: registered child under registered parent with different meta-kind produces L19 error', () => {
+    // schema:stage (meta-kind: schema) trying to parent under config:kv (meta-kind: config)
+    const data = makeMinimalModel({
+      hub: {
+        ...makeSystem('hub', '/hub'),
+        content: {
+          'my-config': {
+            kind: 'config',
+            type: 'kv',
+            label: 'Config',
+            data: { entries: { enabled: true } }
+          },
+          'my-stage': {
+            kind: 'schema',
+            type: 'stage',
+            label: 'Stage',
+            parentContentId: 'my-config',
+            data: { semanticClass: 'open' }
+          }
+        }
+      }
+    })
+    const messages = getIssueMessages(data)
+    expect(messages.some((m) => m.includes('same-meta-kind') || m.includes('parentContentId'))).toBe(true)
+  })
+})