@elevasis/core 0.17.0 → 0.19.0

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

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest'
-import { OrgKnowledgeNodeSchema, OrgKnowledgeKindSchema, KnowledgeDomainSchema } from '../domains/knowledge'
+import {
+  OrgKnowledgeNodeSchema,
+  OrgKnowledgeKindSchema,
+  KnowledgeDomainSchema,
+  KnowledgeLinkSchema
+} from '../domains/knowledge'
 import { OrganizationGraphEdgeKindSchema } from '../graph/schema'
 import { buildOrganizationGraph } from '../graph/build'
 import { DEFAULT_ORGANIZATION_MODEL, DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE } from '../defaults'
@@ -212,3 +217,115 @@ describe('buildOrganizationGraph with knowledge', () => {
     expect(defaultKnowledgeNodes).toHaveLength(0)
   })
 })
+
+// ---------------------------------------------------------------------------
+// KnowledgeLinkSchema — nodeId format validation
+// ---------------------------------------------------------------------------
+
+describe('KnowledgeLinkSchema', () => {
+  it('accepts a valid kind:dotted-path nodeId', () => {
+    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'feature:sales.crm' })).not.toThrow()
+    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'feature:sales.lead-gen' })).not.toThrow()
+  })
+
+  it('accepts resource: and knowledge: prefixed node IDs', () => {
+    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'resource:my-resource' })).not.toThrow()
+    expect(() => KnowledgeLinkSchema.parse({ nodeId: 'knowledge:knowledge.test-doc' })).not.toThrow()
+  })
+
+  it('rejects a bare dotted ID with no kind: prefix', () => {
+    // NodeIdStringSchema requires kind:dotted-path format
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: 'sales.crm' }).success).toBe(false)
+  })
+
+  it('rejects an empty nodeId', () => {
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: '' }).success).toBe(false)
+  })
+
+  it('rejects a nodeId with uppercase characters', () => {
+    // NodeIdStringSchema regex requires lowercase
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: 'Feature:Sales.CRM' }).success).toBe(false)
+  })
+
+  it('rejects a link missing the nodeId field', () => {
+    expect(KnowledgeLinkSchema.safeParse({}).success).toBe(false)
+  })
+
+  it('rejects a plain number as nodeId', () => {
+    expect(KnowledgeLinkSchema.safeParse({ nodeId: 123 }).success).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OrgKnowledgeNodeSchema — field length constraints
+// ---------------------------------------------------------------------------
+
+describe('OrgKnowledgeNodeSchema length constraints', () => {
+  const BASE = {
+    id: 'knowledge.test-node',
+    kind: 'playbook',
+    title: 'Test Node',
+    summary: 'A valid summary.',
+    body: 'Body content.',
+    links: [],
+    ownerIds: [],
+    updatedAt: '2026-05-01'
+  }
+
+  it('rejects title exceeding 200 characters', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, title: 'x'.repeat(201) })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts title exactly at 200 characters', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, title: 'x'.repeat(200) })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects summary exceeding 1000 characters', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, summary: 'x'.repeat(1001) })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts summary exactly at 1000 characters', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, summary: 'x'.repeat(1000) })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects empty title', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, title: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty summary', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, summary: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects empty body', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, body: '' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects id with uppercase characters', () => {
+    // ModelIdSchema requires lowercase kebab/dot/underscore separated IDs
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, id: 'Knowledge.Test' })
+    expect(result.success).toBe(false)
+  })
+
+  it('rejects id exceeding 100 characters', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, id: 'knowledge.' + 'a'.repeat(95) })
+    expect(result.success).toBe(false)
+  })
+
+  it('accepts a valid custom icon token on a node', () => {
+    const result = OrgKnowledgeNodeSchema.safeParse({ ...BASE, icon: 'custom.my-icon' })
+    expect(result.success).toBe(true)
+  })
+
+  it('trims whitespace from title and summary', () => {
+    const node = OrgKnowledgeNodeSchema.parse({ ...BASE, title: '  Trimmed  ', summary: '  Summary.  ' })
+    expect(node.title).toBe('Trimmed')
+    expect(node.summary).toBe('Summary.')
+  })
+})

