@elevasis/core 0.18.0 → 0.20.0

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

@@ -135,6 +135,8 @@ export interface StatefulStageDefinition {
   /** Matches stage_key values written by workflow steps. */
   stageKey: string
   label: string
+  /** UI color token. Consumers may map this to their design system. */
+  color?: string
   states: StatefulStateDefinition[]
 }
 
@@ -251,6 +253,7 @@ export const CRM_PIPELINE_DEFINITION: StatefulPipelineDefinition = {
     {
       stageKey: 'interested',
       label: 'Interested',
+      color: 'blue',
       states: [
         CRM_DISCOVERY_REPLIED_STATE,
         CRM_DISCOVERY_LINK_SENT_STATE,
@@ -262,11 +265,11 @@ export const CRM_PIPELINE_DEFINITION: StatefulPipelineDefinition = {
         CRM_FOLLOWUP_3_SENT_STATE
       ]
     },
-    { stageKey: 'proposal', label: 'Proposal', states: [] },
-    { stageKey: 'closing', label: 'Closing', states: [] },
-    { stageKey: 'closed_won', label: 'Closed Won', states: [] },
-    { stageKey: 'closed_lost', label: 'Closed Lost', states: [] },
-    { stageKey: 'nurturing', label: 'Nurturing', states: [] }
+    { stageKey: 'proposal', label: 'Proposal', color: 'yellow', states: [] },
+    { stageKey: 'closing', label: 'Closing', color: 'orange', states: [] },
+    { stageKey: 'closed_won', label: 'Closed Won', color: 'green', states: [] },
+    { stageKey: 'closed_lost', label: 'Closed Lost', color: 'red', states: [] },
+    { stageKey: 'nurturing', label: 'Nurturing', color: 'grape', states: [] }
   ]
 }
 
@@ -440,21 +443,21 @@ export const LEAD_GEN_PIPELINE_DEFINITIONS: Record<string, StatefulPipelineDefin
 }
 
 // ============================================================================
-// Lead-Gen Stage Catalog (status-based processing model)
+// Lead-Gen Stage Catalog (OM Spine processing-state model)
+//
+// Canonical set of processing stage keys for acq_companies.processing_state and
+// acq_contacts.processing_state. These keys coordinate build templates, workflow
+// factory validation, API filters, and UI progress projections.
 //
-// Canonical set of processing stage keys for the status-map model that replaces
-// the stateful trait on acq_list_members and acq_list_companies. Each key maps
-// to a terminal status string in the processing_state jsonb column.
+// State is sparse: absent keys mean "not attempted"; present keys hold terminal
+// status entries such as success, no_result, skipped, or error.
 //
-// Sources:
+// Historical sources:
 //   ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE  → personalized, uploaded, interested,
 //                                          discovered, verified
 //   ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE → populated, extracted, qualified
 //   Design plan hint (lead-gen-domain-cleanup.mdx §4) → scraped, enriched
 //
-// Wave 2 will validate pipeline_config.stages[].key against this catalog at
-// list-create/update time. Each lead-gen workflow in operations will declare
-// stageImplemented: '<key>' in its WorkflowDefinition (Slice D-2).
 // ============================================================================
 
 /** One entry in the lead-gen stage catalog. */
@@ -488,15 +491,15 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
   },
   populated: {
     key: 'populated',
-    label: 'Populated',
-    description: 'Company record populated with structured data from scrape results.',
+    label: 'Companies found',
+    description: 'Companies have been found and added to the lead-gen list.',
     order: 2,
     entity: 'company'
   },
   extracted: {
     key: 'extracted',
-    label: 'Extracted',
-    description: 'Website content extracted and parsed for company intelligence.',
+    label: 'Websites analyzed',
+    description: 'Company websites have been analyzed for business signals.',
     order: 3,
     entity: 'company'
   },
@@ -507,29 +510,36 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
     order: 4,
     entity: 'company'
   },
