@elevasis/core 0.22.0 → 0.24.0

package/src/organization-model/__tests__/content-kinds-registry.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest'
+import {
+  CONTENT_KIND_REGISTRY,
+  defineContentType,
+  lookupContentType,
+  pipelineKind,
+  stageKind,
+  templateKind,
+  templateStepKind,
+  statusFlowKind,
+  statusKind,
+  configKvKind
+} from '../content-kinds/index'
+import type { ContentTypeDefinition, ContentTypeKey } from '../content-kinds/types'
+
+// ---------------------------------------------------------------------------
+// CONTENT_KIND_REGISTRY shape (D8: static object literal)
+// ---------------------------------------------------------------------------
+
+describe('CONTENT_KIND_REGISTRY', () => {
+  it('contains all 7 expected keys', () => {
+    const expectedKeys: ContentTypeKey[] = [
+      'schema:pipeline',
+      'schema:stage',
+      'schema:template',
+      'schema:template-step',
+      'schema:status-flow',
+      'schema:status',
+      'config:kv'
+    ]
+    for (const key of expectedKeys) {
+      expect(CONTENT_KIND_REGISTRY).toHaveProperty(key)
+    }
+  })
+
+  it('maps schema:pipeline to the pipelineKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:pipeline']).toBe(pipelineKind)
+  })
+
+  it('maps schema:stage to the stageKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:stage']).toBe(stageKind)
+  })
+
+  it('maps schema:template to the templateKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:template']).toBe(templateKind)
+  })
+
+  it('maps schema:template-step to the templateStepKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:template-step']).toBe(templateStepKind)
+  })
+
+  it('maps schema:status-flow to the statusFlowKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:status-flow']).toBe(statusFlowKind)
+  })
+
+  it('maps schema:status to the statusKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['schema:status']).toBe(statusKind)
+  })
+
+  it('maps config:kv to the configKvKind definition', () => {
+    expect(CONTENT_KIND_REGISTRY['config:kv']).toBe(configKvKind)
+  })
+
+  it('has exactly 7 keys (no extra unintended entries)', () => {
+    expect(Object.keys(CONTENT_KIND_REGISTRY)).toHaveLength(7)
+  })
+
+  it('every entry has kind, type, payloadSchema, label, and description fields', () => {
+    for (const [key, def] of Object.entries(CONTENT_KIND_REGISTRY)) {
+      expect(def).toHaveProperty('kind')
+      expect(def).toHaveProperty('type')
+      expect(def).toHaveProperty('payloadSchema')
+      expect(typeof def.kind).toBe('string')
+      expect(typeof def.type).toBe('string')
+      expect(def.label).toBeTruthy()
+      expect(def.description).toBeTruthy()
+      // key must equal kind:type
+      expect(key).toBe(`${def.kind}:${def.type}`)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// parentTypes constraint
+// ---------------------------------------------------------------------------
+
+describe('parentTypes constraints', () => {
+  it('schema:pipeline has empty parentTypes (top-level, no parent required)', () => {
+    expect(pipelineKind.parentTypes).toEqual([])
+  })
+
+  it('schema:stage parentTypes is ["schema:pipeline"]', () => {
+    expect(stageKind.parentTypes).toEqual(['schema:pipeline'])
+  })
+
+  it('schema:template has empty parentTypes', () => {
+    expect(templateKind.parentTypes).toEqual([])
+  })
+
+  it('schema:template-step parentTypes is ["schema:template"]', () => {
+    expect(templateStepKind.parentTypes).toEqual(['schema:template'])
+  })
+
+  it('schema:status-flow has empty parentTypes', () => {
+    expect(statusFlowKind.parentTypes).toEqual([])
+  })
+
+  it('schema:status parentTypes is ["schema:status-flow"]', () => {
+    expect(statusKind.parentTypes).toEqual(['schema:status-flow'])
+  })
+
+  it('config:kv has empty parentTypes', () => {
+    expect(configKvKind.parentTypes).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// lookupContentType
+// ---------------------------------------------------------------------------
+
+describe('lookupContentType', () => {
+  it('returns the correct definition for schema:pipeline', () => {
+    const def = lookupContentType('schema', 'pipeline')
+    expect(def).toBe(pipelineKind)
+  })
+
+  it('returns the correct definition for schema:stage', () => {
+    const def = lookupContentType('schema', 'stage')
+    expect(def).toBe(stageKind)
+  })
+
+  it('returns the correct definition for config:kv', () => {
+    const def = lookupContentType('config', 'kv')
+    expect(def).toBe(configKvKind)
+  })
+
+  it('returns undefined for an unregistered kind (D2: not an error)', () => {
+    const def = lookupContentType('tenant', 'custom-thing')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for unknown kind with valid type', () => {
+    const def = lookupContentType('unknown', 'pipeline')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for valid kind with unknown type', () => {
+    const def = lookupContentType('schema', 'not-a-real-type')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for empty kind string', () => {
+    const def = lookupContentType('', 'pipeline')
+    expect(def).toBeUndefined()
+  })
+
+  it('returns undefined for empty type string', () => {
+    const def = lookupContentType('schema', '')
+    expect(def).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// defineContentType (identity factory, L16)
+// ---------------------------------------------------------------------------
+
+describe('defineContentType', () => {
+  it('is an identity function — returns the same object reference', () => {
+    const def: ContentTypeDefinition<{ name: string }> = {
+      kind: 'tenant',
+      type: 'custom',
+      payloadSchema: { safeParse: () => ({ success: true, data: { name: 'x' } }) } as unknown as ContentTypeDefinition<{
+        name: string
+      }>['payloadSchema'],
+      label: 'Custom',
+      description: 'A tenant-defined type.',
+      parentTypes: []
+    }
+    const result = defineContentType(def)
+    expect(result).toBe(def)
+  })
+
+  it('does NOT mutate the input definition', () => {
+    const def: ContentTypeDefinition<unknown> = {
+      kind: 'schema',
+      type: 'pipeline',
+      payloadSchema: {
+        safeParse: () => ({ success: true, data: {} })
+      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
+      parentTypes: []
+    }
+    const original = { ...def }
+    defineContentType(def)
+    expect(def).toEqual(original)
+  })
+
+  it('does NOT register the definition globally (no side-effects on CONTENT_KIND_REGISTRY)', () => {
+    const tenantKey = 'tenant:my-new-type'
+    defineContentType({
+      kind: 'tenant',
+      type: 'my-new-type',
+      payloadSchema: {
+        safeParse: () => ({ success: true, data: {} })
+      } as unknown as ContentTypeDefinition<unknown>['payloadSchema'],
+      parentTypes: []
+    })
+    // After calling defineContentType, the registry must remain unchanged (D8: static)
+    expect(CONTENT_KIND_REGISTRY).not.toHaveProperty(tenantKey)
+  })
+})

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

@@ -1,194 +1,168 @@
-import { describe, expect, it } from 'vitest'
-import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
-import { DEFAULT_ORGANIZATION_MODEL_BRANDING } from '../domains/branding'
-import { OrganizationModelBrandingSchema } from '../domains/branding'
-import { DEFAULT_ORGANIZATION_MODEL_SALES } from '../domains/sales'
-import { OrganizationModelSalesSchema } from '../domains/sales'
-import { DEFAULT_ORGANIZATION_MODEL_PROJECTS } from '../domains/projects'
-import { OrganizationModelProjectsSchema } from '../domains/projects'
-import { DEFAULT_ORGANIZATION_MODEL_PROSPECTING } from '../domains/prospecting'
-import { OrganizationModelProspectingSchema } from '../domains/prospecting'
-import { DEFAULT_ORGANIZATION_MODEL_NAVIGATION } from '../domains/navigation'
-import { OrganizationModelNavigationSchema } from '../domains/navigation'
-import { DEFAULT_ORGANIZATION_MODEL_OPERATIONS } from '../domains/operations'
-import { OperationsDomainSchema } from '../domains/operations'
-import { DEFAULT_ORGANIZATION_MODEL_STATUSES } from '../domains/statuses'
-import { StatusesDomainSchema } from '../domains/statuses'
-import { DEFAULT_ORGANIZATION_MODEL_SYSTEMS, SystemsDomainSchema } from '../domains/systems'
-import { resolveOrganizationModel } from '../resolve'
-import { OrganizationModelSchema } from '../schema'
-
-// All DEFAULT_ORGANIZATION_MODEL* constants and the schemas used to validate them.
-// The composite constant lives in defaults.ts; domain sub-constants live in their
-// respective domain files. All are covered here for roundtrip integrity.
-const domainCases = [
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_BRANDING',
-    constant: DEFAULT_ORGANIZATION_MODEL_BRANDING,
-    schema: OrganizationModelBrandingSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_SALES',
-    constant: DEFAULT_ORGANIZATION_MODEL_SALES,
-    schema: OrganizationModelSalesSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_PROJECTS',
-    constant: DEFAULT_ORGANIZATION_MODEL_PROJECTS,
-    schema: OrganizationModelProjectsSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_PROSPECTING',
-    constant: DEFAULT_ORGANIZATION_MODEL_PROSPECTING,
-    schema: OrganizationModelProspectingSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_NAVIGATION',
-    constant: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
-    schema: OrganizationModelNavigationSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_STATUSES',
-    constant: DEFAULT_ORGANIZATION_MODEL_STATUSES,
-    schema: StatusesDomainSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_OPERATIONS',
-    constant: DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
-    schema: OperationsDomainSchema
-  },
-  {
-    name: 'DEFAULT_ORGANIZATION_MODEL_SYSTEMS',
-    constant: DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
-    schema: SystemsDomainSchema
-  }
-] as const
-
-describe('organization-model defaults', () => {
-  describe('DEFAULT_ORGANIZATION_MODEL (composite)', () => {
-    it('passes OrganizationModelSchema.parse without throwing', () => {
-      expect(() => OrganizationModelSchema.parse(DEFAULT_ORGANIZATION_MODEL)).not.toThrow()
-    })
-
-    it('resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL) returns a schema-valid model', () => {
-      const result = resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL)
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-
-    it('resolveOrganizationModel with no override equals resolveOrganizationModel with DEFAULT_ORGANIZATION_MODEL', () => {
-      const fromUndefined = resolveOrganizationModel(undefined)
-      const fromDefault = resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL)
-      expect(fromDefault).toEqual(fromUndefined)
-    })
-
-    it('keeps Command View enabled but development-only in the default Knowledge navigation', () => {
-      const result = resolveOrganizationModel(undefined)
-      const commandViewFeature = result.features.find((feature) => feature.id === 'knowledge.command-view')
-      const commandViewSurface = DEFAULT_ORGANIZATION_MODEL_NAVIGATION.surfaces.find(
-        (surface) => surface.id === 'knowledge.command-view'
-      )
-
-      expect(commandViewFeature?.enabled).toBe(true)
-      expect(commandViewFeature?.devOnly).toBe(true)
-      expect(commandViewSurface?.enabled).toBe(true)
-      expect(commandViewSurface?.devOnly).toBe(true)
-    })
-  })
-
-  describe.each(domainCases)('$name (domain sub-constant)', ({ name: _name, constant, schema }) => {
-    it('passes its domain schema parse without throwing', () => {
-      expect(() => schema.parse(constant)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_BRANDING via resolveOrganizationModel', () => {
-    it('resolving with branding override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ branding: DEFAULT_ORGANIZATION_MODEL_BRANDING })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_SALES via resolveOrganizationModel', () => {
-    it('resolving with sales override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ sales: DEFAULT_ORGANIZATION_MODEL_SALES })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_PROJECTS via resolveOrganizationModel', () => {
-    it('resolving with projects override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_PROSPECTING via resolveOrganizationModel', () => {
-    it('resolving with prospecting override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_NAVIGATION via resolveOrganizationModel', () => {
-    it('resolving with navigation override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS via resolveOrganizationModel', () => {
-    it('resolving with operations override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ operations: DEFAULT_ORGANIZATION_MODEL_OPERATIONS })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-
-    it('default operations seed covers all 5 entity categories', () => {
-      expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
-    })
-
-    it('every entry has a non-empty id, label, and semanticClass', () => {
-      for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-        expect(entry.id.length).toBeGreaterThan(0)
-        expect(entry.label.length).toBeGreaterThan(0)
-        expect(entry.semanticClass.length).toBeGreaterThan(0)
-      }
-    })
-
-    it('all entry ids are unique', () => {
-      const ids = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.id)
-      const uniqueIds = new Set(ids)
-      expect(uniqueIds.size).toBe(ids.length)
-    })
-  })
-
-  describe('DEFAULT_ORGANIZATION_MODEL_STATUSES via resolveOrganizationModel', () => {
-    it('resolving with statuses override produces a schema-valid model', () => {
-      const result = resolveOrganizationModel({ statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
-    })
-
-    it('default statuses seed covers all 9 delivery.task values', () => {
-      const taskEntries = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === 'delivery.task')
-      expect(taskEntries).toHaveLength(9)
-    })
-
-    it('default statuses seed covers all 5 queue values', () => {
-      const queueEntries = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === 'queue')
-      expect(queueEntries).toHaveLength(5)
-    })
-
-    it('every entry has a non-empty id, label, and semanticClass', () => {
-      for (const entry of DEFAULT_ORGANIZATION_MODEL_STATUSES.entries) {
-        expect(entry.id.length).toBeGreaterThan(0)
-        expect(entry.label.length).toBeGreaterThan(0)
-        expect(entry.semanticClass.length).toBeGreaterThan(0)
-      }
-    })
-
-    it('all entry ids are unique', () => {
-      const ids = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.map((e) => e.id)
-      const uniqueIds = new Set(ids)
-      expect(uniqueIds.size).toBe(ids.length)
-    })
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
+import { DEFAULT_ORGANIZATION_MODEL_BRANDING, OrganizationModelBrandingSchema } from '../domains/branding'
+import { DEFAULT_ORGANIZATION_MODEL_ENTITIES, EntitiesDomainSchema } from '../domains/entities'
+import { DEFAULT_ORGANIZATION_MODEL_STATUSES, StatusesDomainSchema } from '../domains/statuses'
+import { DEFAULT_ORGANIZATION_MODEL_SYSTEMS, SystemsDomainSchema } from '../domains/systems'
+import { resolveOrganizationModel } from '../resolve'
+import { OrganizationModelSchema } from '../schema'
+import { DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE } from '../defaults'
+
+// Phase 4 (D8): sales, prospecting, projects, navigation top-level OM fields removed.
+// DEFAULT_ORGANIZATION_MODEL_SALES / OrganizationModelSalesSchema,
+// DEFAULT_ORGANIZATION_MODEL_PROJECTS / OrganizationModelProjectsSchema,
+// DEFAULT_ORGANIZATION_MODEL_PROSPECTING / OrganizationModelProspectingSchema,
+// DEFAULT_ORGANIZATION_MODEL_NAVIGATION / OrganizationModelNavigationSchema
+// are no longer exported from their respective domain files.
+// Tests that depended on these exports are skipped with explicit reason comments.
+
+// Only the domain constants and schemas that still exist are covered here.
+const domainCases = [
+  {
+    name: 'DEFAULT_ORGANIZATION_MODEL_BRANDING',
+    constant: DEFAULT_ORGANIZATION_MODEL_BRANDING,
+    schema: OrganizationModelBrandingSchema
+  },
+  {
+    name: 'DEFAULT_ORGANIZATION_MODEL_ENTITIES',
+    constant: DEFAULT_ORGANIZATION_MODEL_ENTITIES,
+    schema: EntitiesDomainSchema
+  },
+  {
+    name: 'DEFAULT_ORGANIZATION_MODEL_STATUSES',
+    constant: DEFAULT_ORGANIZATION_MODEL_STATUSES,
+    schema: StatusesDomainSchema
+  },
+  {
+    name: 'DEFAULT_ORGANIZATION_MODEL_SYSTEMS',
+    constant: DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+    schema: SystemsDomainSchema
+  }
+] as const
+
+describe('organization-model defaults', () => {
+  describe('DEFAULT_ORGANIZATION_MODEL (composite)', () => {
+    it('passes OrganizationModelSchema.parse without throwing', () => {
+      expect(() => OrganizationModelSchema.parse(DEFAULT_ORGANIZATION_MODEL)).not.toThrow()
+    })
+
+    it('resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL) returns a schema-valid model', () => {
+      const result = resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL)
+      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+    })
+
+    it('resolveOrganizationModel with no override equals resolveOrganizationModel with DEFAULT_ORGANIZATION_MODEL', () => {
+      const fromUndefined = resolveOrganizationModel(undefined)
+      const fromDefault = resolveOrganizationModel(DEFAULT_ORGANIZATION_MODEL)
+      expect(fromDefault).toEqual(fromUndefined)
+    })
+
+    // Phase 4 (D8): model.navigation removed. The knowledge.command-view surface tracking
+    // previously used DEFAULT_ORGANIZATION_MODEL_NAVIGATION.surfaces — skipped since that
+    // constant is deleted. The system itself still exists; only the navigation surface
+    // reference is gone from the top-level schema.
+    it.skip('keeps Command View enabled but development-only in the default Knowledge navigation (deferred — Phase 4: navigation domain removed)', () => {
+      // Previously checked DEFAULT_ORGANIZATION_MODEL_NAVIGATION.surfaces.
+      // The command-view system still exists in DEFAULT_ORGANIZATION_MODEL.systems.
+      // Re-enable with a top-level surfaces Record fixture if that assertion is needed.
+    })
+  })
+
+  describe.each(domainCases)('$name (domain sub-constant)', ({ name: _name, constant, schema }) => {
+    it('passes its domain schema parse without throwing', () => {
+      expect(() => schema.parse(constant)).not.toThrow()
+    })
+  })
+
+  // Phase 4 (D8): OrganizationModelSalesSchema, DEFAULT_ORGANIZATION_MODEL_SALES removed.
+  describe.skip('DEFAULT_ORGANIZATION_MODEL_SALES via resolveOrganizationModel (deferred — Phase 4: sales domain removed)', () => {
+    it('resolving with sales override produces a schema-valid model', () => {
+      // Previously: resolveOrganizationModel({ sales: DEFAULT_ORGANIZATION_MODEL_SALES })
+      // Sales data now lives in system.content. Use getAllPipelines(model) from migration-helpers.
+    })
+  })
+
+  // Phase 4 (D8): OrganizationModelProjectsSchema, DEFAULT_ORGANIZATION_MODEL_PROJECTS removed.
+  describe.skip('DEFAULT_ORGANIZATION_MODEL_PROJECTS via resolveOrganizationModel (deferred — Phase 4: projects domain removed)', () => {
+    it('resolving with projects override produces a schema-valid model', () => {
+      // Previously: resolveOrganizationModel({ projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS })
+      // Project statuses now live in system.content. Use getAllProjectStatuses(model) from migration-helpers.
+    })
+  })
+
+  // Phase 4 (D8): OrganizationModelProspectingSchema, DEFAULT_ORGANIZATION_MODEL_PROSPECTING removed.
+  describe.skip('DEFAULT_ORGANIZATION_MODEL_PROSPECTING via resolveOrganizationModel (deferred — Phase 4: prospecting domain removed)', () => {
+    it('resolving with prospecting override produces a schema-valid model', () => {
+      // Previously: resolveOrganizationModel({ prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING })
+      // Prospecting stages/templates now live in system.content. Use getAllProspectingStages() / getAllBuildTemplates().
+    })
+  })
+
+  // Phase 4 (D8): OrganizationModelNavigationSchema, DEFAULT_ORGANIZATION_MODEL_NAVIGATION removed.
+  describe.skip('DEFAULT_ORGANIZATION_MODEL_NAVIGATION via resolveOrganizationModel (deferred — Phase 4: navigation domain removed)', () => {
+    it('resolving with navigation override produces a schema-valid model', () => {
+      // Previously: resolveOrganizationModel({ navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION })
+      // Surfaces and navigation groups are now top-level Records on OrganizationModelSchemaBase.
+    })
+  })
+
+  describe('DEFAULT_ORGANIZATION_MODEL_BRANDING via resolveOrganizationModel', () => {
+    it('resolving with branding override produces a schema-valid model', () => {
+      const result = resolveOrganizationModel({ branding: DEFAULT_ORGANIZATION_MODEL_BRANDING })
+      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+    })
+  })
+
+  describe('DEFAULT_ORGANIZATION_MODEL_STATUSES via resolveOrganizationModel', () => {
+    // Phase 4 (D1): statuses top-level field removed from OM schema.
+    // DEFAULT_ORGANIZATION_MODEL_STATUSES is still exported from domains/statuses.ts
+    // (it's used by the UI statuses domain as a semantic registry, not OM-schema-level data).
+    // The resolveOrganizationModel override with { statuses: ... } was silently accepted
+    // before Phase 4 because statuses was an extra field; now statuses is gone from OM entirely.
+    // We keep the data-integrity checks below; the resolveOrganizationModel override test is skipped.
+    it.skip('resolving with statuses override produces a schema-valid model (deferred — Phase 4: statuses field removed from OM schema)', () => {
+      // Previously: resolveOrganizationModel({ statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES })
+      // Status data now lives in system.content via (schema:status-flow) + (schema:status) content nodes.
+    })
+
+    it('default statuses seed covers all 9 delivery.task values', () => {
+      const taskEntries = Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES).filter(
+        (e) => e.semanticClass === 'delivery.task'
+      )
+      expect(taskEntries).toHaveLength(9)
+    })
+
+    it('default statuses seed covers all 5 queue values', () => {
+      const queueEntries = Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES).filter((e) => e.semanticClass === 'queue')
+      expect(queueEntries).toHaveLength(5)
+    })
+
+    it('every entry has a non-empty id, label, and semanticClass', () => {
+      for (const entry of Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES)) {
+        expect(entry.id.length).toBeGreaterThan(0)
+        expect(entry.label.length).toBeGreaterThan(0)
+        expect(entry.semanticClass.length).toBeGreaterThan(0)
+      }
+    })
+
+    it('all entry ids are unique', () => {
+      const ids = Object.values(DEFAULT_ORGANIZATION_MODEL_STATUSES).map((e) => e.id)
+      const uniqueIds = new Set(ids)
+      expect(uniqueIds.size).toBe(ids.length)
+    })
+  })
+
+  describe('DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE — flat Record (Phase 4 D3)', () => {
+    it('is an empty object (no pre-seeded nodes in generic base)', () => {
+      expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).toEqual({})
+    })
+
+    it('does not have a .nodes array (old wrapper shape removed)', () => {
+      expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).not.toHaveProperty('nodes')
+    })
+
+    it('does not have a .version field (moved to domainMetadata.knowledge)', () => {
+      expect(DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE).not.toHaveProperty('version')
+    })
+  })
+})

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

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest'
+import {
+  ActionsDomainSchema,
+  ActionInvocationSchema,
+  CRM_ACTION_ENTRIES,
+  DEFAULT_ORGANIZATION_MODEL_ACTIONS,
+  LEAD_GEN_ACTION_ENTRIES
+} from '../../domains/actions'
+
+describe('actions domain', () => {
+  it('defaults lead-gen action entries with invocation contracts', () => {
+    const domain = ActionsDomainSchema.parse(LEAD_GEN_ACTION_ENTRIES)
+
+    expect(Object.keys(domain)).toHaveLength(13)
+    expect(domain['lead-gen.company.source']).toMatchObject({
+      id: 'lead-gen.company.source',
+      scope: { domain: 'sales' },
+      lifecycle: 'active'
+    })
+    expect(Object.values(domain).every((action) => action.invocations.length > 0)).toBe(true)
+  })
+
+  it('defaults CRM action entries for deal actions', () => {
+    const domain = ActionsDomainSchema.parse(CRM_ACTION_ENTRIES)
+
+    expect(Object.keys(domain)).toHaveLength(9)
+    expect(domain.mark_no_show).toBeUndefined()
+    expect(
+      Object.values(domain).every((action) => action.affects?.includes('crm.deal') && action.resourceId !== undefined)
+    ).toBe(true)
+  })
+
+  it('defaults all organization-model actions', () => {
+    const domain = ActionsDomainSchema.parse(DEFAULT_ORGANIZATION_MODEL_ACTIONS)
+
+    expect(Object.keys(domain)).toHaveLength(22)
+  })
+
+  it('accepts entity references in affects', () => {
+    expect(() =>
+      ActionsDomainSchema.parse({
+        'crm.deal.update': {
+          id: 'crm.deal.update',
+          order: 10,
+          label: 'Update deal',
+          affects: ['crm.deal']
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('accepts every invocation kind', () => {
+    expect(() =>
+      ActionInvocationSchema.parse({
+        kind: 'slash-command',
+        command: '/lead-gen source',
+        toolFactory: 'lead-gen-source'
+      })
+    ).not.toThrow()
+    expect(() => ActionInvocationSchema.parse({ kind: 'mcp-tool', server: 'lead-gen', name: 'source' })).not.toThrow()
+    expect(() =>
+      ActionInvocationSchema.parse({
+        kind: 'api-endpoint',
+        method: 'POST',
+        path: '/api/prospecting/source',
+        requestSchema: 'source-request',
+        responseSchema: 'source-response'
+      })
+    ).not.toThrow()
+    expect(() =>
+      ActionInvocationSchema.parse({ kind: 'script-execution', resourceId: 'scripts.lead-gen-source' })
+    ).not.toThrow()
+  })
+
+  it('rejects malformed slash commands', () => {
+    expect(() => ActionInvocationSchema.parse({ kind: 'slash-command', command: 'lead-gen source' })).toThrow()
+  })
+})