@elevasis/core 0.22.0 → 0.23.0

package/src/organization-model/README.md

@@ -1,20 +1,19 @@
 # Organization Model
 
-The organization model is the published semantic contract that maps a tenant's product shape to flat feature hierarchy, shell navigation, business semantics, and graph bindings.
+The organization model is the published semantic contract that maps a tenant's System hierarchy, shell navigation, business semantics, resource governance, and graph bindings.
 
-Use this module when resolving or validating an organization's contract before wiring UI shells, routing, feature gates, or domain-specific capability checks.
+Use this module when resolving or validating an organization's contract before wiring UI shells, routing, system gates, or domain-specific capability checks.
 
 ## Published Exports
 
 The public entry point exposes:
 
 - `OrganizationModelSchema`
-- `FeatureSchema`
 - `DEFAULT_ORGANIZATION_MODEL`
 - `defineOrganizationModel`
 - `resolveOrganizationModel`
 - `createFoundationOrganizationModel`
-- node ID and feature helper types
+- node ID and System helper types
 - `OrganizationModel` and supporting domain types
 
 Import it from the published subpath:
@@ -36,8 +35,8 @@ The model is versioned and currently validates against `version: 1`.
 Top-level fields:
 
 - `version`
+- `domainMetadata`
 - `branding`
-- `features`
 - `navigation`
 - `sales`
 - `prospecting`
@@ -49,40 +48,81 @@ Top-level fields:
 - `goals`
 - `systems`
 - `resources`
+- `capabilities`
+- `policies`
 - `statuses`
-- `operations`
 - `knowledge`
 
-Resource identity is authored in `resources.entries`. Runtime workflows, agents, and integrations import those descriptors, derive `resourceId` and kind from them, and attach executable behavior in operations code.
+The pure collection domains are id-keyed maps: `systems`, `roles`, `goals`, `customers`, `offerings`, `resources`, `capabilities`, `policies`, and `statuses`. The map key must match the entry `id`. Entries carry `order` for deterministic ordered views; use `listDomain(record)` when order matters.
 
-## Feature Set
+Resource identity is authored in `resources`. Runtime workflows, agents, integrations, and scripts import those descriptors, derive `resourceId` and kind from them, and attach executable behavior in operations code.
 
-Feature hierarchy is authored as a flat array. Dotted IDs define parent/child relationships:
+## System Set
+
+System hierarchy is authored as an id-keyed `systems` map. Dotted IDs and `parentSystemId` define parent/child relationships:
+
+```ts
+systems: {
+  dashboard: { id: 'dashboard', order: 10, label: 'Dashboard', lifecycle: 'active' },
+  sales: { id: 'sales', order: 20, label: 'Sales', lifecycle: 'active' },
+  clients: { id: 'clients', order: 30, label: 'Clients', lifecycle: 'active' },
+  projects: { id: 'projects', order: 40, label: 'Projects', lifecycle: 'active' }
+}
+```
+
+Systems describe semantic ownership, hierarchy, lifecycle, access, and governance. Sidebar presentation is authored separately under `navigation.sidebar`; UI-backed Systems may still provide `ui.path` for route matching during the migration, but they do not author composed surface lists. Lifecycle values such as `active`, `beta`, `deprecated`, and `archived` replace the old feature enabled/dev-only split.
+
+## Sidebar Navigation
+
+Shell navigation is authored as a recursive sidebar tree:
 
 ```ts
-features: [
-  { id: 'dashboard', label: 'Dashboard', enabled: true, path: '/', uiPosition: 'sidebar-primary' },
-  { id: 'sales', label: 'Sales', enabled: true, uiPosition: 'sidebar-primary' },
-  { id: 'sales.crm', label: 'CRM', enabled: true, path: '/crm' },
-  { id: 'operations.resources', label: 'Resources', enabled: true, path: '/operations/resources' }
-]
+navigation: {
+  sidebar: {
+    primary: {
+      dashboard: {
+        type: 'surface',
+        order: 10,
+        label: 'Dashboard',
+        path: '/',
+        surfaceType: 'dashboard',
+        targets: { systems: ['dashboard'] }
+      },
+      business: {
+        type: 'group',
+        order: 20,
+        label: 'Business',
+        children: {
+          clients: {
+            type: 'surface',
+            order: 20,
+            label: 'Clients',
+            path: '/clients',
+            surfaceType: 'list',
+            targets: { systems: ['clients'] }
+          }
+        }
+      }
+    },
+    bottom: {}
+  }
+}
 ```
 
-Containers omit `path`; leaves provide `path`. `uiPosition`, `requiresAdmin`, and `devOnly` inherit from ancestors.
-Development-only features remain in the contract with `enabled: true` and `devOnly: true`; shell consumers hide them and guard their paths outside development mode.
+Routeable sidebar leaves are projected into flat semantic surface DTOs by `projectOrganizationSurfaces(model)`. Do not author top-level `surfaces` or `navigationGroups` fields on `OrganizationModel`.
 
 ## Graph IDs
 
 Cross-collection links use kind-prefixed IDs:
 
