@elevasis/core 0.24.1 → 0.26.0

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

@@ -4,24 +4,69 @@ import { getSystem, listAllSystems } from '../helpers'
 import { defineOrganizationModel, resolveOrganizationModel, resolveOrganizationModelWithResources } from '../resolve'
 
 describe('organization-model resolve', () => {
-  it('resolves the system defaults', () => {
-    const model = resolveOrganizationModel()
-
-    expect(model.version).toBe(1)
-    expect('surfaces' in model).toBe(false)
-    expect('navigationGroups' in model).toBe(false)
-    expect(model.systems['dashboard']?.path).toBe('/')
-    expect(model.systems['sales']?.path).toBe('/sales')
-    expect(model.systems['sales.crm']?.path).toBe('/crm')
-    expect(model.systems['admin']?.requiresAdmin).toBe(true)
-    expect(model.systems['archive']?.devOnly).toBe(true)
-  })
-
-  it('resolves authored sidebar navigation with Dashboard above Business and /clients as the client route', () => {
-    const model = resolveOrganizationModel()
-    const primaryEntries = Object.entries(model.navigation.sidebar.primary).sort(
-      ([leftId, left], [rightId, right]) =>
-        (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER) ||
+  it('resolves the system defaults', () => {
+    const model = resolveOrganizationModel()
+
+    expect(model.version).toBe(1)
+    expect('surfaces' in model).toBe(false)
+    expect('navigationGroups' in model).toBe(false)
+    expect(model.systems).toEqual({})
+    expect(model.navigation.sidebar.primary).toEqual({})
+    expect(model.navigation.sidebar.bottom).toEqual({})
+  })
+
+  it('resolves authored sidebar navigation with explicit tenant systems', () => {
+    const model = resolveOrganizationModel({
+      navigation: {
+        sidebar: {
+          primary: {
+            dashboard: {
+              type: 'surface',
+              label: 'Dashboard',
+              path: '/',
+              surfaceType: 'dashboard',
+              order: 10,
+              targets: { systems: ['dashboard'] }
+            },
+            business: {
+              type: 'group',
+              label: 'Business',
+              order: 20,
+              children: {
+                clients: {
+                  type: 'surface',
+                  label: 'Clients',
+                  path: '/clients',
+                  surfaceType: 'list',
+                  icon: 'clients',
+                  order: 10,
+                  targets: { systems: ['clients'] }
+                }
+              }
+            }
+          },
+          bottom: {}
+        }
+      },
+      systems: {
+        dashboard: {
+          id: 'dashboard',
+          order: 10,
+          label: 'Dashboard',
+          lifecycle: 'active'
+        },
+        clients: {
+          id: 'clients',
+          order: 20,
+          label: 'Clients',
+          lifecycle: 'active',
+          icon: 'clients'
+        }
+      }
+    })
+    const primaryEntries = Object.entries(model.navigation.sidebar.primary).sort(
+      ([leftId, left], [rightId, right]) =>
+        (left.order ?? Number.MAX_SAFE_INTEGER) - (right.order ?? Number.MAX_SAFE_INTEGER) ||
         leftId.localeCompare(rightId)
     )
 
@@ -29,15 +74,17 @@ describe('organization-model resolve', () => {
     expect(primaryEntries[1]?.[0]).toBe('business')
 
     const business = model.navigation.sidebar.primary.business
-    expect(business?.type).toBe('group')
-    if (business?.type === 'group') {
-      expect(business.children.clients).toMatchObject({
-        type: 'surface',
-        path: '/clients',
-        targets: { systems: ['clients'] }
-      })
-    }
-  })
+    expect(business?.type).toBe('group')
+    if (business?.type === 'group') {
+      expect(business.children.clients).toMatchObject({
+        type: 'surface',
+        path: '/clients',
+        icon: 'clients',
+        targets: { systems: ['clients'] }
+      })
+    }
+    expect(model.systems.clients?.icon).toBe('clients')
+  })
 
   it('adds tenant systems additively to the merged record', () => {
     const baseSize = Object.keys(resolveOrganizationModel().systems).length
@@ -115,20 +162,20 @@ describe('organization-model resolve', () => {
   })
 
   it('preserves sibling fields when overriding a nested property', () => {
-    const model = resolveOrganizationModel({
-      branding: {
-        organizationName: 'OverriddenOrg'
-      }
+    const model = resolveOrganizationModel({
+      branding: {
+        organizationName: 'OverriddenOrg'
+      }
     })
 
-    expect(model.branding.organizationName).toBe('OverriddenOrg')
-    expect(model.branding.productName).toBe('Elevasis')
-    expect(Object.keys(model.systems).length).toBeGreaterThan(0)
-  })
-
-  it('overrides an existing system by id when the same key is supplied', () => {
-    const model = resolveOrganizationModel({
-      systems: {
+    expect(model.branding.organizationName).toBe('OverriddenOrg')
+    expect(model.branding.productName).toBe('Elevasis')
+    expect(model.systems).toEqual({})
+  })
+
+  it('overrides an existing system by id when the same key is supplied', () => {
+    const model = resolveOrganizationModel({
+      systems: {
         dashboard: {
           id: 'dashboard',
           order: 10,
@@ -281,15 +328,7 @@ describe('resolveOrganizationModelWithResources', () => {
               order: 910,
               label: 'CRM',
               enabled: true,
-              config: { retryCount: 3 },
-              content: {
-                settings: {
-                  kind: 'config',
-                  type: 'kv',
-                  label: 'Settings',
-                  data: { entries: { retryCount: 1, fromContent: true } }
-                }
-              }
+              config: { retryCount: 3, fromConfig: true }
             }
           }
         }
@@ -315,6 +354,6 @@ describe('resolveOrganizationModelWithResources', () => {
     expect(resolved.systems.sys?.resources?.map((resource) => resource.id)).toEqual(['sys-workflow'])
     expect(resolved.systems['sys.crm']?.id).toBe('sys.crm')
     expect(resolved.systems['sys.crm']?.resources?.map((resource) => resource.id)).toEqual(['crm-workflow'])
-    expect(resolved.systems['sys.crm']?.config).toEqual({ retryCount: 3, fromContent: true })
+    expect(resolved.systems['sys.crm']?.config).toEqual({ retryCount: 3, fromConfig: true })
   })
 })

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

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL, scaffoldOrganizationModel, type OrganizationModel } from '..'
+
+const BASE_MODEL: OrganizationModel = {
+  ...DEFAULT_ORGANIZATION_MODEL,
+  systems: {
+    sales: {
+      id: 'sales',
+      order: 10,
+      label: 'Sales',
+      lifecycle: 'active',
+      systems: {
+        crm: {
+          id: 'sales.crm',
+          order: 20,
+          label: 'CRM',
+          lifecycle: 'active'
+        }
+      }
+    }
+  },
+  resources: {},
+  knowledge: {}
+}
+
+describe('organization-model scaffolders', () => {
+  it('plans the minimal system scaffold without route files', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'system',
+      id: 'sales.partners',
+      label: 'Partners',
+      description: 'Partner operations.',
+      noProject: true
+    })
+
+    expect(plan.intent).toBe('system')
+    expect(plan.id).toBe('sales.partners')
+    expect(plan.edits.map((edit) => edit.path)).toEqual(
+      expect.arrayContaining([
+        'packages/elevasis-core/src/organization-model/systems.ts',
+        'packages/elevasis-core/src/organization-model/navigation.ts',
+        'packages/elevasis-core/src/organization-model/roles.ts',
+        'packages/elevasis-core/src/organization-model/assembly.ts',
+        'packages/elevasis-core/src/organization-model/knowledge.ts'
+      ])
+    )
+    expect(plan.writes.some((write) => write.path.endsWith('manifest.stub.ts'))).toBe(true)
+    expect(plan.writes.some((write) => write.path.includes('/routes/'))).toBe(false)
+    expect(plan.projectCommand).toBeUndefined()
+  })
+
+  it('defaults system scaffolds to a project chain unless skipped', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'system',
+      id: 'sales.enablement',
+      label: 'Enablement'
+    })
+
+    expect(plan.projectCommand).toContain('project:create --link-om sales.enablement')
+  })
+
+  it('keeps ontology/resource/knowledge project chains opt-in', () => {
+    const ontology = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'ontology',
+      id: 'deal-score',
+      systemPath: 'sales.crm',
+      kind: 'object'
+    })
+    const resource = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'resource',
+      id: 'crm-score-workflow',
+      systemPath: 'sales.crm'
+    })
+    const knowledge = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'knowledge',
+      id: 'knowledge.crm-scoring',
+      systemPath: 'sales.crm'
+    })
+
+    expect(ontology.projectCommand).toBeUndefined()
+    expect(resource.projectCommand).toBeUndefined()
+    expect(knowledge.projectCommand).toBeUndefined()
+  })
+
+  it('rejects duplicate system paths during planning', () => {
+    expect(() =>
+      scaffoldOrganizationModel(BASE_MODEL, {
+        intent: 'system',
+        id: 'sales.crm'
+      })
+    ).toThrow('system already exists: sales.crm')
+  })
+})

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

@@ -313,21 +313,36 @@ describe('ontology contract validation', () => {
     ])
   })
 