+  'decision-makers-enriched': {
+    key: 'decision-makers-enriched',
+    label: 'Decision-makers found',
+    description: 'Decision-maker contacts discovered and attached to a qualified company.',
+    order: 6,
+    entity: 'company'
+  },
 
   // Prospecting — contact discovery
   discovered: {
     key: 'discovered',
-    label: 'Discovered',
-    description: 'Contact email address discovered via an email-discovery workflow.',
+    label: 'Decision-makers found',
+    description: 'Decision-maker contact details have been found.',
     order: 5,
     entity: 'contact'
   },
   verified: {
     key: 'verified',
-    label: 'Verified',
-    description: 'Contact email address verified as deliverable (email verification workflow).',
-    order: 6,
+    label: 'Emails verified',
+    description: 'Contact email addresses have been checked for deliverability.',
+    order: 7,
     entity: 'contact'
   },
 
   // Qualification
   qualified: {
     key: 'qualified',
-    label: 'Qualified',
-    description: 'Company passed the ICP qualification rubric (company-qualification workflow).',
-    order: 7,
+    label: 'Companies qualified',
+    description: 'Companies have been scored against the qualification criteria.',
+    order: 8,
     entity: 'company'
   },
 
@@ -538,21 +548,21 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
     key: 'personalized',
     label: 'Personalized',
     description: 'Outreach message personalized for the contact (Instantly personalization workflow).',
-    order: 8,
+    order: 9,
     entity: 'contact'
   },
   uploaded: {
     key: 'uploaded',
-    label: 'Uploaded',
-    description: 'Contact uploaded to an Instantly campaign for outreach.',
-    order: 9,
+    label: 'Reviewed and exported',
+    description: 'Approved records have been reviewed and exported for handoff.',
+    order: 10,
     entity: 'contact'
   },
   interested: {
     key: 'interested',
     label: 'Interested',
     description: 'Contact replied with a positive signal (Instantly reply-handler transition).',
-    order: 10,
+    order: 11,
     entity: 'contact'
   }
 }

package/src/organization-model/graph/build.ts

@@ -7,6 +7,7 @@ import type {
   OrganizationGraphNode,
   OrganizationGraphNodeKind
 } from './types'
+import { CAPABILITY_REGISTRY } from '../domains/prospecting'
 
 function nodeId(kind: OrganizationGraphNodeKind, sourceId?: string): string {
   return kind === 'organization' ? 'organization-model' : `${kind}:${sourceId ?? ''}`
@@ -187,6 +188,79 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
     }
   }
 