-- `feature:sales.crm`
+- `system:sales.crm`
 - `integration:instantly`
 - `resource:lead-import`
-- `capability:operations.queue.review`
+- `action:operations.queue.review`
 
 ## Resource Descriptors
 
-The OM Resources domain is governance-only. Descriptors declare canonical `id`, required `systemId`, governance `status`, and optional role ownership. `DeploymentSpec` remains the runtime/deploy assembly around those descriptors, not a second resource identity catalog.
+The OM Resources domain is governance-only. Descriptors declare canonical `id`, required `systemPath`, governance `status`, and optional role ownership. `DeploymentSpec` remains the runtime/deploy assembly around those descriptors, not a second resource identity catalog.
 
 ## Resolution Semantics
 
@@ -90,20 +130,20 @@ The OM Resources domain is governance-only. Descriptors declare canonical `id`,
 - `resolveOrganizationModel()` deep-merges a partial override into the default model, then validates it.
 - `createFoundationOrganizationModel()` resolves the canonical model and returns UI-facing helper outputs.
 - Plain objects merge recursively.
+- Id-keyed domain maps merge additively by key.
 - Arrays replace the default value.
 - Missing fields fall back to `DEFAULT_ORGANIZATION_MODEL`.
 
 ## Referential Integrity
 
-- Feature IDs must be unique.
-- Child feature IDs require ancestor feature nodes.
-- Container features omit `path`.
-- Leaf features provide `path`.
+- System IDs must be unique.
+- Child System IDs require valid ancestors or `parentSystemId` links.
+- Systems with UI provide `ui.path`.
 - Systems, resources, roles, knowledge nodes, and goals must resolve their declared cross-references.
 
 ## Practical Guidance
 
 - Use `resolveOrganizationModel()` when you need a runtime-safe model.
 - Use `defineOrganizationModel()` when authoring static overrides.
-- Keep feature IDs stable because shell routing, gating, breadcrumbs, and docs depend on them.
-- Put resource identity and governance in `resources.entries`; attach executable behavior in operations.
+- Keep System IDs stable because shell routing, gating, breadcrumbs, and docs depend on them.
+- Put resource identity and governance in `resources`; attach executable behavior in operations.

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,26 +1,22 @@
 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_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'
 
-// 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.
+// 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',
@@ -28,35 +24,15 @@ const domainCases = [
     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_ENTITIES',
+    constant: DEFAULT_ORGANIZATION_MODEL_ENTITIES,
+    schema: EntitiesDomainSchema
   },
   {
     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,
@@ -81,17 +57,14 @@ describe('organization-model defaults', () => {
       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)
+    // 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.
     })
   })
 
@@ -101,84 +74,71 @@ describe('organization-model defaults', () => {
     })
   })
 
-  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', () => {
+  // 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', () => {
-      const result = resolveOrganizationModel({ sales: DEFAULT_ORGANIZATION_MODEL_SALES })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+      // Previously: resolveOrganizationModel({ sales: DEFAULT_ORGANIZATION_MODEL_SALES })
+      // Sales data now lives in system.content. Use getAllPipelines(model) from migration-helpers.
     })
   })
 
-  describe('DEFAULT_ORGANIZATION_MODEL_PROJECTS via resolveOrganizationModel', () => {
+  // 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', () => {
-      const result = resolveOrganizationModel({ projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+      // Previously: resolveOrganizationModel({ projects: DEFAULT_ORGANIZATION_MODEL_PROJECTS })
+      // Project statuses now live in system.content. Use getAllProjectStatuses(model) from migration-helpers.
     })
   })
 
-  describe('DEFAULT_ORGANIZATION_MODEL_PROSPECTING via resolveOrganizationModel', () => {
+  // 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', () => {
-      const result = resolveOrganizationModel({ prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+      // Previously: resolveOrganizationModel({ prospecting: DEFAULT_ORGANIZATION_MODEL_PROSPECTING })
+      // Prospecting stages/templates now live in system.content. Use getAllProspectingStages() / getAllBuildTemplates().
     })
   })
 
-  describe('DEFAULT_ORGANIZATION_MODEL_NAVIGATION via resolveOrganizationModel', () => {
+  // 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', () => {
-      const result = resolveOrganizationModel({ navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION })
-      expect(() => OrganizationModelSchema.parse(result)).not.toThrow()
+      // Previously: resolveOrganizationModel({ navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION })
+      // Surfaces and navigation groups are now top-level Records on OrganizationModelSchemaBase.
     })
   })
 
-  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 })
+  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()
     })
-
-    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()
+    // 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 = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === 'delivery.task')
+      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 = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.filter((e) => e.semanticClass === 'queue')
+      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 DEFAULT_ORGANIZATION_MODEL_STATUSES.entries) {
+      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)
@@ -186,9 +146,23 @@ describe('organization-model defaults', () => {
     })
 
     it('all entry ids are unique', () => {
-      const ids = DEFAULT_ORGANIZATION_MODEL_STATUSES.entries.map((e) => e.id)
+      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')
+    })
+  })
 })