package/src/organization-model/__tests__/prospecting-ssot.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest'
+import { LEAD_GEN_STAGE_CATALOG } from '../domains/sales'
+import {
+  CAPABILITY_REGISTRY,
+  DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
+  PROSPECTING_STEPS
+} from '../domains/prospecting'
+
+const EXPECTED_CAPABILITY_REGISTRY = {
+  'lead-gen.company.source': 'lgn-import-workflow',
+  'lead-gen.company.apollo-import': 'lgn-01c-apollo-import-workflow',
+  'lead-gen.contact.discover': 'lgn-04-email-discovery-workflow',
+  'lead-gen.contact.verify-email': 'lgn-05-email-verification-workflow',
+  'lead-gen.company.website-extract': 'lgn-02-website-extract-workflow',
+  'lead-gen.company.qualify': 'lgn-03-company-qualification-workflow',
+  'lead-gen.company.dtc-subscription-qualify': 'lgn-03b-dtc-subscription-score-workflow',
+  'lead-gen.contact.apollo-decision-maker-enrich': 'lgn-04b-apollo-decision-maker-enrich-workflow',
+  'lead-gen.contact.personalize': 'ist-personalization-workflow',
+  'lead-gen.review.outreach-ready': 'ist-upload-contacts-workflow',
+  'lead-gen.export.list': 'lgn-06-export-list-workflow',
+  'lead-gen.company.cleanup': 'lgn-company-cleanup-workflow'
+}
+
+describe('prospecting organization-model SSOT', () => {
+  it('catalogs the DTC decision-maker enrichment stage', () => {
+    expect(LEAD_GEN_STAGE_CATALOG['decision-makers-enriched']).toEqual({
+      key: 'decision-makers-enriched',
+      label: 'Decision-makers found',
+      description: 'Decision-maker contacts discovered and attached to a qualified company.',
+      order: 6,
+      entity: 'company'
+    })
+  })
+
+  it('scopes prospecting steps per build template', () => {
+    expect(PROSPECTING_STEPS.localServices.findContacts).toMatchObject({
+      id: 'find-contacts',
+      primaryEntity: 'contact',
+      stageKey: 'discovered'
+    })
+    expect(PROSPECTING_STEPS.dtcApolloClickup.enrichDecisionMakers).toMatchObject({
+      id: 'enrich-decision-makers',
+      primaryEntity: 'company',
+      stageKey: 'decision-makers-enriched'
+    })
+  })
+
+  it('uses catalog stage keys for every prospecting step', () => {
+    const catalogKeys = new Set(Object.keys(LEAD_GEN_STAGE_CATALOG))
+
+    for (const templateSteps of Object.values(PROSPECTING_STEPS)) {
+      for (const step of Object.values(templateSteps)) {
+        expect(catalogKeys.has(step.stageKey), step.id).toBe(true)
+      }
+    }
+  })
+
+  it('uses registered capabilities for every prospecting step', () => {
+    const capabilityKeys = new Set(Object.keys(CAPABILITY_REGISTRY))
+
+    for (const templateSteps of Object.values(PROSPECTING_STEPS)) {
+      for (const step of Object.values(templateSteps)) {
+        expect(capabilityKeys.has(step.capabilityKey), step.id).toBe(true)
+      }
+    }
+  })
+
+  it('derives prospecting lifecycle stages from the stage catalog by entity', () => {
+    const expectedCompanyStages = Object.values(LEAD_GEN_STAGE_CATALOG)
+      .filter((stage) => stage.entity === 'company')
+      .sort((a, b) => a.order - b.order)
+      .map(({ key, label, order }) => ({ id: key, label, order }))
+
+    const expectedContactStages = Object.values(LEAD_GEN_STAGE_CATALOG)
+      .filter((stage) => stage.entity === 'contact')
+      .sort((a, b) => a.order - b.order)
+      .map(({ key, label, order }) => ({ id: key, label, order }))
+
+    expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.companyStages).toEqual(expectedCompanyStages)
+    expect(DEFAULT_ORGANIZATION_MODEL_PROSPECTING.contactStages).toEqual(expectedContactStages)
+  })
+
+  it('build templates reference PROSPECTING_STEPS entries', () => {
+    const [localServices, dtcApolloClickup] = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates
+
+    expect(localServices?.steps).toEqual(Object.values(PROSPECTING_STEPS.localServices))
+    expect(dtcApolloClickup?.steps).toEqual(Object.values(PROSPECTING_STEPS.dtcApolloClickup))
+  })
+
+  it('covers all known lead-gen capability registry entries', () => {
+    expect(CAPABILITY_REGISTRY).toEqual(EXPECTED_CAPABILITY_REGISTRY)
+    expect(Object.keys(CAPABILITY_REGISTRY)).toHaveLength(12)
+  })
+})

package/src/organization-model/defaults.ts

@@ -150,6 +150,14 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       uiPosition: 'sidebar-primary'
     },
+    {
+      id: 'monitoring.calendar',
+      label: 'Calendar',
+      description: 'Google Calendar events and agenda views',
+      enabled: true,
+      path: '/monitoring/calendar',
+      icon: 'feature.calendar'
+    },
     {
       id: 'monitoring.activity-log',
       label: 'Activity Log',

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

@@ -12,6 +12,9 @@ export const KnowledgeLinkSchema = z.object({
   nodeId: NodeIdStringSchema
 })
 
+export const KnowledgeSkillBindingSchema = z.string().trim().min(1).max(120)
+export const KnowledgeDomainBindingSchema = z.string().trim().min(1).max(80)
+
 // ---------------------------------------------------------------------------
 // OrgKnowledgeNode — single schema, `kind` discriminator drives presentation.
 // Phase 1: body is raw MDX string (lossless migration from operations/ docs).
@@ -33,6 +36,10 @@ export const OrgKnowledgeNodeSchema = z.object({
    * Each link emits a `governs` edge: knowledge-node -> target node.
    */
   links: z.array(KnowledgeLinkSchema).default([]),
+  /** Operator skill or command bindings relevant to this node. */
+  skills: z.array(KnowledgeSkillBindingSchema).optional(),
+  /** Domain key used to derive fast graph->skill registries. */
+  domain: KnowledgeDomainBindingSchema.optional(),
   /** Identifiers of the roles or members who own this knowledge node. */
   ownerIds: z.array(ModelIdSchema).default([]),
   /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
@@ -50,4 +57,6 @@ export const KnowledgeDomainSchema = z.object({
 export type OrgKnowledgeNode = z.infer<typeof OrgKnowledgeNodeSchema>
 export type OrgKnowledgeKind = z.infer<typeof OrgKnowledgeKindSchema>
 export type KnowledgeLink = z.infer<typeof KnowledgeLinkSchema>
+export type KnowledgeSkillBinding = z.infer<typeof KnowledgeSkillBindingSchema>
+export type KnowledgeDomainBinding = z.infer<typeof KnowledgeDomainBindingSchema>
 export type KnowledgeDomain = z.infer<typeof KnowledgeDomainSchema>