-  it('projects legacy entities, actions, and system content into compiled ontology indexes', () => {
+  it('projects legacy entities and actions while reading catalogs from authored ontology', () => {
     const model = OrganizationModelSchema.parse(
-      makeMinimalModel({
-        dashboard: {
-          ...makeSystem('dashboard', '/'),
-          content: {
-            pipeline: {
-              kind: 'schema',
-              type: 'pipeline',
-              label: 'Pipeline',
-              data: { entityId: 'crm.deal' }
+      {
+        ...makeMinimalModel({
+          dashboard: {
+            ...makeSystem('dashboard', '/'),
+            ontology: {
+              catalogTypes: {
+                'dashboard:catalog/pipeline': {
+                  id: 'dashboard:catalog/pipeline',
+                  kind: 'pipeline',
+                  appliesTo: 'dashboard:object/crm.deal',
+                label: 'Pipeline',
+                  entries: {
+                    open: { label: 'Open', order: 10, semanticClass: 'open' }
+                  }
+                }
+              }
             }
           }
+        }),
+        actions: {
+          send_reply: {
+            id: 'send_reply',
+            order: 10,
+            label: 'Send Reply',
+            affects: ['crm.deal']
+          }
         }
-      })
+      }
     )
 
     const compilation = compileOrganizationOntology(model)
@@ -339,19 +354,27 @@ describe('ontology contract validation', () => {
       legacyId: 'crm.deal'
     })
     expect(compilation.ontology.actionTypes['dashboard:action/send_reply']?.legacyActionId).toBe('send_reply')
-    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']).not.toHaveProperty('legacyContentId')
     expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.origin).toMatchObject({
-      source: 'legacy.system.content',
-      legacyId: 'dashboard:pipeline'
+      source: 'system:dashboard.ontology',
+      systemPath: 'dashboard'
     })
   })
 
-  it('adds origin metadata to authored and projected compiled ontology records without mutating source', () => {
+  it('adds origin metadata to authored compiled ontology records without mutating source', () => {
     const authoredObject = {
       id: 'dashboard:object/task',
       label: 'Task',
       ownerSystemId: 'dashboard'
     }
+    const authoredCatalog = {
+      id: 'dashboard:catalog/task-status',
+      label: 'Task Status',
+      kind: 'status-flow',
+      appliesTo: 'dashboard:object/task',
+      entries: {
+        planned: { label: 'Planned', order: 10 }
+      }
+    }
     const model = OrganizationModelSchema.parse({
       ...makeMinimalModel({
         dashboard: {
@@ -359,14 +382,9 @@ describe('ontology contract validation', () => {
           ontology: {
             objectTypes: {
               'dashboard:object/task': authoredObject
-            }
-          },
-          content: {
-            pipeline: {
-              kind: 'schema',
-              type: 'pipeline',
-              label: 'Pipeline',
-              data: { entityId: 'crm.deal' }
+            },
+            catalogTypes: {
+              'dashboard:catalog/task-status': authoredCatalog
             }
           }
         }
@@ -380,13 +398,13 @@ describe('ontology contract validation', () => {
       source: 'system:dashboard.ontology',
       systemPath: 'dashboard'
     })
-    expect(compilation.ontology.catalogTypes['dashboard:catalog/pipeline']?.origin).toMatchObject({
-      kind: 'projected',
-      source: 'legacy.system.content',
-      systemPath: 'dashboard',
-      legacyId: 'dashboard:pipeline'
+    expect(compilation.ontology.catalogTypes['dashboard:catalog/task-status']?.origin).toMatchObject({
+      kind: 'authored',
+      source: 'system:dashboard.ontology',
+      systemPath: 'dashboard'
     })
     expect(authoredObject).not.toHaveProperty('origin')
+    expect(authoredCatalog).not.toHaveProperty('origin')
     expect(model.systems.dashboard?.ontology?.objectTypes?.['dashboard:object/task']).not.toHaveProperty('origin')
   })
 
@@ -674,47 +692,31 @@ describe('system config contract', () => {
     expect(result.success).toBe(false)
   })
 
-  it('projects bridge-era config:kv into effective resolved system config', () => {
+  it('resolves first-class system config without bridge-era config:kv content', () => {
     const model = OrganizationModelSchema.parse(
       makeMinimalModel({
         dashboard: {
           ...makeSystem('dashboard', '/'),
           config: {
             retries: 3,
-            nested: { direct: true }
-          },
-          content: {
-            settings: {
-              kind: 'config',
-              type: 'kv',
-              label: 'Settings',
-              data: { entries: { enabled: true, retries: 1, mode: 'bridge' } }
-            }
+            mode: 'direct',
+            nested: { direct: true, enabled: true }
           }
         }
       })
     )
 
     expect(resolveSystemConfig(model, 'dashboard')).toEqual({
-      enabled: true,
       retries: 3,
-      mode: 'bridge',
-      nested: { direct: true }
+      mode: 'direct',
+      nested: { direct: true, enabled: true }
     })
 
     const resolved = resolveOrganizationModelWithResources({
       systems: {
         dashboard: {
           ...makeSystem('dashboard', '/'),
-          config: { retries: 3 },
-          content: {
-            settings: {
-              kind: 'config',
-              type: 'kv',
-              label: 'Settings',
-              data: { entries: { enabled: true, retries: 1 } }
-            }
-          }
+          config: { enabled: true, retries: 3 }
         }
       }
     })
@@ -780,8 +782,8 @@ describe('system action and policy validation', () => {
         sales: { id: 'sales', order: 10, label: 'Sales', enabled: true, lifecycle: 'active' },
         'sales.lead-gen': makeSystem('sales.lead-gen')
       }),
-      systems: {
-        sales: {
+      systems: {
+        sales: {
           id: 'sales',
           order: 10,
           label: 'Sales',
@@ -793,10 +795,17 @@ describe('system action and policy validation', () => {
           label: 'Lead Gen',
           lifecycle: 'active',
           actions: [{ actionId: 'lead-gen.company.source', intent: 'exposes' }],
-          policies: ['policy.lead-gen.approval']
-        }
-      },
-      policies: {
+          policies: ['policy.lead-gen.approval']
+        }
+      },
+      actions: {
+        'lead-gen.company.source': {
+          id: 'lead-gen.company.source',
+          order: 10,
+          label: 'Source companies'
+        }
+      },
+      policies: {
         'policy.lead-gen.approval': {
           id: 'policy.lead-gen.approval',
           order: 10,

package/src/organization-model/catalogs/lead-gen.ts

@@ -39,106 +39,3 @@ export interface LeadGenStageCatalogEntry {
   recordStageKey?: string
 }
 
-/**
- * Canonical lead-gen processing stage catalog.
- * Keys are the stage names written by workflow steps into processing_state jsonb.
- *
- * Ordered roughly by pipeline progression (prospecting -> outreach -> qualification).
- */
-export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> = {
-  // Prospecting - company population
-  scraped: {
-    key: 'scraped',
-    label: 'Scraped',
-    description: 'Company was scraped from a source directory (Apify actor run).',
-    order: 1,
-    entity: 'company'
-  },
-  populated: {
-    key: 'populated',
-    label: 'Companies found',
-    description: 'Companies have been found and added to the lead-gen list.',
-    order: 2,
-    entity: 'company'
-  },
-  crawled: {
-    key: 'crawled',
-    label: 'Websites crawled',
-    description:
-      'Company websites have been crawled (e.g. via Apify) and raw page content stored for downstream LLM analysis.',
-    order: 2.5,
-    entity: 'company'
-  },
-  extracted: {
-    key: 'extracted',
-    label: 'Websites analyzed',
-    description: 'Company websites have been analyzed for business signals.',
-    order: 3,
-    entity: 'company'
-  },
-  enriched: {
-    key: 'enriched',
-    label: 'Enriched',
-    description: 'Company or contact enriched with third-party data (e.g. Tomba, Anymailfinder).',
-    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',
-    recordEntity: 'contact',
-    recordStageKey: 'discovered'
-  },
-
-  // Prospecting - contact discovery
-  discovered: {
-    key: 'discovered',
-    label: 'Decision-makers found',
-    description: 'Decision-maker contact details have been found.',
-    order: 5,
-    entity: 'contact'
-  },
-  verified: {
-    key: 'verified',
-    label: 'Emails verified',
-    description: 'Contact email addresses have been checked for deliverability.',
-    order: 7,
-    entity: 'contact'
-  },
-
-  // Qualification
-  qualified: {
-    key: 'qualified',
-    label: 'Companies qualified',
-    description: 'Companies have been scored against the qualification criteria.',
-    order: 8,
-    entity: 'company'
-  },
-
-  // Outreach
-  personalized: {
-    key: 'personalized',
-    label: 'Personalized',
-    description: 'Outreach message personalized for the contact (Instantly personalization workflow).',
-    order: 9,
-    entity: 'contact'
-  },
-  uploaded: {
-    key: 'uploaded',
-    label: 'Reviewed and exported',
-    description: 'Approved records have been reviewed and exported for handoff.',
-    order: 10,
-    entity: 'company',
-    additionalEntities: ['contact']
-  },
-  interested: {
-    key: 'interested',
-    label: 'Interested',
-    description: 'Contact replied with a positive signal (Instantly reply-handler transition).',
-    order: 11,
-    entity: 'contact'
-  }
-}