@elevasis/core 0.24.1 → 0.26.0

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

@@ -1,333 +1,116 @@
-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>
+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({})
+
+/**
+ * Generic empty default for the actions domain.
+ * Elevasis-specific action entries (LEAD_GEN_ACTION_ENTRIES, CRM_ACTION_ENTRIES,
+ * DEFAULT_ORGANIZATION_MODEL_ACTIONS) have been relocated to
+ * `@repo/elevasis-core/src/organization-model/actions.ts`.
+ * Tenant OM configs supply their own action entries via `resolveOrganizationModel`.
+ */
+export const DEFAULT_ORGANIZATION_MODEL_ACTIONS: z.infer<typeof ActionsDomainSchema> = {}
+
+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/knowledge.ts

@@ -21,16 +21,13 @@ export const KnowledgeTargetKindSchema = z
     'goal',
     'customer-segment',
     'offering',
-    'ontology',
-    // D4: content nodes are a valid knowledge target after compound-domain data moved into system.content
-    'content-node'
+    'ontology'
   ])
   .meta({ label: 'Target kind' })
 
 export const KnowledgeTargetRefSchema = z
   .object({
     kind: KnowledgeTargetKindSchema,
-    // D4: content-node targets use a qualified id format '<system-path>:<local-content-id>'.
     // Ontology targets use the canonical '<scope>:<kind>/<local-id>' ontology id format.
     // Business-logic validation of target existence is done in OrganizationModelSchema.superRefine.
     id: z.string().trim().min(1).max(300)
@@ -48,9 +45,20 @@ export const KnowledgeTargetRefSchema = z
     }
   })
 
-const LegacyKnowledgeLinkSchema = z.object({
-  nodeId: z.union([NodeIdStringSchema, z.templateLiteral(['ontology:', OntologyIdSchema])])
-})
+const LegacyKnowledgeLinkSchema = z
+  .object({
+    nodeId: z.union([NodeIdStringSchema, z.templateLiteral(['ontology:', OntologyIdSchema])])
+  })
+  .superRefine((link, ctx) => {
+    const [kind] = link.nodeId.split(':')
+    if (!KnowledgeTargetKindSchema.safeParse(kind).success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['nodeId'],
+        message: `Unknown knowledge target kind "${kind}"`
+      })
+    }
+  })
 
 const CanonicalKnowledgeLinkSchema = z.object({
   target: KnowledgeTargetRefSchema

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

@@ -6,9 +6,9 @@ export const ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
   order: z.number().int().min(0)
 })
 
-// Phase 4 cut: OrganizationModelProjectsSchema and DEFAULT_ORGANIZATION_MODEL_PROJECTS removed.
-// Project/milestone/task status data moved into system.content as (schema:status-flow) and
-// (schema:status) content nodes on the owning system. Use getAllProjectStatuses() from
-// migration-helpers to read status data portably.
+// OrganizationModelProjectsSchema and DEFAULT_ORGANIZATION_MODEL_PROJECTS are retired.
+// Project/milestone/task status data lives in System.ontology.catalogTypes on
+// the owning system. Use getAllProjectStatuses() from migration-helpers to read
+// status data portably.
 //
 // ProjectsDomainStateSchema is retained as the payload shape type for individual status entries.