+  const allStages = [
+    ...organizationModel.prospecting.companyStages,
+    ...organizationModel.prospecting.contactStages
+  ].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+
+  for (const stage of allStages) {
+    const id = nodeId('stage', stage.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'stage',
+      label: stage.label,
+      sourceId: stage.id,
+      ...(stage.description ? { description: stage.description } : {}),
+      ...(stage.icon ? { icon: stage.icon } : {})
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+  }
+
+  for (const cap of [...CAPABILITY_REGISTRY].sort((a, b) => a.id.localeCompare(b.id))) {
+    const id = nodeId('capability', cap.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'capability',
+      label: cap.label,
+      sourceId: cap.id,
+      description: cap.description
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+    const resourceNode = ensureResourceNode(nodes, nodeIds, resourceNodesById, cap.resourceId)
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('maps_to', id, resourceNode.id),
+      kind: 'maps_to',
+      sourceId: id,
+      targetId: resourceNode.id
+    })
+  }
+
+  for (const template of [...organizationModel.prospecting.buildTemplates].sort((a, b) => a.id.localeCompare(b.id))) {
+    const stepById = new Map(template.steps.map((s) => [s.id, s]))
+    for (const step of [...template.steps].sort((a, b) => a.id.localeCompare(b.id))) {
+      const stageNodeId = nodeId('stage', step.stageKey)
+      const capNodeId = nodeId('capability', step.capabilityKey)
+      pushUniqueEdge(edges, edgeIds, {
+        id: edgeId('uses', stageNodeId, capNodeId, step.id),
+        kind: 'uses',
+        sourceId: stageNodeId,
+        targetId: capNodeId
+      })
+      for (const depId of step.dependsOn ?? []) {
+        const depStep = stepById.get(depId)
+        if (depStep) {
+          const depStageNodeId = nodeId('stage', depStep.stageKey)
+          pushUniqueEdge(edges, edgeIds, {
+            id: edgeId('references', stageNodeId, depStageNodeId, step.id),
+            kind: 'references',
+            sourceId: stageNodeId,
+            targetId: depStageNodeId
+          })
+        }
+      }
+    }
+  }
+
   if (commandViewData) {
     const commandViewResources = collectCommandViewResources(commandViewData).sort((a, b) =>
       a.resourceId.localeCompare(b.resourceId)

package/src/organization-model/graph/schema.ts

@@ -8,6 +8,7 @@ export const OrganizationGraphNodeKindSchema = z.enum([
   'surface',
   'entity',
   'capability',
+  'stage',
   'resource',
   'knowledge'
 ])

package/src/organization-model/graph/types.ts

@@ -9,6 +9,7 @@ export type OrganizationGraphNodeKind =
   | 'surface'
   | 'entity'
   | 'capability'
+  | 'stage'
   | 'resource'
   | 'knowledge'
 

package/src/organization-model/icons.ts

@@ -2,6 +2,7 @@ import { z } from 'zod'
 
 export const ORGANIZATION_MODEL_ICON_TOKENS = [
   'nav.dashboard',
+  'nav.calendar',
   'nav.sales',
   'nav.crm',
   'nav.lead-gen',
@@ -16,6 +17,7 @@ export const ORGANIZATION_MODEL_ICON_TOKENS = [
   'knowledge.strategy',
   'knowledge.reference',
   'feature.dashboard',
+  'feature.calendar',
   'feature.sales',
   'feature.crm',
   'feature.finance',
@@ -39,6 +41,7 @@ export const ORGANIZATION_MODEL_ICON_TOKENS = [
   'integration.google-sheets',
   'integration.attio',
   'surface.dashboard',
+  'surface.calendar',
   'surface.overview',
   'surface.command-view',
   'surface.command-queue',

package/src/organization-model/schema.ts

@@ -70,8 +70,14 @@ function hasFeature(featuresById: Map<string, unknown>, featureId: string): bool
   return featuresById.has(featureId) || featuresById.has(LEGACY_FEATURE_ALIASES.get(featureId) ?? '')
 }
 
+function defaultFeaturePathFor(id: string): string {
+  return `/${id.replaceAll('.', '/')}`
+}
+
 export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
   const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
+  const featureIdsByEffectivePath = new Map<string, string>()
+
   model.features.forEach((feature, featureIndex) => {
     const segments = feature.id.split('.')
     if (segments.length > 1) {
@@ -88,6 +94,21 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     const hasChildren = model.features.some(
       (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.id !== feature.id
     )
+    const contributesRoutePath = feature.path !== undefined || !hasChildren
+    if (contributesRoutePath) {
+      const effectivePath = feature.path ?? defaultFeaturePathFor(feature.id)
+      const existingFeatureId = featureIdsByEffectivePath.get(effectivePath)
+      if (existingFeatureId !== undefined) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, feature.path === undefined ? 'id' : 'path'],
+          `Feature "${feature.id}" effective path "${effectivePath}" duplicates feature "${existingFeatureId}"`
+        )
+      } else {
+        featureIdsByEffectivePath.set(effectivePath, feature.id)
+      }
+    }
+
     if (hasChildren && feature.enabled) {
       const hasEnabledDescendant = model.features.some(
         (candidate) => candidate.id.startsWith(`${feature.id}.`) && candidate.enabled
@@ -102,6 +123,48 @@ export const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((
     }
   })
 
+  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Navigation surface')
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ['navigation', 'defaultSurfaceId'],
+      `Navigation defaultSurfaceId references unknown surface "${model.navigation.defaultSurfaceId}"`
+    )
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (!surfacesById.has(surfaceId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+        )
+      }
+    })
+  })
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.featureId !== undefined && !hasFeature(featuresById, surface.featureId)) {
+      addIssue(
+        ctx,
+        ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        `Navigation surface "${surface.id}" references unknown feature "${surface.featureId}"`
+      )
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (!hasFeature(featuresById, featureId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+          `Navigation surface "${surface.id}" references unknown feature "${featureId}"`
+        )
+      }
+    })
+  })
+
   // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
   const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
   model.offerings.products.forEach((product, productIndex) => {

package/src/organization-model/surface-projection.ts

@@ -0,0 +1,218 @@
+import type { OrganizationModel, OrganizationModelFeature, OrganizationModelSurface } from './types'
+
+export type OrganizationSurfaceProjectionIssueCode =
+  | 'duplicate-surface-id'
+  | 'duplicate-surface-path'
+  | 'unknown-default-surface'
+  | 'unknown-group-surface'
+  | 'unknown-surface-feature'
+  | 'unknown-surface-feature-reference'
+
+export interface OrganizationSurfaceProjection {
+  id: string
+  label: string
+  path: string
+  surfaceType: OrganizationModelSurface['surfaceType']
+  featureId?: string
+  featureIds: string[]
+  entityIds: string[]
+  resourceIds: string[]
+  capabilityIds: string[]
+  enabled: boolean
+  devOnly?: boolean
+  requiresAdmin?: boolean
+}
+
+export interface OrganizationSurfaceProjectionIssue {
+  code: OrganizationSurfaceProjectionIssueCode
+  message: string
+  path: Array<string | number>
+  surfaceId?: string
+  featureId?: string
+  groupId?: string
+  value?: string
+}
+
+const LEGACY_FEATURE_ALIASES = new Map<string, string>([
+  ['crm', 'sales.crm'],
+  ['lead-gen', 'sales.lead-gen'],
+  ['submitted-requests', 'monitoring.submitted-requests']
+])
+
+function normalizePath(path: string): string {
+  return path.length > 1 ? path.replace(/\/+$/, '') : path
+}
+
+function collectFeaturesById(model: OrganizationModel): Map<string, OrganizationModelFeature> {
+  return new Map(model.features.map((feature) => [feature.id, feature]))
+}
+
+function resolveFeatureId(featuresById: Map<string, OrganizationModelFeature>, featureId: string): string | undefined {
+  if (featuresById.has(featureId)) {
+    return featureId
+  }
+
+  const aliasTarget = LEGACY_FEATURE_ALIASES.get(featureId)
+  return aliasTarget !== undefined && featuresById.has(aliasTarget) ? aliasTarget : undefined
+}
+
+function getFeatureWithAncestors(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureId: string
+): OrganizationModelFeature[] {
+  const features: OrganizationModelFeature[] = []
+  const segments = featureId.split('.')
+
+  for (let index = 1; index <= segments.length; index += 1) {
+    const candidate = featuresById.get(segments.slice(0, index).join('.'))
+    if (candidate) {
+      features.push(candidate)
+    }
+  }
+
+  return features
+}
+
+function hasInheritedFlag(
+  featuresById: Map<string, OrganizationModelFeature>,
+  featureIds: string[],
+  flag: 'devOnly' | 'requiresAdmin'
+): boolean {
+  return featureIds.some((featureId) =>
+    getFeatureWithAncestors(featuresById, featureId).some((feature) => feature[flag] === true)
+  )
+}
+
+function isFeatureEnabled(featuresById: Map<string, OrganizationModelFeature>, featureId: string): boolean {
+  const featureLineage = getFeatureWithAncestors(featuresById, featureId)
+  return featureLineage.length > 0 && featureLineage.every((feature) => feature.enabled)
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)]
+}
+
+export function projectOrganizationSurfaces(model: OrganizationModel): OrganizationSurfaceProjection[] {
+  const featuresById = collectFeaturesById(model)
+
+  return model.navigation.surfaces.map((surface) => {
+    const featureId = surface.featureId ? resolveFeatureId(featuresById, surface.featureId) : undefined
+    const featureIds = unique(
+      [featureId, ...surface.featureIds.map((candidate) => resolveFeatureId(featuresById, candidate))].filter(
+        (candidate): candidate is string => candidate !== undefined
+      )
+    )
+    const enabled = surface.enabled && featureIds.every((candidate) => isFeatureEnabled(featuresById, candidate))
+    const devOnly = surface.devOnly === true || hasInheritedFlag(featuresById, featureIds, 'devOnly')
+    const requiresAdmin = hasInheritedFlag(featuresById, featureId ? [featureId] : featureIds, 'requiresAdmin')
+
+    return {
+      id: surface.id,
+      label: surface.label,
+      path: surface.path,
+      surfaceType: surface.surfaceType,
+      featureId,
+      featureIds,
+      entityIds: [...surface.entityIds],
+      resourceIds: [...surface.resourceIds],
+      capabilityIds: [...surface.capabilityIds],
+      enabled,
+      ...(devOnly ? { devOnly } : {}),
+      ...(requiresAdmin ? { requiresAdmin } : {})
+    }
+  })
+}
+
+export function validateOrganizationSurfaceProjection(model: OrganizationModel): OrganizationSurfaceProjectionIssue[] {
+  const issues: OrganizationSurfaceProjectionIssue[] = []
+  const featuresById = collectFeaturesById(model)
+  const surfaceIds = new Set<string>()
+  const surfacePaths = new Map<string, string>()
+
+  function addIssue(issue: OrganizationSurfaceProjectionIssue): void {
+    issues.push(issue)
+  }
+
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surfaceIds.has(surface.id)) {
+      addIssue({
+        code: 'duplicate-surface-id',
+        message: `Surface id "${surface.id}" must be unique`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'id'],
+        surfaceId: surface.id,
+        value: surface.id
+      })
+    } else {
+      surfaceIds.add(surface.id)
+    }
+
+    const normalizedPath = normalizePath(surface.path)
+    const existingSurfaceId = surfacePaths.get(normalizedPath)
+    if (existingSurfaceId !== undefined) {
+      addIssue({
+        code: 'duplicate-surface-path',
+        message: `Surface path "${surface.path}" is already used by surface "${existingSurfaceId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'path'],
+        surfaceId: surface.id,
+        value: surface.path
+      })
+    } else {
+      surfacePaths.set(normalizedPath, surface.id)
+    }
+
+    if (surface.featureId !== undefined && resolveFeatureId(featuresById, surface.featureId) === undefined) {
+      addIssue({
+        code: 'unknown-surface-feature',
+        message: `Surface "${surface.id}" references unknown feature "${surface.featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureId'],
+        surfaceId: surface.id,
+        featureId: surface.featureId,
+        value: surface.featureId
+      })
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      if (resolveFeatureId(featuresById, featureId) !== undefined) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-surface-feature-reference',
+        message: `Surface "${surface.id}" references unknown feature "${featureId}"`,
+        path: ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+        surfaceId: surface.id,
+        featureId,
+        value: featureId
+      })
+    })
+  })
+
+  if (model.navigation.defaultSurfaceId !== undefined && !surfaceIds.has(model.navigation.defaultSurfaceId)) {
+    addIssue({
+      code: 'unknown-default-surface',
+      message: `Default surface "${model.navigation.defaultSurfaceId}" is not declared in navigation.surfaces`,
+      path: ['navigation', 'defaultSurfaceId'],
+      surfaceId: model.navigation.defaultSurfaceId,
+      value: model.navigation.defaultSurfaceId
+    })
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (surfaceIds.has(surfaceId)) {
+        return
+      }
+
+      addIssue({
+        code: 'unknown-group-surface',
+        message: `Navigation group "${group.id}" references unknown surface "${surfaceId}"`,
+        path: ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+        surfaceId,
+        groupId: group.id,
+        value: surfaceId
+      })
+    })
+  })
+
+  return issues
+}

