@elevasis/core 0.26.0 → 0.27.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__/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
+    )
+  })
+})

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

@@ -0,0 +1,175 @@
+/**
+ * Browser-safe shared cross-reference index for the Organization Model.
+ *
+ * This module is the single source of truth for OM cross-reference resolution.
+ * It is consumed by:
+ *   - `OrganizationModelSchema.superRefine` (Zod validation, browser-safe)
+ *   - `packages/cli/src/knowledge/verify.ts` (CLI gate, Node-only)
+ *
+ * INVARIANT: No Node.js builtins, no `@repo/elevasis-core` import, no dynamic import().
+ */
+
+import { compileOrganizationOntology } from './ontology'
+import { listAllSystems } from './helpers'
+import type { OntologyKind } from './ontology'
+import type { OrganizationModel } from './types'
+
+// ---------------------------------------------------------------------------
+// Shared key-to-kind map
+// ---------------------------------------------------------------------------
+
+/**
+ * Maps ontology reference field keys (as they appear inside ontology records
+ * and resource ontology bindings) to their expected OntologyKind.
+ *
+ * Single source of truth — replaces both the byte-identical
+ * `ontologyReferenceKeyKinds` in `schema.ts` and `genericReferenceKeyKinds`
+ * in `verify.ts`.
+ */
+export const ONTOLOGY_REFERENCE_KEY_KINDS: Record<string, OntologyKind> = {
+  valueType: 'value-type',
+  catalogType: 'catalog',
+  objectType: 'object',
+  eventType: 'event',
+  actionType: 'action',
+  linkType: 'link',
+  interfaceType: 'interface',
+  propertyType: 'property',
+  groupType: 'group',
+  surfaceType: 'surface',
+  stepCatalog: 'catalog'
+} satisfies Record<string, OntologyKind>
+
+// ---------------------------------------------------------------------------
+// Cross-reference index
+// ---------------------------------------------------------------------------
+
+/**
+ * Pre-built look-up sets derived from a resolved OrganizationModel.
+ * Built once, then consumed by both validation paths (superRefine + verify.ts).
+ */
+export interface OmCrossRefIndex {
+  /**
+   * Systems keyed by BOTH dotted path (e.g. "sales.lead-gen") AND system.id.
+   * Value is opaque (`unknown`) — consumers only call `.has()`.
+   */
+  systemsById: Map<string, unknown>
+  resourceIds: Set<string>
+  knowledgeIds: Set<string>
+  roleIds: Set<string>
+  goalIds: Set<string>
+  actionIds: Set<string>
+  customerSegmentIds: Set<string>
+  offeringIds: Set<string>
+  ontologyIds: Set<string>
+  /** Ontology records indexed by kind (value is a plain id→record map). */
+  ontologyIndexByKind: Record<OntologyKind, Record<string, unknown>>
+  /** IDs of individual stage entries from all catalogs with `kind === 'stage'`. */
+  stageIds: Set<string>
+}
+
+/**
+ * Build the OmCrossRefIndex from a resolved OrganizationModel.
+ *
+ * Call once per validation pass and share the result across all checks.
+ */
+export function buildOmCrossRefIndex(model: OrganizationModel): OmCrossRefIndex {
+  // Systems: keyed by path AND by system.id (path-OR-id resolution)
+  const systemsById = new Map<string, unknown>()
+  for (const { path, system } of listAllSystems(model)) {
+    systemsById.set(path, system)
+    systemsById.set(system.id, system)
+  }
+
+  const resourceIds = new Set(Object.keys(model.resources ?? {}))
+  const knowledgeIds = new Set(Object.keys(model.knowledge ?? {}))
+  const roleIds = new Set(Object.keys(model.roles ?? {}))
+  const goalIds = new Set(Object.keys(model.goals ?? {}))
+  const actionIds = new Set(Object.keys(model.actions ?? {}))
+  const customerSegmentIds = new Set(Object.keys(model.customers ?? {}))
+  const offeringIds = new Set(Object.keys(model.offerings ?? {}))
+
+  const ontologyCompilation = compileOrganizationOntology(model)
+
+  const ontologyIndexByKind: Record<OntologyKind, Record<string, unknown>> = {
+    object: ontologyCompilation.ontology.objectTypes,
+    link: ontologyCompilation.ontology.linkTypes,
+    action: ontologyCompilation.ontology.actionTypes,
+    catalog: ontologyCompilation.ontology.catalogTypes,
+    event: ontologyCompilation.ontology.eventTypes,
+    interface: ontologyCompilation.ontology.interfaceTypes,
+    'value-type': ontologyCompilation.ontology.valueTypes,
+    property: ontologyCompilation.ontology.sharedProperties,
+    group: ontologyCompilation.ontology.groups,
+    surface: ontologyCompilation.ontology.surfaces
+  }
+
+  const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index) => Object.keys(index)))
+
+  // Stage IDs: entry keys from all catalogs whose kind === 'stage'
+  const stageIds = new Set<string>()
+  for (const catalog of Object.values(ontologyCompilation.ontology.catalogTypes)) {
+    if ((catalog as { kind?: string }).kind !== 'stage') continue
+    const entries = (catalog as { entries?: Record<string, unknown> }).entries
+    if (entries !== undefined) {
+      for (const stageId of Object.keys(entries)) {
+        stageIds.add(stageId)
+      }
+    }
+  }
+
+  return {
+    systemsById,
+    resourceIds,
+    knowledgeIds,
+    roleIds,
+    goalIds,
+    actionIds,
+    customerSegmentIds,
+    offeringIds,
+    ontologyIds,
+    ontologyIndexByKind,
+    stageIds
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Canonical resolution functions
+// ---------------------------------------------------------------------------
+
+/**
+ * The ONLY definition of which (kind, id) knowledge-link targets resolve.
+ *
+ * Fixes two confirmed divergences vs. the old inline `exists()` in verify.ts:
+ *  1. `kind === 'stage'` — previously missing in verify.ts, causing a false-positive error.
+ *  2. `kind === 'system'` — resolves via `systemsById` which is keyed by BOTH path AND
+ *     `system.id`, so a system referenced by its id (not its dotted path) is also found.
+ */
+export function knowledgeTargetExists(index: OmCrossRefIndex, kind: string, id: string): boolean {
+  if (kind === 'system') return index.systemsById.has(id)
+  if (kind === 'resource') return index.resourceIds.has(id)
+  if (kind === 'knowledge') return index.knowledgeIds.has(id)
+  if (kind === 'stage') return index.stageIds.has(id)
+  if (kind === 'action') return index.actionIds.has(id)
+  if (kind === 'role') return index.roleIds.has(id)
+  if (kind === 'goal') return index.goalIds.has(id)
+  if (kind === 'customer-segment') return index.customerSegmentIds.has(id)
+  if (kind === 'offering') return index.offeringIds.has(id)
+  if (kind === 'ontology') return index.ontologyIds.has(id)
+  return false
+}
+
+/**
+ * Returns `true` when a resource ontology binding references an ontology ID
+ * that does not exist in the compiled index for the expected kind.
+ *
+ * Shared between `schema.ts` resource-ontology binding validation and
+ * `verify.ts` resource ontology reference checks.
+ */
+export function resourceOntologyBindingMissing(
+  index: OmCrossRefIndex,
+  expectedKind: OntologyKind,
+  ontologyId: string
+): boolean {
+  return index.ontologyIndexByKind[expectedKind][ontologyId] === undefined
+}

package/src/organization-model/domains/branding.ts

@@ -14,9 +14,9 @@ export const OrganizationModelBrandingSchema = z.object({
     .default({})
 })
 
-export const DEFAULT_ORGANIZATION_MODEL_BRANDING: z.infer<typeof OrganizationModelBrandingSchema> = {
-  organizationName: 'Default Organization',
-  productName: 'Elevasis',
-  shortName: 'Elevasis',
-  logos: {}
-}
+export const DEFAULT_ORGANIZATION_MODEL_BRANDING: z.infer<typeof OrganizationModelBrandingSchema> = {
+  organizationName: 'Default Organization',
+  productName: 'Organization OS',
+  shortName: 'Org OS',
+  logos: {}
+}