@elevasis/core 0.25.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,

package/src/_gen/__tests__/__snapshots__/contracts.md.snap

@@ -306,7 +306,7 @@ export type OrganizationModelSystemLifecycle = z.infer<typeof SystemLifecycleSch
 ### `OrganizationModelSystemStatus`
 
 ```typescript
-/** @deprecated Use OrganizationModelSystemLifecycle. Accepted for one publish cycle. */
+/** @deprecated Use OrganizationModelSystemLifecycle. Accepted for one publish cycle. */
 export type OrganizationModelSystemStatus = z.infer<typeof SystemStatusSchema>
 ```
 
@@ -376,6 +376,18 @@ export type OrganizationModelResourceGovernanceStatus = z.infer<typeof ResourceG
 export type OrganizationModelResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>
 ```
 
+### `OrganizationModelContractRef`
+
+```typescript
+export type OrganizationModelContractRef = z.infer<typeof ContractRefSchema>
+```
+
+### `OrganizationModelResourceOntologyBindingContract`
+
+```typescript
+export type OrganizationModelResourceOntologyBindingContract = ResourceOntologyBindingContract
+```
+
 ### `OrganizationModelAgentKind`
 
 ```typescript
@@ -625,7 +637,7 @@ export type OrganizationModelBuiltinIconToken = z.infer<typeof OrganizationModel
 ### `DeepPartial`
 
 ```typescript
-export type DeepPartial<T> =
+export type DeepPartial<T> =
   T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T
 ```
 

package/src/business/acquisition/api-schemas.test.ts

@@ -2,8 +2,7 @@ import { describe, expect, it } from 'vitest'
 import {
   CRM_PIPELINE_DEFINITION,
   DEFAULT_CRM_PRIORITY_RULE_CONFIG,
-  LEAD_GEN_PIPELINE_DEFINITIONS,
-  LEAD_GEN_STAGE_CATALOG
+  LEAD_GEN_PIPELINE_DEFINITIONS
 } from '../../organization-model/domains/sales'
 import { CrmPriorityOverrideSchema, evaluateCrmDealPriority, resolveCrmPriorityRuleConfig } from './crm-priority'
 import {
@@ -61,8 +60,7 @@ import {
   CRM_STAGE_KEYS_FROM_ONTOLOGY,
   LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
   LEAD_GEN_STAGE_KEYS_FROM_ONTOLOGY,
-  getLeadGenStageCatalogFromOntology,
-  isLeadGenActionKey
+  getLeadGenStageCatalogFromOntology
 } from './ontology-validation'
 
 // ---------------------------------------------------------------------------
@@ -70,8 +68,10 @@ import {
 // ---------------------------------------------------------------------------
 
 const VALID_UUID = '00000000-0000-4000-8000-000000000001'
-const ISO_TS = '2026-04-27T12:34:56.000Z'
-const PRIORITY = {
+const ISO_TS = '2026-04-27T12:34:56.000Z'
+const VALID_COMPANY_STAGE_KEY = 'qualified'
+const VALID_CONTACT_STAGE_KEY = 'verified'
+const PRIORITY = {
   bucketKey: 'waiting' as const,
   rank: 30,
   label: 'Waiting',
@@ -130,17 +130,14 @@ describe('business ontology validation bridge', () => {
     expect(CrmStageKeySchema.options).toEqual(CRM_STAGE_KEYS_FROM_ONTOLOGY)
   })
 
-  it('keeps lead-gen schema validation aligned to the ontology catalog and legacy stage constant', () => {
-    const legacyStageKeys = Object.keys(LEAD_GEN_STAGE_CATALOG)
-
-    expect(LEAD_GEN_STAGE_KEYS_FROM_ONTOLOGY).toEqual(legacyStageKeys)
-    expect(Object.keys(getLeadGenStageCatalogFromOntology())).toEqual(legacyStageKeys)
+  it('keeps the generic core lead-gen catalog bridge vacuous until a model-owned catalog is supplied', () => {
+    expect(LEAD_GEN_STAGE_KEYS_FROM_ONTOLOGY).toEqual([])
+    expect(getLeadGenStageCatalogFromOntology()).toEqual({})
   })
 
-  it('indexes legacy action ids through compiled ontology action types', () => {
-    expect(BUSINESS_ONTOLOGY_VALIDATION_INDEX.actionTypesByLegacyId['send_reply']?.ownerSystemId).toBe('sales.crm')
-    expect(isLeadGenActionKey('lead-gen.company.source')).toBe(true)
-    expect(isLeadGenActionKey('lead-gen.missing.action')).toBe(false)
+  it('does not publish Elevasis lead-gen action ids through the generic core ontology bridge', () => {
+    expect(BUSINESS_ONTOLOGY_VALIDATION_INDEX.actionTypesByLegacyId['send_reply']).toBeUndefined()
+    expect(BUSINESS_ONTOLOGY_VALIDATION_INDEX.actionTypesByLegacyId['lead-gen.company.source']).toBeUndefined()
   })
 })
 
@@ -273,11 +270,11 @@ describe('CrmTransitionItemRequestSchema', () => {
     }
   })
 
-  it('rejects non-CRM pipeline keys and unknown CRM keys', () => {
-    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, pipelineKey: 'lead-gen' }).success).toBe(false)
-    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stageKey: 'unknown_stage' }).success).toBe(false)
-    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stateKey: 'unknown_state' }).success).toBe(false)
-  })
+  it('accepts generic non-empty pipeline keys but rejects unknown CRM stage/state keys', () => {
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, pipelineKey: 'lead-gen' }).success).toBe(true)
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stageKey: 'unknown_stage' }).success).toBe(false)
+    expect(CrmTransitionItemRequestSchema.safeParse({ ...valid, stateKey: 'unknown_state' }).success).toBe(false)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -550,13 +547,13 @@ describe('UpdateContactRequestSchema', () => {
     )
   })
 
