@elevasis/core 0.22.0 → 0.24.0

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

@@ -0,0 +1,333 @@
+import { z } from 'zod'
+import { EntityIdSchema } from './entities'
+import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
+
+export const ActionResourceIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(255)
+  .regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, 'Resource IDs must use letters, numbers, -, _, or . separators')
+
+export const ActionInvocationKindSchema = z
+  .enum(['slash-command', 'mcp-tool', 'api-endpoint', 'script-execution'])
+  .meta({ label: 'Invocation kind' })
+
+export const ActionIdSchema = ModelIdSchema
+
+export const ActionScopeSchema = z.union([
+  z.literal('global'),
+  z.object({
+    domain: ModelIdSchema
+  })
+])
+
+export const ActionRefSchema = z.object({
+  actionId: ActionIdSchema.meta({ ref: 'action' }),
+  intent: z.enum(['exposes', 'consumes']).meta({ label: 'Intent' })
+})
+
+export const SlashCommandInvocationSchema = z.object({
+  kind: z.literal('slash-command'),
+  command: z
+    .string()
+    .trim()
+    .min(1)
+    .max(200)
+    .regex(/^\/[^\s].*$/, 'Slash commands must start with /'),
+  toolFactory: ModelIdSchema.optional()
+})
+
+export const McpToolInvocationSchema = z.object({
+  kind: z.literal('mcp-tool'),
+  server: ModelIdSchema,
+  name: ModelIdSchema
+})
+
+export const ApiEndpointInvocationSchema = z.object({
+  kind: z.literal('api-endpoint'),
+  method: z.enum(['GET', 'POST', 'PATCH', 'DELETE']).meta({ label: 'HTTP method' }),
+  path: z.string().trim().startsWith('/').max(500),
+  requestSchema: ModelIdSchema.optional(),
+  responseSchema: ModelIdSchema.optional()
+})
+
+export const ScriptExecutionInvocationSchema = z.object({
+  kind: z.literal('script-execution'),
+  resourceId: ActionResourceIdSchema
+})
+
+export const ActionInvocationSchema = z.discriminatedUnion('kind', [
+  SlashCommandInvocationSchema,
+  McpToolInvocationSchema,
+  ApiEndpointInvocationSchema,
+  ScriptExecutionInvocationSchema
+])
+
+export const ActionSchema = z.object({
+  id: ActionIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  scope: ActionScopeSchema.default('global'),
+  resourceId: ActionResourceIdSchema.optional(),
+  affects: z.array(EntityIdSchema.meta({ ref: 'entity' })).optional(),
+  invocations: z.array(ActionInvocationSchema).default([]),
+  knowledge: z
+    .array(ModelIdSchema.meta({ ref: 'knowledge' }))
+    .default([])
+    .optional(),
+  lifecycle: z
+    .enum(['draft', 'beta', 'active', 'deprecated', 'archived'])
+    .meta({ label: 'Lifecycle', color: 'teal' })
+    .default('active')
+})
+
+export const ActionsDomainSchema = z
+  .record(z.string(), ActionSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each action entry id must match its map key'
+  })
+  .default({})
+
+const LEAD_GEN_ACTION_ENTRY_INPUTS: z.input<typeof ActionSchema>[] = [
+  {
+    id: 'lead-gen.company.source',
+    order: 10,
+    label: 'Source companies',
+    description: 'Import source companies from a list provider.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-import-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/source' }]
+  },
+  {
+    id: 'lead-gen.company.apollo-import',
+    order: 20,
+    label: 'Import from Apollo',
+    description: 'Pull companies and seed contact data from an Apollo search or list.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-01c-apollo-import-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/apollo-import' }]
+  },
+  {
+    id: 'lead-gen.contact.discover',
+    order: 30,
+    label: 'Discover contact emails',
+    description: 'Find email addresses for contacts at qualified companies.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-04-email-discovery-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/contacts/discover' }]
+  },
+  {
+    id: 'lead-gen.contact.verify-email',
+    order: 40,
+    label: 'Verify emails',
+    description: 'Check email deliverability before outreach.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-05-email-verification-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/contacts/verify-email' }]
+  },
+  {
+    id: 'lead-gen.company.apify-crawl',
+    order: 50,
+    label: 'Crawl websites',
+    description:
+      'Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-02a-apify-website-crawl-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/apify-crawl' }]
+  },
+  {
+    id: 'lead-gen.company.website-extract',
+    order: 60,
+    label: 'Extract website signals',
+    description: 'Scrape and analyze company websites for qualification signals.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-02-website-extract-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/website-extract' }]
+  },
+  {
+    id: 'lead-gen.company.qualify',
+    order: 70,
+    label: 'Qualify companies',
+    description: 'Score and filter companies against the ICP rubric.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-03-company-qualification-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/qualify' }]
+  },
+  {
+    id: 'lead-gen.company.dtc-subscription-qualify',
+    order: 80,
+    label: 'Qualify DTC subscription fit',
+    description: 'Classify subscription potential and consumable-product fit for DTC brands.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-03b-dtc-subscription-score-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/dtc-subscription-qualify' }]
+  },
+  {
+    id: 'lead-gen.contact.apollo-decision-maker-enrich',
+    order: 90,
+    label: 'Enrich decision-makers',
+    description: 'Find and enrich qualified contacts at qualified companies via Apollo.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-04b-apollo-decision-maker-enrich-workflow',
+    invocations: [
+      { kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/contacts/apollo-decision-maker-enrich' }
+    ]
+  },
+  {
+    id: 'lead-gen.contact.personalize',
+    order: 100,
+    label: 'Personalize outreach',
+    description: 'Generate personalized opening lines for each contact.',
+    scope: { domain: 'sales' },
+    resourceId: 'ist-personalization-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/contacts/personalize' }]
+  },
+  {
+    id: 'lead-gen.review.outreach-ready',
+    order: 110,
+    label: 'Upload to outreach',
+    description: 'Upload approved contacts to the outreach sequence after QC review.',
+    scope: { domain: 'sales' },
+    resourceId: 'ist-upload-contacts-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/review/outreach-ready' }]
+  },
+  {
+    id: 'lead-gen.export.list',
+    order: 120,
+    label: 'Export lead list',
+    description: 'Export approved leads as a downloadable lead list.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-06-export-list-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/export/list' }]
+  },
+  {
+    id: 'lead-gen.company.cleanup',
+    order: 130,
+    label: 'Clean up companies',
+    description: 'Remove disqualified or duplicate companies from the list.',
+    scope: { domain: 'sales' },
+    resourceId: 'lgn-company-cleanup-workflow',
+    invocations: [{ kind: 'api-endpoint', method: 'POST', path: '/api/prospecting/companies/cleanup' }]
+  }
+]
+
+export const LEAD_GEN_ACTION_ENTRIES: Record<string, z.infer<typeof ActionSchema>> = Object.fromEntries(
+  LEAD_GEN_ACTION_ENTRY_INPUTS.map((action) => {
+    const parsed = ActionSchema.parse(action)
+    return [parsed.id, parsed]
+  })
+)
+
+const CRM_ACTION_ENTRY_INPUTS: z.input<typeof ActionSchema>[] = [
+  {
+    id: 'send_reply',
+    order: 210,
+    label: 'Send Reply',
+    description: 'Send a contextual reply for an active CRM deal.',
+    scope: { domain: 'sales' },
+    resourceId: 'crm-send-reply-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'send_link',
+    order: 220,
+    label: 'Send Booking Link',
+    description: 'Send a booking link to move a deal toward a scheduled call.',
+    scope: { domain: 'sales' },
+    resourceId: 'crm-send-booking-link-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'send_nudge',
+    order: 230,
+    label: 'Send Nudge',
+    description: 'Send a follow-up nudge for a stalled CRM deal.',
+    scope: { domain: 'sales' },
+    resourceId: 'crm-send-nudge-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'rebook',
+    order: 240,
+    label: 'Rebook',
+    description: 'Rebook a missed or rescheduled CRM appointment.',
+    scope: { domain: 'sales' },
+    resourceId: 'crm-rebook-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'move_to_proposal',
+    order: 250,
+    label: 'Move to Proposal',
+    description: 'Advance a qualified CRM deal into the proposal stage.',
+    scope: { domain: 'sales' },
+    resourceId: 'move_to_proposal-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'move_to_closing',
+    order: 260,
+    label: 'Move to Closing',
+    description: 'Advance a proposal-stage CRM deal into closing.',
+    scope: { domain: 'sales' },
+    resourceId: 'move_to_closing-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'move_to_closed_won',
+    order: 270,
+    label: 'Close Won',
+    description: 'Mark a CRM deal as closed won.',
+    scope: { domain: 'sales' },
+    resourceId: 'move_to_closed_won-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'move_to_closed_lost',
+    order: 280,
+    label: 'Close Lost',
+    description: 'Mark a CRM deal as closed lost.',
+    scope: { domain: 'sales' },
+    resourceId: 'move_to_closed_lost-workflow',
+    affects: ['crm.deal']
+  },
+  {
+    id: 'move_to_nurturing',
+    order: 290,
+    label: 'Move to Nurturing',
+    description: 'Move a CRM deal into nurturing for future follow-up.',
+    scope: { domain: 'sales' },
+    resourceId: 'move_to_nurturing-workflow',
+    affects: ['crm.deal']
+  }
+]
+
+export const CRM_ACTION_ENTRIES: Record<string, z.infer<typeof ActionSchema>> = Object.fromEntries(
+  CRM_ACTION_ENTRY_INPUTS.map((action) => {
+    const parsed = ActionSchema.parse(action)
+    return [parsed.id, parsed]
+  })
+)
+
+export const DEFAULT_ORGANIZATION_MODEL_ACTIONS: z.infer<typeof ActionsDomainSchema> = {
+  ...LEAD_GEN_ACTION_ENTRIES,
+  ...CRM_ACTION_ENTRIES
+}
+
+export function findOrganizationActionById(
+  id: string,
+  actions: z.infer<typeof ActionsDomainSchema> = DEFAULT_ORGANIZATION_MODEL_ACTIONS
+): z.infer<typeof ActionSchema> | undefined {
+  return actions[id]
+}
+
+export type ActionId = z.infer<typeof ActionIdSchema>
+export type ActionScope = z.infer<typeof ActionScopeSchema>
+export type ActionRef = z.infer<typeof ActionRefSchema>
+export type ActionInvocationKind = z.infer<typeof ActionInvocationKindSchema>
+export type ActionInvocation = z.infer<typeof ActionInvocationSchema>
+export type Action = z.infer<typeof ActionSchema>
+export type ActionsDomain = z.infer<typeof ActionsDomainSchema>

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

