@elevasis/core 0.21.0 → 0.23.0

package/src/organization-model/graph/link.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { NodeIdStringSchema } from '../domains/features'
+import { NodeIdStringSchema } from '../domains/systems'
 import { OrganizationGraphEdgeKindSchema } from './schema'
 
 export const LinkSchema = z.object({

package/src/organization-model/graph/schema.ts

@@ -4,23 +4,37 @@ import { OrganizationModelSchema } from '../schema'
 
 export const OrganizationGraphNodeKindSchema = z.enum([
   'organization',
-  'feature',
-  'surface',
+  'system',
+  'role',
+  'action',
   'entity',
-  'capability',
+  'event',
+  'policy',
   'stage',
   'resource',
-  'knowledge'
+  'knowledge',
+  'customer-segment',
+  'offering',
+  'goal',
+  'surface',
+  'navigation-group',
+  // Phase 3 preview — Phase 4 populates via graph projection of system.content entries.
+  'content-node'
 ])
 
 export const OrganizationGraphEdgeKindSchema = z.enum([
   'contains',
   'references',
-  'exposes',
   'maps_to',
-  'operates-on',
   'uses',
-  'governs'
+  'governs',
+  'links',
+  'affects',
+  'emits',
+  'originates_from',
+  'triggers',
+  'applies_to',
+  'effects'
 ])
 
 export const OrganizationGraphNodeSchema = z.object({
@@ -31,8 +45,9 @@ export const OrganizationGraphNodeSchema = z.object({
   description: DescriptionSchema.optional(),
   icon: IconNameSchema.optional(),
   enabled: z.boolean().optional(),
-  featureId: z.string().trim().min(1).max(100).optional(),
-  resourceType: z.enum(['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint']).optional()
+  resourceType: z
+    .enum(['workflow', 'agent', 'trigger', 'integration', 'external', 'human_checkpoint', 'script'])
+    .optional()
 })
 
 export const OrganizationGraphEdgeSchema = z.object({

package/src/organization-model/graph/types.ts

@@ -5,22 +5,36 @@ import type { OrganizationModelIconToken } from '../icons'
 
 export type OrganizationGraphNodeKind =
   | 'organization'
-  | 'feature'
-  | 'surface'
+  | 'system'
+  | 'role'
+  | 'action'
   | 'entity'
-  | 'capability'
+  | 'event'
+  | 'policy'
   | 'stage'
   | 'resource'
   | 'knowledge'
+  | 'customer-segment'
+  | 'offering'
+  | 'goal'
+  | 'surface'
+  | 'navigation-group'
+  /** Phase 3 preview — Phase 4 populates this kind via graph projection of system.content entries. */
+  | 'content-node'
 
 export type OrganizationGraphEdgeKind =
   | 'contains'
   | 'references'
-  | 'exposes'
   | 'maps_to'
-  | 'operates-on'
   | 'uses'
   | 'governs'
+  | 'links'
+  | 'affects'
+  | 'emits'
+  | 'originates_from'
+  | 'triggers'
+  | 'applies_to'
+  | 'effects'
 export type { Link } from './link'
 
 export interface OrganizationGraphNode {
@@ -31,8 +45,7 @@ export interface OrganizationGraphNode {
   description?: string
   icon?: OrganizationModelIconToken
   enabled?: boolean
-  featureId?: string
-  resourceType?: 'workflow' | 'agent' | 'trigger' | 'integration' | 'external' | 'human_checkpoint'
+  resourceType?: 'workflow' | 'agent' | 'trigger' | 'integration' | 'external' | 'human_checkpoint' | 'script'
 }
 
 export interface OrganizationGraphEdge {

package/src/organization-model/helpers.ts

@@ -1,4 +1,20 @@
-import type { OrganizationModelFeature } from './types'
+import type { OrganizationModel, OrganizationModelSystemEntry } from './types'
+import type { ContentNode } from './content-kinds/types'
+import type { ResourceEntry } from './domains/resources'
+
+// W1A has landed: ContentNode and SystemEntry (with content + subsystems) are now
+// defined in their canonical locations.
+// Phase 4: removed locally-scoped inferred types for deleted compound-domain schemas
+// (SalesPipeline, ProspectingBuildTemplate, etc.). migration-helpers.ts imports them directly.
+
+/**
+ * SystemEntry extended with the recursive tree slots (`content`, `subsystems`).
+ * `OrganizationModelSystemEntry` is inferred from `SystemEntrySchema: ZodType<SystemEntry>`
+ * so it already carries these fields; this alias re-exports it under the tree-walker name
+ * for clarity at call sites.
+ */
+export type { ContentNode }
+export type SystemEntryWithTree = OrganizationModelSystemEntry
 
 export function defaultPathFor(id: string): string {
   return `/${id.replaceAll('.', '/')}`
@@ -9,66 +25,255 @@ export function parentIdOf(id: string): string | undefined {
   return index === -1 ? undefined : id.slice(0, index)
 }
 
-export function findById(features: readonly OrganizationModelFeature[], id: string): OrganizationModelFeature | undefined {
-  return features.find((feature) => feature.id === id)
+/**
+ * Return all entries of an OM domain map sorted by their declared `order` field.
+ * Use this whenever iteration order matters for UI or deterministic output.
+ */
+export function listDomain<T extends { id: string; order: number }>(record: Record<string, T>): T[] {
+  return Object.values(record).sort((a, b) => a.order - b.order)
+}
+
+export function findById(
+  systems: Record<string, OrganizationModelSystemEntry>,
+  id: string
+): OrganizationModelSystemEntry | undefined {
+  return systems[id]
 }
 
 export function findByPath(
-  features: readonly OrganizationModelFeature[],
+  systems: Record<string, OrganizationModelSystemEntry>,
   path: string
-): OrganizationModelFeature | undefined {
-  return features.find((feature) => (feature.path ?? defaultPathFor(feature.id)) === path)
+): OrganizationModelSystemEntry | undefined {
+  return Object.values(systems).find((system) => (system.path ?? system.ui?.path ?? defaultPathFor(system.id)) === path)
 }
 
 export function childrenOf(
-  features: readonly OrganizationModelFeature[],
+  systems: Record<string, OrganizationModelSystemEntry>,
   id: string
-): OrganizationModelFeature[] {
+): OrganizationModelSystemEntry[] {
   const prefix = `${id}.`
-  return features.filter((feature) => feature.id.startsWith(prefix) && !feature.id.slice(prefix.length).includes('.'))
+  return Object.values(systems).filter(
+    (system) => system.id.startsWith(prefix) && !system.id.slice(prefix.length).includes('.')
+  )
 }
 
-export function topLevel(features: readonly OrganizationModelFeature[]): OrganizationModelFeature[] {
-  return features.filter((feature) => !feature.id.includes('.'))
+export function topLevel(systems: Record<string, OrganizationModelSystemEntry>): OrganizationModelSystemEntry[] {
+  return Object.values(systems).filter((system) => !system.id.includes('.'))
 }
 
 export function ancestorsOf(
-  features: readonly OrganizationModelFeature[],
+  systems: Record<string, OrganizationModelSystemEntry>,
   id: string
-): OrganizationModelFeature[] {
+): OrganizationModelSystemEntry[] {
   const segments = id.split('.')
   const ids = segments.map((_, index) => segments.slice(0, index + 1).join('.'))
-  return ids.map((ancestorId) => findById(features, ancestorId)).filter((feature): feature is OrganizationModelFeature => Boolean(feature))
+  return ids
+    .map((ancestorId) => findById(systems, ancestorId))
+    .filter((system): system is OrganizationModelSystemEntry => Boolean(system))
 }
 
 export function parentOf(
-  features: readonly OrganizationModelFeature[],
+  systems: Record<string, OrganizationModelSystemEntry>,
   id: string
-): OrganizationModelFeature | undefined {
+): OrganizationModelSystemEntry | undefined {
   const parentId = parentIdOf(id)
-  return parentId ? findById(features, parentId) : undefined
+  return parentId ? findById(systems, parentId) : undefined
 }
 
 function inheritedValue<T>(
-  features: readonly OrganizationModelFeature[],
+  systems: Record<string, OrganizationModelSystemEntry>,
   id: string,
-  getValue: (feature: OrganizationModelFeature) => T | undefined
+  getValue: (system: OrganizationModelSystemEntry) => T | undefined
 ): T | undefined {
-  return ancestorsOf(features, id)
+  return ancestorsOf(systems, id)
     .slice()
     .reverse()
     .map(getValue)
     .find((value): value is T => value !== undefined)
 }
 
-export function uiPositionFor(features: readonly OrganizationModelFeature[], id: string) {
-  return inheritedValue(features, id, (feature) => feature.uiPosition)
+export function uiPositionFor(systems: Record<string, OrganizationModelSystemEntry>, id: string) {
+  return inheritedValue(systems, id, (system) => system.uiPosition)
+}
+
+export function requiresAdminFor(systems: Record<string, OrganizationModelSystemEntry>, id: string): boolean {
+  return inheritedValue(systems, id, (system) => system.requiresAdmin) ?? false
+}
+
+export function devOnlyFor(systems: Record<string, OrganizationModelSystemEntry>, id: string): boolean {
+  return inheritedValue(systems, id, (system) => system.devOnly || system.lifecycle === 'beta' || undefined) ?? false
+}
+
+// ---------------------------------------------------------------------------
+// Recursive system-tree helpers (Wave 1B)
+// These operate on the NEW recursive System shape introduced by W1A, where
+// `model.systems` is `Record<LocalId, SystemEntry>` (nested via `subsystems`).
+// `SystemEntry` here is the extended interface defined at the top of this file.
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve a system by its dot-separated path string.
+ *
+ * `getSystem(model, 'sales.crm.dispositions')` walks:
+ *   `model.systems['sales'] → .subsystems['crm'] → .subsystems['dispositions']`
+ *
+ * Returns `undefined` if any segment is missing.
+ */
+export function getSystem(model: OrganizationModel, path: string): SystemEntryWithTree | undefined {
+  const segments = path.split('.')
+  // model.systems is typed as Record<string, OrganizationModelSystemEntry>; cast
+  // to SystemEntryWithTree (which extends it with optional content + subsystems).
+  let current: Record<string, SystemEntryWithTree> = model.systems as Record<string, SystemEntryWithTree>
+  let node: SystemEntryWithTree | undefined
+  for (const seg of segments) {
+    node = current[seg]
+    if (node === undefined) return undefined
+    current = node.subsystems ?? {}
+  }
+  return node
+}
+
+/**
+ * Return the root-first ancestor chain for a system path, including the system
+ * itself as the last element.
+ *
+ * `getSystemAncestors(model, 'sales.crm')` → `[salesEntry, crmEntry]`
+ *
+ * Returns an empty array if the path cannot be resolved.
+ */
+export function getSystemAncestors(model: OrganizationModel, path: string): SystemEntryWithTree[] {
+  const segments = path.split('.')
+  const result: SystemEntryWithTree[] = []
+  let current: Record<string, SystemEntryWithTree> = model.systems as Record<string, SystemEntryWithTree>
+  for (const seg of segments) {
+    const node = current[seg]
+    if (node === undefined) return []
+    result.push(node)
+    current = node.subsystems ?? {}
+  }
+  return result
+}
+
+/**
+ * Flat depth-first enumeration of every system in the model tree.
+ * Each entry carries the computed full path and the system node.
+ * Order: parent before children (pre-order DFS).
+ *
+ * Example result paths: `'sales'`, `'sales.crm'`, `'sales.crm.dispositions'`
+ */
+export function listAllSystems(model: OrganizationModel): Array<{ path: string; system: SystemEntryWithTree }> {
+  const results: Array<{ path: string; system: SystemEntryWithTree }> = []
+
+  function walk(map: Record<string, SystemEntryWithTree>, prefix: string): void {
+    for (const [localId, system] of Object.entries(map)) {
+      const fullPath = prefix ? `${prefix}.${localId}` : localId
+      results.push({ path: fullPath, system })
+      if (system.subsystems) {
+        walk(system.subsystems, fullPath)
+      }
+    }
+  }
+
+  walk(model.systems as Record<string, SystemEntryWithTree>, '')
+  return results
+}
+
+/**
+ * Resolve a content node by its qualified id (`<system-path>:<local-content-id>`).
+ *
+ * `getContent(model, 'sales.crm:default-pipeline')` resolves the `sales.crm`
+ * system and then looks up `system.content['default-pipeline']`.
+ *
+ * Returns `undefined` if the system or local id is not found, or if the
+ * qualified id does not contain exactly one `:` separator.
+ */
+export function getContent(model: OrganizationModel, qualifiedId: string): ContentNode | undefined {
+  const colonIndex = qualifiedId.indexOf(':')
+  if (colonIndex === -1) return undefined
+  const systemPath = qualifiedId.slice(0, colonIndex)
+  const localId = qualifiedId.slice(colonIndex + 1)
+  if (!systemPath || !localId) return undefined
+  const system = getSystem(model, systemPath)
+  return system?.content?.[localId]
 }
 
-export function requiresAdminFor(features: readonly OrganizationModelFeature[], id: string): boolean {
-  return inheritedValue(features, id, (feature) => feature.requiresAdmin) ?? false
+/**
+ * Resolve the layered content view for a system.
+ *
+ * Returns:
+ * - `own`: the system's direct `content` map (empty record if none).
+ * - `inherited`: ancestor content nodes that are NOT shadowed by `own` or by a
+ *   closer ancestor (depth-wins cascade, same as CSS specificity).
+ *
+ * Shadow rule: if two ancestors both declare `content['x']`, the deeper one
+ * wins. If the system itself declares `content['x']`, neither ancestor entry
+ * for `'x'` appears in `inherited`.
+ *
+ * `resolveSystemContent(model, 'sales.crm')` with both `sales.content['x']`
+ * and `sales.crm.content['x']` defined → `own` contains `'x'`, `inherited`
+ * contains NO entry for `'x'` from `sales`.
+ */
+export function resolveSystemContent(
+  model: OrganizationModel,
+  path: string
+): { own: Record<string, ContentNode>; inherited: Array<{ fromPath: string; node: ContentNode; localId: string }> } {
+  const ancestors = getSystemAncestors(model, path)
+  if (ancestors.length === 0) return { own: {}, inherited: [] }
+
+  const system = ancestors[ancestors.length - 1]
+  const own: Record<string, ContentNode> = { ...(system.content ?? {}) }
+
+  // Collect ancestor entries depth-first (deepest ancestor first, excluding self).
+  // We reconstruct paths for each ancestor by slicing the path segments.
+  const segments = path.split('.')
+  const shadowedIds = new Set(Object.keys(own))
+  const inherited: Array<{ fromPath: string; node: ContentNode; localId: string }> = []
+
+  // Iterate ancestors from deepest-parent to root so deeper wins.
+  for (let i = ancestors.length - 2; i >= 0; i--) {
+    const ancestor = ancestors[i]
+    const ancestorPath = segments.slice(0, i + 1).join('.')
+    const contentMap = ancestor.content ?? {}
+    for (const [localId, node] of Object.entries(contentMap)) {
+      if (!shadowedIds.has(localId)) {
+        shadowedIds.add(localId)
+        inherited.push({ fromPath: ancestorPath, node, localId })
+      }
+    }
+  }
+
+  // Re-order inherited so shallower ancestors come first (root-first display order).
+  inherited.reverse()
+
+  return { own, inherited }
 }
 
-export function devOnlyFor(features: readonly OrganizationModelFeature[], id: string): boolean {
-  return inheritedValue(features, id, (feature) => feature.devOnly) ?? false
+/**
+ * Return all resources whose `systemPath` belongs to the given system.
+ *
+ * When `includeDescendants` is false (default), only resources whose
+ * `systemPath` exactly matches `systemPath` are returned.
+ *
+ * When `includeDescendants` is true, resources attached to any descendant
+ * system are also included. Descendant matching is segment-aware: the path
+ * `'sales'` does NOT match `'salesforce.foo'` because segment boundaries are
+ * enforced by splitting on `'.'`.
+ *
+ * @example
+ * getResourcesForSystem(model, 'sales')
+ * // → resources where systemPath === 'sales'
+ *
+ * getResourcesForSystem(model, 'sales', { includeDescendants: true })
+ * // → resources where systemPath === 'sales' OR systemPath starts with 'sales.'
+ */
+export function getResourcesForSystem(
+  model: OrganizationModel,
+  systemPath: string,
+  options: { includeDescendants?: boolean } = {}
+): ResourceEntry[] {
+  const { includeDescendants = false } = options
+  const prefix = systemPath + '.'
+  return Object.values(model.resources ?? {}).filter(
+    (r) => r.systemPath === systemPath || (includeDescendants && r.systemPath.startsWith(prefix))
+  )
 }

package/src/organization-model/icons.ts

@@ -18,6 +18,7 @@ export const ORGANIZATION_MODEL_ICON_TOKENS = [
   'knowledge.reference',
   'feature.dashboard',
   'feature.calendar',
+  'feature.business',
   'feature.sales',
   'feature.crm',
   'feature.finance',

package/src/organization-model/index.ts

@@ -1,3 +1,4 @@
+export * from './content-kinds/index'
 export * from './schema'
 export * from './types'
 export * from './contracts'
@@ -9,10 +10,122 @@ export {
 export * from './defaults'
 export * from './resolve'
 export * from './foundation'
+export * from './surface-projection'
 export * from './helpers'
+export * from './migration-helpers'
 export * from './graph'
-export * from './domains/branding'
-export * from './domains/sales'
-export * from './domains/projects'
-export * from './domains/features'
-export * from './domains/prospecting'
+export * from './catalogs/lead-gen'
+export * from './domains/branding'
+// Phase 4: OrganizationModelSalesSchema, OrganizationModelProspectingSchema,
+// OrganizationModelProjectsSchema removed. Business-logic exports (StatefulPipelineDefinition,
+// CRM_PIPELINE_DEFINITION, ProspectingBuildTemplateSchema, etc.) still re-exported below.
+export {
+  SalesStageSemanticClassSchema,
+  SalesStageSchema,
+  SalesPipelineSchema,
+  CRM_DISCOVERY_REPLIED_STATE,
+  CRM_DISCOVERY_LINK_SENT_STATE,
+  CRM_DISCOVERY_NUDGING_STATE,
+  CRM_DISCOVERY_BOOKING_CANCELLED_STATE,
+  CRM_REPLY_SENT_STATE,
+  CRM_FOLLOWUP_1_SENT_STATE,
+  CRM_FOLLOWUP_2_SENT_STATE,
+  CRM_FOLLOWUP_3_SENT_STATE,
+  CRM_PIPELINE_DEFINITION,
+  CRM_PRIORITY_BUCKETS,
+  DEFAULT_CRM_PRIORITY_RULE_CONFIG,
+  DEFAULT_CRM_NEXT_ACTION_RULE_CONFIG,
+  ACQ_LIST_MEMBERS_LEAD_GEN_PIPELINE,
+  ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE,
+  LEAD_GEN_PIPELINE_DEFINITIONS,
+  findPipeline,
+  getValidStatesForStage,
+  LEAD_GEN_STAGE_CATALOG
+} from './domains/sales'
+export type {
+  StatefulStateDefinition,
+  StatefulStageDefinition,
+  StatefulPipelineDefinition,
+  CrmPriorityBucketKey,
+  CrmPriorityBucketDefinition,
+  CrmPriorityRuleConfig,
+  CrmNextActionMapping,
+  CrmNextActionRuleConfig
+} from './domains/sales'
+export {
+  ProspectingLifecycleStageSchema,
+  RecordColumnConfigSchema,
+  RecordColumnsConfigSchema,
+  CredentialRequirementSchema,
+  ProspectingBuildTemplateStepSchema,
+  ProspectingBuildTemplateSchema,
+  PROSPECTING_STEPS,
+  ACTION_REGISTRY,
+  findActionById
+} from './domains/prospecting'
+export type {
+  ListBuilderStep,
+  RecordColumnConfig,
+  CredentialRequirement,
+  TemplateName,
+  StepName,
+  ActionRegistry
+} from './domains/prospecting'
+export { ProjectsDomainStateSchema } from './domains/projects'
+export * from './domains/systems'
+export * from './domains/resources'
+export {
+  DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
+  getSortedSidebarEntries,
+  NavigationGroupSchema,
+  OrganizationModelNavigationSchema,
+  SidebarNavigationSchema,
+  SidebarNodeSchema,
+  SidebarSectionSchema,
+  SidebarSurfaceTargetsSchema,
+  SurfaceDefinitionSchema,
+  SurfaceTypeSchema
+} from './domains/navigation'
+export {
+  EntitiesDomainSchema,
+  EntityIdSchema,
+  EntityLinkKindSchema,
+  EntityLinkSchema,
+  EntitySchema
+} from './domains/entities'
+export {
+  KnowledgeDomainSchema,
+  KnowledgeLinkSchema,
+  KnowledgeTargetKindSchema,
+  KnowledgeTargetRefSchema,
+  OrgKnowledgeKindSchema,
+  OrgKnowledgeNodeSchema
+} from './domains/knowledge'
+export * from './domains/roles'
+export * from './domains/identity'
+export * from './domains/policies'
+export {
+  ActionsDomainSchema,
+  ActionIdSchema,
+  ActionInvocationKindSchema,
+  ActionInvocationSchema,
+  ActionRefSchema,
+  ActionSchema,
+  ActionScopeSchema,
+  ApiEndpointInvocationSchema,
+  DEFAULT_ORGANIZATION_MODEL_ACTIONS,
+  findOrganizationActionById,
+  LEAD_GEN_ACTION_ENTRIES,
+  McpToolInvocationSchema,
+  ScriptExecutionInvocationSchema,
+  SlashCommandInvocationSchema
+} from './domains/actions'
+export type {
+  ActionsDomain,
+  Action as OrganizationAction,
+  ActionId,
+  ActionInvocation,
+  ActionInvocationKind,
+  ActionRef,
+  ActionScope
+} from './domains/actions'