-  it('accepts processingState keyed by the stage catalog', () => {
-    const result = UpdateContactRequestSchema.safeParse({
-      processingState: {
-        [LEAD_GEN_STAGE_CATALOG.verified.key]: {
-          status: 'no_result'
-        }
-      }
+  it('accepts processingState keyed by the stage catalog', () => {
+    const result = UpdateContactRequestSchema.safeParse({
+      processingState: {
+        [VALID_CONTACT_STAGE_KEY]: {
+          status: 'no_result'
+        }
+      }
     })
 
     expect(result.success).toBe(true)
@@ -1027,20 +1024,16 @@ describe('ListStatusSchema', () => {
 // PipelineStageSchema
 // ---------------------------------------------------------------------------
 
-describe('PipelineStageSchema', () => {
-  it('accepts a key present in LEAD_GEN_STAGE_CATALOG', () => {
-    for (const key of Object.keys(LEAD_GEN_STAGE_CATALOG)) {
-      expect(PipelineStageSchema.safeParse({ key }).success).toBe(true)
-    }
-  })
-
-  it('rejects a key not in LEAD_GEN_STAGE_CATALOG', () => {
-    const result = PipelineStageSchema.safeParse({ key: 'not_a_real_stage' })
-    expect(result.success).toBe(false)
-    if (!result.success) {
-      expect(result.error.issues[0]?.message).toMatch(/LEAD_GEN_STAGE_CATALOG/)
-    }
-  })
+describe('PipelineStageSchema', () => {
+  it('accepts non-empty model-owned stage keys', () => {
+    expect(PipelineStageSchema.safeParse({ key: VALID_COMPANY_STAGE_KEY }).success).toBe(true)
+    expect(PipelineStageSchema.safeParse({ key: 'tenant-custom-stage' }).success).toBe(true)
+  })
+
+  it('rejects an empty stage key', () => {
+    const result = PipelineStageSchema.safeParse({ key: '' })
+    expect(result.success).toBe(false)
+  })
 
   it('accepts optional label, enabled, and order fields', () => {
     expect(PipelineStageSchema.safeParse({ key: 'scraped', label: 'Scraped', enabled: true, order: 1 }).success).toBe(
@@ -1061,23 +1054,23 @@ describe('BuildPlanSnapshotSchema', () => {
     expect(BuildPlanSnapshotSchema.safeParse(validSnapshot).success).toBe(true)
   })
 
-  it('rejects a step stageKey outside LEAD_GEN_STAGE_CATALOG', () => {
-    const result = BuildPlanSnapshotSchema.safeParse({
-      ...validSnapshot,
-      steps: [{ ...validSnapshot!.steps[0], stageKey: 'made-up-stage' }]
-    })
-
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a step actionKey outside ACTION_REGISTRY', () => {
-    const result = BuildPlanSnapshotSchema.safeParse({
-      ...validSnapshot,
-      steps: [{ ...validSnapshot!.steps[0], actionKey: 'lead-gen.missing.action' }]
-    })
-
-    expect(result.success).toBe(false)
-  })
+  it('accepts custom non-empty step stage keys at the transport boundary', () => {
+    const result = BuildPlanSnapshotSchema.safeParse({
+      ...validSnapshot,
+      steps: [{ ...validSnapshot!.steps[0], stageKey: 'made-up-stage' }]
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('accepts custom non-empty action keys at the transport boundary', () => {
+    const result = BuildPlanSnapshotSchema.safeParse({
+      ...validSnapshot,
+      steps: [{ ...validSnapshot!.steps[0], actionKey: 'lead-gen.missing.action' }]
+    })
+
+    expect(result.success).toBe(true)
+  })
 
   it('rejects duplicate step ids', () => {
     const first = validSnapshot!.steps[0]!
@@ -1475,13 +1468,13 @@ describe('UpdateCompanyRequestSchema', () => {
     expect(UpdateCompanyRequestSchema.safeParse({ status: 'invalid' }).success).toBe(true)
   })
 
-  it('accepts processingState keyed by the stage catalog', () => {
-    const result = UpdateCompanyRequestSchema.safeParse({
-      processingState: {
-        [LEAD_GEN_STAGE_CATALOG.qualified.key]: {
-          status: 'success',
-          data: { score: 92 }
-        }
+  it('accepts processingState keyed by the stage catalog', () => {
+    const result = UpdateCompanyRequestSchema.safeParse({
+      processingState: {
+        [VALID_COMPANY_STAGE_KEY]: {
+          status: 'success',
+          data: { score: 92 }
+        }
       }
     })
 
@@ -1492,14 +1485,14 @@ describe('UpdateCompanyRequestSchema', () => {
     expect(UpdateCompanyRequestSchema.safeParse({ pipelineStatus: 'emailed' }).success).toBe(true)
   })
 
-  it('rejects processingState keys outside the stage catalog', () => {
-    expect(
-      UpdateCompanyRequestSchema.safeParse({
-        processingState: {
-          madeUpStage: { status: 'success' }
-        }
-      }).success
-    ).toBe(false)
+  it('rejects empty processingState keys', () => {
+    expect(
+      UpdateCompanyRequestSchema.safeParse({
+        processingState: {
+          '': { status: 'success' }
+        }
+      }).success
+    ).toBe(false)
   })
 
   it('accepts numEmployees of 0', () => {
@@ -1744,10 +1737,10 @@ describe('ListRecordsQuerySchema', () => {
     expect(ListRecordsQuerySchema.safeParse({ entity: 'company', stage: 'uploaded' }).success).toBe(true)
   })
 
-  it('still rejects unrelated stage/entity combinations', () => {
-    expect(ListRecordsQuerySchema.safeParse({ entity: 'contact', stage: 'qualified' }).success).toBe(false)
-  })
-})
+  it('accepts stage/entity combinations at the transport boundary', () => {
+    expect(ListRecordsQuerySchema.safeParse({ entity: 'contact', stage: 'qualified' }).success).toBe(true)
+  })
+})
 
 // ---------------------------------------------------------------------------
 // AcqListResponseSchema (forward-compat)

package/src/business/acquisition/api-schemas.ts

@@ -1,29 +1,19 @@
 import { z } from 'zod'
 import { UuidSchema, NonEmptyStringSchema } from '../../platform/utils/validation'
-import { CRM_PIPELINE_DEFINITION } from '../../organization-model/domains/sales'
 import { CredentialRequirementSchema, RecordColumnConfigSchema } from '../../organization-model/domains/prospecting'
 import { isProspectingBuildTemplateId } from './build-templates'
 import {
   CRM_STAGE_KEYS_FROM_ONTOLOGY,
-  CRM_STATE_KEYS_FROM_ONTOLOGY,
-  isLeadGenActionKey,
-  isLeadGenRecordStageValidForEntity,
-  isLeadGenStageKey
+  CRM_STATE_KEYS_FROM_ONTOLOGY
 } from './ontology-validation'
 export { CrmPriorityBucketKeySchema, CrmPriorityBucketOverrideSchema, CrmPriorityOverrideSchema } from './crm-priority'
 export type { CrmPriorityBucketOverride, CrmPriorityOverride, ResolvedCrmPriorityRuleConfig } from './crm-priority'
 
 export const ProcessingStageStatusSchema = z.enum(['success', 'no_result', 'skipped', 'error'])
 
-export const LeadGenStageKeySchema = z
-  .string()
-  .refine((value) => isLeadGenStageKey(value), {
-    message: 'processing state key must match LEAD_GEN_STAGE_CATALOG'
-  })
+export const LeadGenStageKeySchema = z.string().trim().min(1)
 
-export const LeadGenActionKeySchema = z.string().refine((value) => isLeadGenActionKey(value), {
-  message: 'actionKey must match ACTION_REGISTRY'
-})
+export const LeadGenActionKeySchema = z.string().trim().min(1)
 
 const crmStageKeys = CRM_STAGE_KEYS_FROM_ONTOLOGY
 const crmStateKeys = CRM_STATE_KEYS_FROM_ONTOLOGY
@@ -135,9 +125,9 @@ export const TransitionItemRequestSchema = z
   })
   .strict()
 
-export const CrmTransitionItemRequestSchema = z
-  .object({
-    pipelineKey: z.literal(CRM_PIPELINE_DEFINITION.pipelineKey),
+export const CrmTransitionItemRequestSchema = z
+  .object({
+    pipelineKey: z.string().min(1),
     stageKey: CrmStageKeySchema,
     stateKey: CrmStateKeySchema.nullable().optional(),
     reason: z.string().optional(),
@@ -508,14 +498,14 @@ export const IcpRubricSchema = z.object({
 })
 
 /**
- * One stage entry in a list's `pipeline_config.stages[]`. The `key` is
- * validated against `LEAD_GEN_STAGE_CATALOG` so list pipeline definitions
- * stay aligned with the org-os semantic layer.
- */
+ * One stage entry in a list's `pipeline_config.stages[]`.
+ *
+ * Stage catalogs are model-owned. The published core schema validates the
+ * transport shape and leaves closed-catalog checks to callers with a resolved
+ * Organization Model.
+ */
 export const PipelineStageSchema = z.object({
-  key: z.string().refine((value) => isLeadGenStageKey(value), {
-    message: 'pipeline stage key must match LEAD_GEN_STAGE_CATALOG'
-  }),
+  key: LeadGenStageKeySchema,
   label: z.string().optional(),
   enabled: z.boolean().optional(),
   order: z.number().int().optional()
@@ -1183,25 +1173,14 @@ export const ListMembersQuerySchema = z
 
 export const ListRecordEntitySchema = z.enum(['company', 'contact'])
 
-export const ListRecordsQuerySchema = z
-  .object({
-    entity: ListRecordEntitySchema,
-    stage: LeadGenStageKeySchema.optional(),
-    limit: z.coerce.number().int().min(1).max(500).default(50),
-    offset: z.coerce.number().int().min(0).default(0)
-  })
-  .strict()
-  .superRefine((query, ctx) => {
-    if (!query.stage) return
-
-    if (!isLeadGenRecordStageValidForEntity(query.stage, query.entity)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `stage "${query.stage}" is not valid for ${query.entity} records`,
-        path: ['stage']
-      })
-    }
-  })
+export const ListRecordsQuerySchema = z
+  .object({
+    entity: ListRecordEntitySchema,
+    stage: LeadGenStageKeySchema.optional(),
+    limit: z.coerce.number().int().min(1).max(500).default(50),
+    offset: z.coerce.number().int().min(0).default(0)
+  })
+  .strict()
 
 export const MemberIdParamsSchema = z.object({
   memberId: UuidSchema

package/src/business/acquisition/derive-actions.test.ts

@@ -1,9 +1,7 @@
-import { describe, expect, it } from 'vitest'
-import { CRM_ACTION_ENTRIES } from '@repo/core/organization-model'
+import { describe, expect, it } from 'vitest'
 import type { AcqDealRow } from './types'
 import type { Action, ActionDef } from './derive-actions'
 import { DEFAULT_CRM_ACTIONS, SendReplyActionPayloadSchema, deriveActions } from './derive-actions'
-import { getCrmActionMetadata } from './ontology-validation'
 
 // ---------------------------------------------------------------------------
 // Fixture builder
@@ -96,28 +94,20 @@ describe('DEFAULT_CRM_ACTIONS static contract', () => {
     expect(unique.size).toBe(keys.length)
   })
 
-  it('derives promoted CRM runtime metadata from CRM_ACTION_ENTRIES', () => {
+  it('derives promoted CRM runtime metadata from the local runtime contract', () => {
     const sendReply = DEFAULT_CRM_ACTIONS.find((a) => a.key === 'send_reply')
-    const metadata = CRM_ACTION_ENTRIES['send_reply']
-    const ontologyMetadata = getCrmActionMetadata('send_reply')
 
     expect(sendReply).toBeDefined()
-    expect(sendReply?.key).toBe(metadata.id)
-    expect(sendReply?.label).toBe(metadata.label)
-    expect(sendReply?.workflowId).toBe(metadata.resourceId)
-    expect(ontologyMetadata).toMatchObject({
-      id: metadata.id,
-      label: metadata.label,
-      resourceId: metadata.resourceId
-    })
+    expect(sendReply?.label).toBe('Send Reply')
+    expect(sendReply?.workflowId).toBe('crm-send-reply-workflow')
+  })
+
+  it('keeps mark_no_show as a runtime-only CRM action', () => {
+    const markNoShow = DEFAULT_CRM_ACTIONS.find((a) => a.key === 'mark_no_show')
+
+    expect(markNoShow).toBeDefined()
+    expect(markNoShow?.workflowId).toBe('mark_no_show-workflow')
   })
-
-  it('keeps mark_no_show as a runtime-only CRM action', () => {
-    const markNoShow = DEFAULT_CRM_ACTIONS.find((a) => a.key === 'mark_no_show')
-
-    expect(markNoShow).toBeDefined()
-    expect(CRM_ACTION_ENTRIES['mark_no_show']).toBeUndefined()
-  })
 })
 
 // ---------------------------------------------------------------------------

package/src/business/acquisition/derive-actions.ts

@@ -4,9 +4,8 @@ import {
   CRM_DISCOVERY_LINK_SENT_STATE,
   CRM_DISCOVERY_NUDGING_STATE,
   CRM_DISCOVERY_REPLIED_STATE
-} from '@repo/core/organization-model'
+} from '../../organization-model/domains/sales'
 import { getDealOwnership, type DealOwnership } from './deal-ownership'
-import { getCrmActionMetadata } from './ontology-validation'
 import type { AcqDealRow } from './types'
 
 export interface Action {
@@ -34,21 +33,69 @@ export const SendReplyActionPayloadSchema = z
   })
   .strict()
 
-type CrmActionRuntimeDef = Pick<ActionDef, 'isAvailableFor' | 'payloadSchema'>
-
+type CrmActionRuntimeDef = Pick<ActionDef, 'isAvailableFor' | 'payloadSchema'>
+
+const CRM_RUNTIME_ACTION_METADATA: Record<string, Pick<ActionDef, 'key' | 'label' | 'workflowId'>> = {
+  move_to_proposal: {
+    key: 'move_to_proposal',
+    label: 'Move to Proposal',
+    workflowId: 'move_to_proposal-workflow'
+  },
+  move_to_closing: {
+    key: 'move_to_closing',
+    label: 'Move to Closing',
+    workflowId: 'move_to_closing-workflow'
+  },
+  move_to_closed_won: {
+    key: 'move_to_closed_won',
+    label: 'Close Won',
+    workflowId: 'move_to_closed_won-workflow'
+  },
+  move_to_closed_lost: {
+    key: 'move_to_closed_lost',
+    label: 'Close Lost',
+    workflowId: 'move_to_closed_lost-workflow'
+  },
+  move_to_nurturing: {
+    key: 'move_to_nurturing',
+    label: 'Move to Nurturing',
+    workflowId: 'move_to_nurturing-workflow'
+  },
+  send_reply: {
+    key: 'send_reply',
+    label: 'Send Reply',
+    workflowId: 'crm-send-reply-workflow'
+  },
+  send_link: {
+    key: 'send_link',
+    label: 'Send Booking Link',
+    workflowId: 'crm-send-booking-link-workflow'
+  },
+  send_nudge: {
+    key: 'send_nudge',
+    label: 'Send Nudge',
+    workflowId: 'crm-send-nudge-workflow'
+  },
+  rebook: {
+    key: 'rebook',
+    label: 'Rebook',
+    workflowId: 'crm-rebook-workflow'
+  }
+}
+
 function crmAction(actionId: string, runtime: CrmActionRuntimeDef): ActionDef {
-  const metadata = getCrmActionMetadata(actionId)
-  if (!metadata?.resourceId) {
+  const metadata = CRM_RUNTIME_ACTION_METADATA[actionId]
+  if (!metadata?.workflowId) {
     throw new Error(`CRM action metadata for "${actionId}" must define resourceId`)
   }
-
-  return {
-    key: metadata.id,
-    label: metadata.label,
-    workflowId: metadata.resourceId,
-    ...runtime
-  }
-}
+
+  return {
+    key: metadata.key,
+    label: metadata.label,
+    workflowId: metadata.workflowId,
+    ...runtime
+  }
+}
 
 export const DEFAULT_CRM_ACTIONS: ActionDef[] = [
   crmAction('move_to_proposal', {

package/src/business/acquisition/ontology-validation.ts

@@ -11,10 +11,10 @@ import {
 import type { OrganizationModel } from '../../organization-model/types'
 import {
   CRM_PIPELINE_DEFINITION,
-  LEAD_GEN_STAGE_CATALOG,
   type LeadGenStageCatalogEntry,
   type StatefulStateDefinition
 } from '../../organization-model/domains/sales'
+import { getLeadGenStageCatalog } from '../../organization-model/migration-helpers'
 
 export const CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
   scope: 'sales.crm',
@@ -73,14 +73,14 @@ function createCrmPipelineCatalog(): OntologyCatalogType {
   }
 }
 
-function createLeadGenStageCatalog(): OntologyCatalogType {
+function createLeadGenStageCatalog(model: OrganizationModel): OntologyCatalogType {
   return {
     id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
     label: 'Lead Gen Processing Stages',
     ownerSystemId: 'sales.lead-gen',
     kind: 'processing-stage-catalog',
     entries: Object.fromEntries(
-      Object.entries(LEAD_GEN_STAGE_CATALOG).map(([key, entry]) => [
+      Object.entries(getLeadGenStageCatalog(model)).map(([key, entry]) => [
         key,
         {
           ...entry
@@ -103,7 +103,7 @@ function mergeBridgeCatalogs(model: OrganizationModel): OrganizationModel {
     bridgeCatalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID] = createCrmPipelineCatalog()
   }
   if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === undefined) {
-    bridgeCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog()
+    bridgeCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model)
   }
 
   if (Object.keys(bridgeCatalogTypes).length === 0) return model

package/src/business/acquisition/types.ts

@@ -1,11 +1,10 @@
 import type { Database } from '../../supabase/database.types'
-import type {
-  ActionRegistry,
-  CredentialRequirement,
-  RecordColumnConfig
-} from '../../organization-model/domains/prospecting'
-import type { LEAD_GEN_STAGE_CATALOG } from '../../organization-model/domains/sales'
-import type { PipelineStage, ProcessingStageStatus } from './api-schemas'
+import type {
+  ActionRegistry,
+  CredentialRequirement,
+  RecordColumnConfig
+} from '../../organization-model/domains/prospecting'
+import type { PipelineStage, ProcessingStageStatus } from './api-schemas'
 
 // =============================================================================
 // Supabase-Generated Types (Re-exported from database.types)
@@ -55,7 +54,7 @@ export interface WebPost {
   aiInsight?: string
 }
 
-export type LeadGenStageKey = (typeof LEAD_GEN_STAGE_CATALOG)[keyof typeof LEAD_GEN_STAGE_CATALOG]['key']
+export type LeadGenStageKey = string
 export type LeadGenActionKey = ActionRegistry[number]['id']
 
 export interface ProcessingStateEntry {

package/src/knowledge/queries.ts

@@ -22,7 +22,6 @@ function toTargetGraphNodeId(nodeId: string): string {
     nodeId.startsWith('system:') ||
     nodeId.startsWith('knowledge:') ||
     nodeId.startsWith('resource:') ||
-    nodeId.startsWith('content-node:') ||
     nodeId.startsWith('ontology:')
   ) {
     return nodeId