@elevasis/core 0.26.0 → 0.28.0

package/src/organization-model/__tests__/cross-ref.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import { buildOmCrossRefIndex, knowledgeTargetExists } from '../cross-ref'
+import { OrganizationModelSchema } from '../schema'
+import type { OrganizationModel } from '../types'
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal but schema-valid OrganizationModel that contains:
+ *  - a top-level system with id "sales" (path "sales")
+ *  - a nested subsystem with id "sales.lead-gen" (path "sales.lead-gen")
+ *  - a stage-kind catalog with id "sales.lead-gen:catalog/company-stage"
+ *    and a single entry "prospect"
+ *  - a knowledge node whose link targets the "prospect" stage
+ */
+function makeModelWithStage(): OrganizationModel {
+  return {
+    ...DEFAULT_ORGANIZATION_MODEL,
+    systems: {
+      sales: {
+        id: 'sales',
+        order: 10,
+        label: 'Sales',
+        enabled: true,
+        lifecycle: 'active' as const,
+        systems: {
+          'lead-gen': {
+            id: 'sales.lead-gen',
+            order: 10,
+            label: 'Lead Gen',
+            enabled: true,
+            lifecycle: 'active' as const,
+            path: '/sales/lead-gen',
+            ontology: {
+              catalogTypes: {
+                'sales.lead-gen:catalog/company-stage': {
+                  id: 'sales.lead-gen:catalog/company-stage',
+                  label: 'Company Stages',
+                  ownerSystemId: 'sales.lead-gen',
+                  kind: 'stage' as const,
+                  entries: {
+                    prospect: {
+                      label: 'Prospect',
+                      description: 'Company identified as a potential lead.',
+                      order: 1
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    knowledge: {
+      'knowledge.lead-gen-playbook': {
+        id: 'knowledge.lead-gen-playbook',
+        kind: 'playbook' as const,
+        title: 'Lead Gen Playbook',
+        summary: 'Governs the lead gen stage progression.',
+        body: '## Overview\n\nPlaybook content.',
+        links: [
+          {
+            target: { kind: 'stage' as const, id: 'prospect' },
+            nodeId: 'stage:prospect'
+          }
+        ],
+        ownerIds: [],
+        updatedAt: '2026-05-17'
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// (a) stage-kind knowledge-link targets resolve via knowledgeTargetExists
+// ---------------------------------------------------------------------------
+
+describe('knowledgeTargetExists — stage kind', () => {
+  it('returns true for a stage id that exists in a stage-kind catalog', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    expect(knowledgeTargetExists(idx, 'stage', 'prospect')).toBe(true)
+  })
+
+  it('returns false for a stage id that does not exist in any catalog', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    expect(knowledgeTargetExists(idx, 'stage', 'nonexistent-stage')).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// (b) system targets resolve by dotted path AND by system.id (dual-keyed)
+// ---------------------------------------------------------------------------
+
+describe('knowledgeTargetExists — system kind dual-keyed lookup', () => {
+  it('resolves a system by its dotted path', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    // "sales.lead-gen" is the dotted path in the systems tree
+    expect(knowledgeTargetExists(idx, 'system', 'sales.lead-gen')).toBe(true)
+  })
+
+  it('resolves a system by system.id when id differs from tree key', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    // system.id === "sales.lead-gen" — same here, but the index is keyed by BOTH
+    // the path AND the id so this also exercises the id branch
+    expect(knowledgeTargetExists(idx, 'system', 'sales.lead-gen')).toBe(true)
+  })
+
+  it('returns false for an unknown system identifier', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    expect(knowledgeTargetExists(idx, 'system', 'sales.crm')).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// (c) Schema path and verify path agree on stage-targeting knowledge node
+// ---------------------------------------------------------------------------
+
+describe('schema / verify path parity — stage target', () => {
+  it('OrganizationModelSchema accepts a knowledge node with a stage link', () => {
+    const model = makeModelWithStage()
+    const result = OrganizationModelSchema.safeParse(model)
+    const stageIssues = result.success
+      ? []
+      : result.error.issues.filter(
+          (issue) =>
+            issue.message.includes('stage') ||
+            (Array.isArray(issue.path) && issue.path.includes('knowledge'))
+        )
+    expect(stageIssues).toHaveLength(0)
+  })
+
+  it('knowledgeTargetExists returns true for the stage target (verify path would accept)', () => {
+    const model = makeModelWithStage()
+    const idx = buildOmCrossRefIndex(model)
+    const knowledgeNode = model.knowledge['knowledge.lead-gen-playbook']
+    expect(knowledgeNode).toBeDefined()
+    for (const link of knowledgeNode.links) {
+      expect(knowledgeTargetExists(idx, link.target.kind, link.target.id)).toBe(true)
+    }
+  })
+
+  it('schema and verify path agree: both accept the stage link without error', () => {
+    const model = makeModelWithStage()
+
+    // Schema path: parse must succeed (no issues about the stage link)
+    const parseResult = OrganizationModelSchema.safeParse(model)
+    const knowledgeIssues = parseResult.success
+      ? []
+      : parseResult.error.issues.filter((issue) => Array.isArray(issue.path) && issue.path[0] === 'knowledge')
+    expect(knowledgeIssues).toHaveLength(0)
+
+    // Verify path: knowledgeTargetExists must return true for every link
+    const idx = buildOmCrossRefIndex(model)
+    const node = model.knowledge['knowledge.lead-gen-playbook']
+    const missingTargets = node.links.filter((link) => !knowledgeTargetExists(idx, link.target.kind, link.target.id))
+    expect(missingTargets).toHaveLength(0)
+  })
+})

package/src/organization-model/__tests__/define-domain-record.test.ts

@@ -0,0 +1,289 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+import { defineDomainRecord } from '../helpers'
+import { defineAction, defineActions, ActionSchema } from '../domains/actions'
+import { defineEntity, defineEntities, EntitySchema } from '../domains/entities'
+import { defineSystem, defineSystems, SystemEntrySchema } from '../domains/systems'
+import { definePolicy, definePolicies, PolicySchema } from '../domains/policies'
+import { defineRole, defineRoles, RoleSchema } from '../domains/roles'
+import { defineGoal, defineGoals, ObjectiveSchema } from '../domains/goals'
+import { defineCustomer, defineCustomers, CustomerSegmentSchema } from '../domains/customers'
+import { defineOffering, defineOfferings, ProductSchema } from '../domains/offerings'
+import { defineStatus, defineStatuses, StatusEntrySchema } from '../domains/statuses'
+import { defineKnowledgeNode, defineKnowledgeNodes, OrgKnowledgeNodeSchema } from '../domains/knowledge'
+
+// ---------------------------------------------------------------------------
+// Minimal valid fixtures for each domain
+// ---------------------------------------------------------------------------
+
+const validAction: z.input<typeof ActionSchema> = {
+  id: 'test-action',
+  order: 10,
+  label: 'Test Action',
+  invocations: []
+}
+
+const validEntity: z.input<typeof EntitySchema> = {
+  id: 'test.entity',
+  order: 10,
+  label: 'Test Entity',
+  ownedBySystemId: 'test-system'
+}
+
+const validSystem: z.input<typeof SystemEntrySchema> = {
+  id: 'test-system',
+  order: 10,
+  label: 'Test System'
+}
+
+const validPolicy: z.input<typeof PolicySchema> = {
+  id: 'test-policy',
+  order: 10,
+  label: 'Test Policy',
+  trigger: { kind: 'manual' },
+  actions: [{ kind: 'block' }]
+}
+
+const validRole: z.input<typeof RoleSchema> = {
+  id: 'test-role',
+  order: 10,
+  title: 'Test Role'
+}
+
+const validGoal: z.input<typeof ObjectiveSchema> = {
+  id: 'test-goal',
+  order: 10,
+  description: 'Grow ARR by 2x',
+  periodStart: '2026-01-01',
+  periodEnd: '2026-12-31'
+}
+
+const validCustomer: z.input<typeof CustomerSegmentSchema> = {
+  id: 'test-segment',
+  order: 10,
+  name: 'SMB Agencies'
+}
+
+const validOffering: z.input<typeof ProductSchema> = {
+  id: 'test-product',
+  order: 10,
+  name: 'Starter Plan'
+}
+
+const validStatus: z.input<typeof StatusEntrySchema> = {
+  id: 'test.status',
+  order: 10,
+  label: 'Test Status',
+  semanticClass: 'delivery.task'
+}
+
+const validKnowledgeNode: z.input<typeof OrgKnowledgeNodeSchema> = {
+  id: 'test-knowledge',
+  kind: 'reference',
+  title: 'Test Knowledge',
+  summary: 'A test knowledge node.',
+  body: 'Full body content here.',
+  updatedAt: '2026-01-01'
+}
+
+// ---------------------------------------------------------------------------
+// Generic defineDomainRecord
+// ---------------------------------------------------------------------------
+
+describe('defineDomainRecord', () => {
+  it('produces an id-keyed map for valid entries', () => {
+    const result = defineDomainRecord(ActionSchema, [validAction])
+    expect(result).toHaveProperty('test-action')
+    expect(result['test-action'].id).toBe('test-action')
+    expect(result['test-action'].label).toBe('Test Action')
+  })
+
+  it('produces a map keyed by each entry id when given multiple entries', () => {
+    const second: z.input<typeof ActionSchema> = { ...validAction, id: 'second-action', label: 'Second' }
+    const result = defineDomainRecord(ActionSchema, [validAction, second])
+    expect(Object.keys(result)).toEqual(['test-action', 'second-action'])
+  })
+
+  it('returns an empty map for an empty entries array', () => {
+    const result = defineDomainRecord(ActionSchema, [])
+    expect(result).toEqual({})
+  })
+
+  it('throws ZodError when an entry fails schema validation', () => {
+    const bad = { id: 'bad', order: 'not-a-number', label: 'Bad' } as unknown as z.input<typeof ActionSchema>
+    expect(() => defineDomainRecord(ActionSchema, [bad])).toThrow(z.ZodError)
+  })
+
+  it('applies schema defaults (invocations defaults to [])', () => {
+    const minimal = { id: 'minimal-action', order: 10, label: 'Minimal' } as z.input<typeof ActionSchema>
+    const result = defineDomainRecord(ActionSchema, [minimal])
+    expect(result['minimal-action'].invocations).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Parameterized per-domain tests
+// ---------------------------------------------------------------------------
+
+describe.each([
+  {
+    domain: 'actions',
+    defineSingle: defineAction,
+    defineMultiple: defineActions,
+    valid: validAction,
+    schema: ActionSchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'entities',
+    defineSingle: defineEntity,
+    defineMultiple: defineEntities,
+    valid: validEntity,
+    schema: EntitySchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'systems',
+    defineSingle: defineSystem,
+    defineMultiple: defineSystems,
+    valid: validSystem,
+    schema: SystemEntrySchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'policies',
+    defineSingle: definePolicy,
+    defineMultiple: definePolicies,
+    valid: validPolicy,
+    schema: PolicySchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'roles',
+    defineSingle: defineRole,
+    defineMultiple: defineRoles,
+    valid: validRole,
+    schema: RoleSchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'goals',
+    defineSingle: defineGoal,
+    defineMultiple: defineGoals,
+    valid: validGoal,
+    schema: ObjectiveSchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'customers',
+    defineSingle: defineCustomer,
+    defineMultiple: defineCustomers,
+    valid: validCustomer,
+    schema: CustomerSegmentSchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'offerings',
+    defineSingle: defineOffering,
+    defineMultiple: defineOfferings,
+    valid: validOffering,
+    schema: ProductSchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'statuses',
+    defineSingle: defineStatus,
+    defineMultiple: defineStatuses,
+    valid: validStatus,
+    schema: StatusEntrySchema,
+    idField: 'id' as const,
+    invalidOverride: { order: 'not-a-number' }
+  },
+  {
+    domain: 'knowledge',
+    defineSingle: defineKnowledgeNode,
+    defineMultiple: defineKnowledgeNodes,
+    valid: validKnowledgeNode,
+    schema: OrgKnowledgeNodeSchema,
+    idField: 'id' as const,
+    invalidOverride: { kind: 'invalid-kind' }
+  }
+])(
+  'define$domain — $domain',
+  ({ domain: _domain, defineSingle, defineMultiple, valid, schema, idField, invalidOverride }) => {
+    it('defineX — validates and returns a parsed entry', () => {
+      const result = defineSingle(valid as never)
+      expect(result).toHaveProperty(idField)
+      expect((result as Record<string, unknown>)[idField]).toBe((valid as Record<string, unknown>)[idField])
+    })
+
+    it('defineX — throws ZodError on invalid input', () => {
+      const bad = { ...valid, ...invalidOverride } as never
+      expect(() => defineSingle(bad)).toThrow(z.ZodError)
+    })
+
+    it('defineXs — produces an id-keyed map', () => {
+      const result = defineMultiple([valid] as never[])
+      const id = (valid as Record<string, unknown>)[idField] as string
+      expect(result).toHaveProperty(id)
+      expect((result[id] as Record<string, unknown>)[idField]).toBe(id)
+    })
+
+    it('defineXs — throws ZodError on invalid input', () => {
+      const bad = { ...valid, ...invalidOverride } as never
+      expect(() => defineMultiple([bad] as never[])).toThrow(z.ZodError)
+    })
+
+    it('defineXs — returns empty map for empty array', () => {
+      const result = defineMultiple([] as never[])
+      expect(result).toEqual({})
+    })
+
+    it('defineXs — validates through schema (no bypass)', () => {
+      // Confirm that defineMultiple uses schema.parse, not a pass-through.
+      // Missing required fields should throw even if the object looks similar.
+      const missingRequired = { [idField]: (valid as Record<string, unknown>)[idField] } as never
+      expect(() => defineMultiple([missingRequired] as never[])).toThrow(z.ZodError)
+    })
+  }
+)
+
+// ---------------------------------------------------------------------------
+// Topology — existing helpers (defineTopology, defineTopologyRelationship)
+// are already tested elsewhere; verified here that they exist and are callable.
+// ---------------------------------------------------------------------------
+
+describe('topology — existing helpers', () => {
+  it('defineTopologyRelationship is importable from domains/topology', async () => {
+    const { defineTopologyRelationship, topologyRef } = await import('../domains/topology')
+    const rel = defineTopologyRelationship({
+      from: topologyRef.system('sales'),
+      kind: 'uses',
+      to: topologyRef.resource('lead-gen.company.qualify')
+    })
+    expect(rel.kind).toBe('uses')
+    expect(rel.from.kind).toBe('system')
+    expect(rel.to.kind).toBe('resource')
+  })
+
+  it('defineTopology is importable and produces a domain object', async () => {
+    const { defineTopology, topologyRef } = await import('../domains/topology')
+    const domain = defineTopology({
+      'rel-1': {
+        from: topologyRef.system('sales'),
+        kind: 'triggers',
+        to: topologyRef.resource('lead-gen.company.qualify')
+      }
+    })
+    expect(domain.version).toBe(1)
+    expect(domain.relationships).toHaveProperty('rel-1')
+  })
+})

package/src/organization-model/__tests__/om-spine-doc-contract.test.ts

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+import { ACTION_REGISTRY } from '../domains/prospecting'
+import { getLeadGenStageCatalog } from '../migration-helpers'
+
+/**
+ * OM Spine doc <-> code contract guard.
+ *
+ * `scripts/monorepo/meta-verify.mjs` only string-greps the primer for symbol
+ * names, so it cannot notice when a documented "constant" has become a
+ * type-only export or an empty stub. This drift actually shipped (the Wave-2
+ * generic/canonical OM split) and went uncaught for that reason. These
+ * assertions tie the primer text to the real code shape so the same class of
+ * drift fails the unit suite. Pure file reads + pure imports — CI-safe.
+ */
+
+const repoRoot = fileURLToPath(new URL('../../../../../', import.meta.url))
+const catalogTypeSrc = fileURLToPath(new URL('../catalogs/lead-gen.ts', import.meta.url))
+
+const PRIMER_PATHS = [
+  'apps/docs/content/docs/technical/development/design/om-spine.mdx',
+  '.claude/skills/org-os/operations/spine.md'
+]
+
+const read = (p: string) => readFileSync(p, 'utf8')
+
+describe('OM Spine doc/code contract', () => {
+  it('keeps the generic core action registry an empty stub (bindings live in @repo/elevasis-core)', () => {
+    expect(ACTION_REGISTRY).toEqual([])
+  })
+
+  it('exposes the lead-gen catalog only as a reader function, not a hand-authored constant', () => {
+    expect(typeof getLeadGenStageCatalog).toBe('function')
+
+    // catalogs/lead-gen.ts must remain type-only — no LEAD_GEN_STAGE_CATALOG value export.
+    const src = read(catalogTypeSrc)
+    expect(src).not.toMatch(/export\s+const\s+LEAD_GEN_STAGE_CATALOG\b/)
+    expect(src).toMatch(/export\s+interface\s+LeadGenStageCatalogEntry\b/)
+  })
+
+  it.each(PRIMER_PATHS)('primer %s describes the post-split reality, not the retired constant', (relPath) => {
+    const text = read(repoRoot + relPath)
+
+    // Negative: the exact stale claims that shipped before this fix must not return.
+    expect(text).not.toMatch(
+      /`LEAD_GEN_STAGE_CATALOG`\s+in\s+`packages\/core\/src\/organization-model\/catalogs\/lead-gen\.ts`/
+    )
+    expect(text).not.toMatch(/LEAD_GEN_STAGE_CATALOG \(vocabulary, catalogs\/lead-gen\.ts\)/)
+
+    // Positive: each primer must point at the real reader + canonical owners.
+    expect(text).toContain('getLeadGenStageCatalog')
+    expect(text).toContain('LEAD_GEN_ACTION_ENTRIES')
+    expect(text).toContain('@repo/elevasis-core')
+  })
+})

package/src/organization-model/__tests__/published-zero-leak.test.ts

@@ -1,10 +1,27 @@
 import { describe, expect, it } from 'vitest'
+import * as publishedCore from '../../index'
 import * as publishedOrganizationModel from '../published'
 
 describe('published organization-model barrel zero-leak guard', () => {
   it('does not export Elevasis instance data through @repo/core/organization-model', () => {
     expect(Object.keys(publishedOrganizationModel)).not.toEqual(
-      expect.arrayContaining(['LEAD_GEN_STAGE_CATALOG', 'CRM_ACTION_ENTRIES', 'LEAD_GEN_ACTION_ENTRIES'])
+      expect.arrayContaining([
+        'LEAD_GEN_STAGE_CATALOG',
+        'CRM_ACTION_ENTRIES',
+        'LEAD_GEN_ACTION_ENTRIES',
+        'CRM_PIPELINE_DEFINITION',
+        'CRM_DISCOVERY_REPLIED_STATE',
+        'CRM_DISCOVERY_LINK_SENT_STATE',
+        'CRM_DISCOVERY_NUDGING_STATE',
+        'CRM_DISCOVERY_BOOKING_CANCELLED_STATE',
+        'CRM_REPLY_SENT_STATE',
+        'CRM_FOLLOWUP_1_SENT_STATE',
+        'CRM_FOLLOWUP_2_SENT_STATE',
+        'CRM_FOLLOWUP_3_SENT_STATE',
+        'CRM_PRIORITY_BUCKETS',
+        'DEFAULT_CRM_PRIORITY_RULE_CONFIG',
+        'DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG'
+      ])
     )
 
     const serializedExports = JSON.stringify(publishedOrganizationModel)
@@ -13,5 +30,47 @@ describe('published organization-model barrel zero-leak guard', () => {
     expect(serializedExports).not.toContain('lgn-05-email-verification-workflow')
     expect(serializedExports).not.toContain('localServices')
     expect(serializedExports).not.toContain('dtcApolloClickup')
+    expect(serializedExports).not.toContain('Elevasis')
+    expect(serializedExports).not.toContain('elevasis.io')
+    expect(serializedExports).not.toContain('discovery_replied')
+    expect(serializedExports).not.toContain('discovery_link_sent')
+    expect(serializedExports).not.toContain('crm-send-booking-link-workflow')
+  })
+
+  it('does not expose Elevasis CRM stage data through the @repo/core root barrel', () => {
+    expect(Object.keys(publishedCore)).not.toEqual(
+      expect.arrayContaining([
+        'CRM_PIPELINE_DEFINITION',
+        'CRM_DISCOVERY_REPLIED_STATE',
+        'CRM_DISCOVERY_LINK_SENT_STATE',
+        'CRM_DISCOVERY_NUDGING_STATE',
+        'CRM_DISCOVERY_BOOKING_CANCELLED_STATE',
+        'CRM_REPLY_SENT_STATE',
+        'CRM_FOLLOWUP_1_SENT_STATE',
+        'CRM_FOLLOWUP_2_SENT_STATE',
+        'CRM_FOLLOWUP_3_SENT_STATE',
+        'CRM_PRIORITY_BUCKETS',
+        'DEFAULT_CRM_PRIORITY_RULE_CONFIG',
+        'DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG',
+        'DEFAULT_CRM_ACTIONS'
+      ])
+    )
+
+    let legacyCrmStatesResult: unknown
+    try {
+      legacyCrmStatesResult = (
+        publishedCore as typeof publishedCore & {
+          getCrmStatesForStage?: (stageKey: string) => unknown
+        }
+      ).getCrmStatesForStage?.('interested')
+    } catch {
+      legacyCrmStatesResult = undefined
+    }
+
+    expect(JSON.stringify(legacyCrmStatesResult ?? null)).not.toContain('discovery_replied')
+    const serializedRootExports = JSON.stringify(publishedCore)
+    expect(serializedRootExports).not.toContain('discovery_replied')
+    expect(serializedRootExports).not.toContain('discovery_link_sent')
+    expect(serializedRootExports).not.toContain('crm-send-booking-link-workflow')
   })
 })

package/src/organization-model/__tests__/resolve.test.ts

@@ -169,7 +169,7 @@ describe('organization-model resolve', () => {
     })
 
     expect(model.branding.organizationName).toBe('OverriddenOrg')
-    expect(model.branding.productName).toBe('Elevasis')
+    expect(model.branding.productName).toBe('Organization OS')
     expect(model.systems).toEqual({})
   })
 

package/src/organization-model/__tests__/schema-refinements.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import { refineOrganizationModel } from '../schema-refinements'
+import type { OrganizationModel } from '../types'
+
+function collectRefinementIssues(model: OrganizationModel): z.ZodIssue[] {
+  const issues: z.ZodIssue[] = []
+  const ctx = {
+    addIssue(issue: z.ZodIssue): void {
+      issues.push(issue)
+    }
+  } as z.RefinementCtx
+
+  refineOrganizationModel(model, ctx)
+  return issues
+}
+
+describe('refineOrganizationModel', () => {
+  it('emits resource systemPath issues through the extracted refinement boundary', () => {
+    const model: OrganizationModel = {
+      ...DEFAULT_ORGANIZATION_MODEL,
+      resources: {
+        ...DEFAULT_ORGANIZATION_MODEL.resources,
+        'missing-system-workflow': {
+          id: 'missing-system-workflow',
+          order: 10,
+          kind: 'workflow',
+          systemPath: 'missing.system',
+          status: 'active'
+        }
+      }
+    }
+
+    const issues = collectRefinementIssues(model)
+
+    expect(issues).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: z.ZodIssueCode.custom,
+          path: ['resources', 'missing-system-workflow', 'systemPath'],
+          message: 'Resource "missing-system-workflow" references unknown system path "missing.system"'
+        })
+      ])
+    )
+  })
+
+  it('uses the shared ontology reference key map for loose ontology payload references', () => {
+    const model: OrganizationModel = {
+      ...DEFAULT_ORGANIZATION_MODEL,
+      ontology: {
+        ...DEFAULT_ORGANIZATION_MODEL.ontology,
+        objectTypes: {
+          ...DEFAULT_ORGANIZATION_MODEL.ontology.objectTypes,
+          'global:object/test-object': {
+            id: 'global:object/test-object',
+            label: 'Test Object',
+            properties: {
+              badValueRef: { valueType: 'global:value-type/missing' }
+            }
+          }
+        }
+      }
+    }
+
+    const issues = collectRefinementIssues(model)
+
+    expect(issues.some((issue) => issue.message.includes('valueType references unknown value-type ontology ID'))).toBe(
+      true
+    )
+  })
+})