package/src/organization-model/types.ts

@@ -12,7 +12,13 @@ import { CustomersDomainSchema, CustomerSegmentSchema, FirmographicsSchema } fro
 import { OfferingsDomainSchema, ProductSchema, PricingModelSchema } from './domains/offerings'
 import { RolesDomainSchema, RoleSchema } from './domains/roles'
 import { GoalsDomainSchema, ObjectiveSchema, KeyResultSchema } from './domains/goals'
-import { KnowledgeDomainSchema, OrgKnowledgeNodeSchema, OrgKnowledgeKindSchema } from './domains/knowledge'
+import {
+  KnowledgeDomainBindingSchema,
+  KnowledgeDomainSchema,
+  KnowledgeSkillBindingSchema,
+  OrgKnowledgeKindSchema,
+  OrgKnowledgeNodeSchema
+} from './domains/knowledge'
 import { OrganizationModelIconTokenSchema, OrganizationModelBuiltinIconTokenSchema } from './icons'
 import { OrganizationModelSchema } from './schema'
 
@@ -47,6 +53,8 @@ export type OrganizationModelKeyResult = z.infer<typeof KeyResultSchema>
 export type OrganizationModelKnowledge = z.infer<typeof KnowledgeDomainSchema>
 export type OrgKnowledgeNode = z.infer<typeof OrgKnowledgeNodeSchema>
 export type OrgKnowledgeKind = z.infer<typeof OrgKnowledgeKindSchema>
+export type KnowledgeSkillBinding = z.infer<typeof KnowledgeSkillBindingSchema>
+export type KnowledgeDomainBinding = z.infer<typeof KnowledgeDomainBindingSchema>
 export type OrganizationModelIconToken = z.infer<typeof OrganizationModelIconTokenSchema>
 export type OrganizationModelBuiltinIconToken = z.infer<typeof OrganizationModelBuiltinIconTokenSchema>
 

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.7.5'
+  CURRENT: '1.8.6'
 }