@@ -30,6 +30,8 @@ export const FirmographicsSchema = z.object({
 export const CustomerSegmentSchema = z.object({
   /** Stable unique identifier for the segment (e.g. "segment-smb-agencies"). */
   id: z.string().trim().min(1).max(100),
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
   /** Human-readable name shown to agents and in UI (e.g. "SMB Marketing Agencies"). */
   name: z.string().trim().max(200).default(''),
   /** One or two sentences describing who this segment is. */
@@ -59,17 +61,18 @@ export const CustomerSegmentSchema = z.object({
 })
 
 // ---------------------------------------------------------------------------
-// Customers domain schema — a collection of customer segments.
+// Customers domain schema — id-keyed map of customer segments.
 // ---------------------------------------------------------------------------
 
-export const CustomersDomainSchema = z.object({
-  segments: z.array(CustomerSegmentSchema).default([])
-})
+export const CustomersDomainSchema = z
+  .record(z.string(), CustomerSegmentSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each segment entry id must match its map key'
+  })
+  .default({})
 
 // ---------------------------------------------------------------------------
 // Seed — empty by default; adapters populate with real segment definitions.
 // ---------------------------------------------------------------------------
 
-export const DEFAULT_ORGANIZATION_MODEL_CUSTOMERS: z.infer<typeof CustomersDomainSchema> = {
-  segments: []
-}
+export const DEFAULT_ORGANIZATION_MODEL_CUSTOMERS: z.infer<typeof CustomersDomainSchema> = {}

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

@@ -0,0 +1,144 @@
+import { z } from 'zod'
+import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
+
+export const EntityIdSchema = ModelIdSchema
+
+export const EntityLinkKindSchema = z
+  .enum(['belongs-to', 'has-many', 'has-one', 'many-to-many'])
+  .meta({ label: 'Link kind' })
+
+export const EntityLinkSchema = z.object({
+  toEntity: EntityIdSchema.meta({ ref: 'entity' }),
+  kind: EntityLinkKindSchema,
+  via: z.string().trim().min(1).max(255).optional(),
+  label: LabelSchema.optional()
+})
+
+export const EntitySchema = z.object({
+  id: EntityIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  ownedBySystemId: ModelIdSchema.meta({ ref: 'system' }),
+  table: z.string().trim().min(1).max(255).optional(),
+  rowSchema: ModelIdSchema.optional(),
+  stateCatalogId: ModelIdSchema.optional(),
+  links: z.array(EntityLinkSchema).optional()
+})
+
+export const EntitiesDomainSchema = z
+  .record(z.string(), EntitySchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each entity entry id must match its map key'
+  })
+  .default({})
+
+const ENTITY_ENTRY_INPUTS: z.input<typeof EntitySchema>[] = [
+  {
+    id: 'crm.deal',
+    order: 10,
+    label: 'Deal',
+    description: 'A CRM opportunity or sales pipeline record.',
+    ownedBySystemId: 'sales.crm',
+    table: 'crm_deals',
+    stateCatalogId: 'crm.pipeline',
+    links: [{ toEntity: 'crm.contact', kind: 'has-many', via: 'deal_contacts', label: 'contacts' }]
+  },
+  {
+    id: 'crm.contact',
+    order: 20,
+    label: 'CRM Contact',
+    description: 'A person associated with a CRM relationship or deal.',
+    ownedBySystemId: 'sales.crm',
+    table: 'crm_contacts'
+  },
+  {
+    id: 'leadgen.list',
+    order: 30,
+    label: 'Lead List',
+    description: 'A prospecting list that groups companies and contacts for acquisition workflows.',
+    ownedBySystemId: 'sales.lead-gen',
+    table: 'acq_lists',
+    links: [
+      { toEntity: 'leadgen.company', kind: 'has-many', via: 'acq_list_companies', label: 'companies' },
+      { toEntity: 'leadgen.contact', kind: 'has-many', via: 'acq_list_members', label: 'contacts' }
+    ]
+  },
+  {
+    id: 'leadgen.company',
+    order: 40,
+    label: 'Lead Company',
+    description: 'A company record sourced, enriched, and qualified during prospecting.',
+    ownedBySystemId: 'sales.lead-gen',
+    table: 'acq_list_companies',
+    stateCatalogId: 'lead-gen.company',
+    links: [
+      { toEntity: 'leadgen.list', kind: 'belongs-to', via: 'list_id', label: 'list' },
+      { toEntity: 'leadgen.contact', kind: 'has-many', via: 'company_id', label: 'contacts' }
+    ]
+  },
+  {
+    id: 'leadgen.contact',
+    order: 50,
+    label: 'Lead Contact',
+    description: 'A prospect contact discovered or enriched during lead generation.',
+    ownedBySystemId: 'sales.lead-gen',
+    table: 'acq_list_members',
+    stateCatalogId: 'lead-gen.contact',
+    links: [
+      { toEntity: 'leadgen.list', kind: 'belongs-to', via: 'list_id', label: 'list' },
+      { toEntity: 'leadgen.company', kind: 'belongs-to', via: 'company_id', label: 'company' }
+    ]
+  },
+  {
+    id: 'delivery.project',
+    order: 60,
+    label: 'Project',
+    description: 'A client delivery project.',
+    ownedBySystemId: 'projects',
+    table: 'projects',
+    links: [
+      { toEntity: 'delivery.milestone', kind: 'has-many', via: 'project_id', label: 'milestones' },
+      { toEntity: 'delivery.task', kind: 'has-many', via: 'project_id', label: 'tasks' }
+    ]
+  },
+  {
+    id: 'delivery.milestone',
+    order: 70,
+    label: 'Milestone',
+    description: 'A delivery checkpoint within a project.',
+    ownedBySystemId: 'projects',
+    table: 'project_milestones',
+    links: [
+      { toEntity: 'delivery.project', kind: 'belongs-to', via: 'project_id', label: 'project' },
+      { toEntity: 'delivery.task', kind: 'has-many', via: 'milestone_id', label: 'tasks' }
+    ]
+  },
+  {
+    id: 'delivery.task',
+    order: 80,
+    label: 'Task',
+    description: 'A delivery task that can move through the task status catalog.',
+    ownedBySystemId: 'projects',
+    table: 'project_tasks',
+    stateCatalogId: 'delivery.task',
+    links: [
+      { toEntity: 'delivery.project', kind: 'belongs-to', via: 'project_id', label: 'project' },
+      { toEntity: 'delivery.milestone', kind: 'belongs-to', via: 'milestone_id', label: 'milestone' }
+    ]
+  }
+]
+
+export const DEFAULT_ORGANIZATION_MODEL_ENTITIES: z.infer<typeof EntitiesDomainSchema> = Object.fromEntries(
+  ENTITY_ENTRY_INPUTS.map((entity) => {
+    const parsed = EntitySchema.parse(entity)
+    return [parsed.id, parsed]
+  })
+)
+
+export type EntityId = z.infer<typeof EntityIdSchema>
+export type EntityLinkKind = z.infer<typeof EntityLinkKindSchema>
+export type EntityLink = z.infer<typeof EntityLinkSchema>
+export type Entity = z.infer<typeof EntitySchema>
+export type EntitiesDomain = z.infer<typeof EntitiesDomainSchema>

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

@@ -43,6 +43,8 @@ const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
 export const ObjectiveSchema = z.object({
   /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
   id: z.string().trim().min(1).max(100),
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number(),
   /** Plain-language description of what the organization wants to achieve. */
   description: z.string().trim().min(1).max(1000),
   /**
@@ -67,14 +69,15 @@ export const ObjectiveSchema = z.object({
 // Goals domain schema — a collection of goals the organization is pursuing.
 // ---------------------------------------------------------------------------
 
-export const GoalsDomainSchema = z.object({
-  objectives: z.array(ObjectiveSchema).default([])
-})
+export const GoalsDomainSchema = z
+  .record(z.string(), ObjectiveSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each objective entry id must match its map key'
+  })
+  .default({})
 
 // ---------------------------------------------------------------------------
 // Seed — empty by default; adapters populate with real goal definitions.
 // ---------------------------------------------------------------------------
 
-export const DEFAULT_ORGANIZATION_MODEL_GOALS: z.infer<typeof GoalsDomainSchema> = {
-  objectives: []
-}
+export const DEFAULT_ORGANIZATION_MODEL_GOALS: z.infer<typeof GoalsDomainSchema> = {}