@elevasis/core 0.21.0 → 0.22.0

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

@@ -0,0 +1,193 @@
+import { describe, expect, it } from 'vitest'
+import {
+  DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+  SystemEntrySchema,
+  SystemKindSchema,
+  SystemsDomainSchema,
+  SystemStatusSchema
+} from '../../domains/systems'
+import { resolveOrganizationModel } from '../../resolve'
+
+const VALID_SYSTEM = {
+  id: 'sys.lead-gen',
+  title: 'Lead Generation Pipeline',
+  description: 'Coordinates prospecting, enrichment, qualification, and outreach preparation.',
+  kind: 'operational' as const,
+  status: 'active' as const
+}
+
+describe('SystemEntrySchema - positive parse', () => {
+  it('accepts a minimal tenant-defined system', () => {
+    const result = SystemEntrySchema.safeParse(VALID_SYSTEM)
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.governedByKnowledge).toEqual([])
+      expect(result.data.drivesGoals).toEqual([])
+    }
+  })
+
+  it('accepts all optional governance references when present', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      responsibleRoleId: 'role.sales-ops',
+      governedByKnowledge: ['knowledge.lead-gen-playbook'],
+      drivesGoals: ['goal.pipeline-coverage']
+    })
+
+    expect(result.success).toBe(true)
+  })
+
+  it('trims id, title, and description', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      id: '  sys.crm  ',
+      title: '  CRM  ',
+      description: '  Owns relationship and deal pipeline operations.  '
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.id).toBe('sys.crm')
+      expect(result.data.title).toBe('CRM')
+      expect(result.data.description).toBe('Owns relationship and deal pipeline operations.')
+    }
+  })
+})
+
+describe('SystemEntrySchema - negative parse', () => {
+  it('rejects missing required fields', () => {
+    expect(SystemEntrySchema.safeParse({ id: 'sys.missing' }).success).toBe(false)
+  })
+
+  it('rejects an unknown system kind', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, kind: 'sales' }).success).toBe(false)
+  })
+
+  it('rejects an unknown system status', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, status: 'paused' }).success).toBe(false)
+  })
+
+  it('rejects IDs that do not match the OM model-id format', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
+  })
+})
+
+describe('SystemsDomainSchema', () => {
+  it('accepts an empty systems array', () => {
+    expect(SystemsDomainSchema.safeParse({ systems: [] }).success).toBe(true)
+  })
+
+  it('defaults systems to an empty array when omitted', () => {
+    const result = SystemsDomainSchema.safeParse({})
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
+    }
+  })
+})
+
+describe('SystemKindSchema and SystemStatusSchema', () => {
+  it.each(['product', 'operational', 'platform', 'diagnostic'] as const)('accepts kind "%s"', (kind) => {
+    expect(SystemKindSchema.safeParse(kind).success).toBe(true)
+  })
+
+  it.each(['active', 'deprecated', 'archived'] as const)('accepts status "%s"', (status) => {
+    expect(SystemStatusSchema.safeParse(status).success).toBe(true)
+  })
+})
+
+describe('resolveOrganizationModel - systems domain integration', () => {
+  it('omitting systems resolves to the empty default catalog', () => {
+    const model = resolveOrganizationModel({})
+
+    expect(model.systems).toEqual(DEFAULT_ORGANIZATION_MODEL_SYSTEMS)
+  })
+
+  it('accepts valid responsible role, knowledge, and goal references', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: { roles: [{ id: 'role.sales-ops', title: 'Sales Ops' }] },
+        goals: {
+          objectives: [
+            {
+              id: 'goal.pipeline-coverage',
+              description: 'Improve sales pipeline coverage',
+              periodStart: '2026-01-01',
+              periodEnd: '2026-12-31'
+            }
+          ]
+        },
+        knowledge: {
+          nodes: [
+            {
+              id: 'knowledge.lead-gen-playbook',
+              kind: 'playbook',
+              title: 'Lead Gen Playbook',
+              summary: 'How lead generation is governed.',
+              body: '## Lead Gen',
+              updatedAt: '2026-05-08'
+            }
+          ]
+        },
+        systems: {
+          systems: [
+            {
+              ...VALID_SYSTEM,
+              responsibleRoleId: 'role.sales-ops',
+              governedByKnowledge: ['knowledge.lead-gen-playbook'],
+              drivesGoals: ['goal.pipeline-coverage']
+            }
+          ]
+        }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when system IDs are duplicated', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          systems: [
+            VALID_SYSTEM,
+            {
+              ...VALID_SYSTEM,
+              title: 'Duplicate System'
+            }
+          ]
+        }
+      })
+    ).toThrow(/System id \\"sys\.lead-gen\\" must be unique/)
+  })
+
+  it('throws when responsibleRoleId references an unknown role', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          systems: [{ ...VALID_SYSTEM, responsibleRoleId: 'role.missing' }]
+        }
+      })
+    ).toThrow(/unknown responsibleRoleId \\"role\.missing\\"/)
+  })
+
+  it('throws when governedByKnowledge references an unknown knowledge node', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          systems: [{ ...VALID_SYSTEM, governedByKnowledge: ['knowledge.missing'] }]
+        }
+      })
+    ).toThrow(/unknown knowledge node \\"knowledge\.missing\\"/)
+  })
+
+  it('throws when drivesGoals references an unknown goal', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        systems: {
+          systems: [{ ...VALID_SYSTEM, drivesGoals: ['goal.missing'] }]
+        }
+      })
+    ).toThrow(/unknown goal \\"goal\.missing\\"/)
+  })
+})

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

@@ -8,6 +8,7 @@ import {
 import { OrganizationGraphEdgeKindSchema } from '../graph/schema'
 import { buildOrganizationGraph } from '../graph/build'
 import { DEFAULT_ORGANIZATION_MODEL, DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE } from '../defaults'
+import { resolveOrganizationModel } from '../resolve'
 import type { OrganizationModel } from '../types'
 
 // ---------------------------------------------------------------------------
@@ -74,6 +75,15 @@ describe('OrgKnowledgeNodeSchema', () => {
     expect(node.ownerIds).toEqual([])
   })
 
+  it('accepts role ids as knowledge owners', () => {
+    const node = OrgKnowledgeNodeSchema.parse({
+      ...makeNode('strategy'),
+      ownerIds: ['role.ops-lead', 'role.ceo']
+    })
+
+    expect(node.ownerIds).toEqual(['role.ops-lead', 'role.ceo'])
+  })
+
   it('accepts an optional semantic icon token', () => {
     const node = OrgKnowledgeNodeSchema.parse({
       ...makeNode('playbook'),
@@ -93,6 +103,35 @@ describe('OrgKnowledgeNodeSchema', () => {
   })
 })
 
+describe('resolveOrganizationModel with knowledge owner roles', () => {
+  const node = {
+    id: 'knowledge.test-owner',
+    kind: 'playbook' as const,
+    title: 'Owned Knowledge',
+    summary: 'A knowledge node with role ownership.',
+    body: '## Body\n\nContent.',
+    ownerIds: ['role.ops-lead'],
+    updatedAt: '2026-05-08'
+  }
+
+  it('passes when ownerIds reference declared role ids', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        roles: { roles: [{ id: 'role.ops-lead', title: 'Ops Lead' }] },
+        knowledge: { nodes: [node] }
+      })
+    ).not.toThrow()
+  })
+
+  it('throws when ownerIds reference unknown role ids', () => {
+    expect(() =>
+      resolveOrganizationModel({
+        knowledge: { nodes: [node] }
+      })
+    ).toThrow(/unknown owner role/)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // OrgKnowledgeKindSchema — enum shape
 // ---------------------------------------------------------------------------

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

@@ -7,7 +7,7 @@ describe('organization-model resolve', () => {
 
     expect(model.version).toBe(1)
     expect(model.features.find((feature) => feature.id === 'dashboard')?.path).toBe('/')
-    expect(model.features.find((feature) => feature.id === 'sales')?.path).toBeUndefined()
+    expect(model.features.find((feature) => feature.id === 'sales')?.path).toBe('/sales')
     expect(model.features.find((feature) => feature.id === 'sales.crm')?.path).toBe('/crm')
     expect(model.features.find((feature) => feature.id === 'admin')?.requiresAdmin).toBe(true)
     expect(model.features.find((feature) => feature.id === 'archive')?.devOnly).toBe(true)

package/src/organization-model/defaults.ts

@@ -20,6 +20,8 @@ import { DEFAULT_ORGANIZATION_MODEL_PROSPECTING } from './domains/prospecting'
 import { DEFAULT_ORGANIZATION_MODEL_OPERATIONS } from './domains/operations'
 import { DEFAULT_ORGANIZATION_MODEL_ROLES } from './domains/roles'
 import { DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
+import { DEFAULT_ORGANIZATION_MODEL_SYSTEMS } from './domains/systems'
+import { DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
 import { DEFAULT_ORGANIZATION_MODEL_STATUSES } from './domains/statuses'
 import type { KnowledgeDomain } from './domains/knowledge'
 
@@ -61,6 +63,15 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       color: 'green',
       icon: 'feature.finance'
     },
+    {
+      id: 'business',
+      label: 'Business',
+      description: 'Revenue, client relationships, and project delivery',
+      enabled: true,
+      color: 'blue',
+      icon: 'feature.business',
+      uiPosition: 'sidebar-primary'
+    },
     {
       id: 'sales',
       label: 'Sales',
@@ -68,7 +79,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       color: 'blue',
       icon: 'feature.sales',
-      uiPosition: 'sidebar-primary'
+      path: '/sales'
     },
     {
       id: 'sales.crm',
@@ -95,8 +106,16 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
       enabled: true,
       color: 'orange',
       icon: 'feature.projects',
-      path: '/projects',
-      uiPosition: 'sidebar-primary'
+      path: '/projects'
+    },
+    {
+      id: 'clients',
+      label: 'Clients',
+      description: 'Client relationships, accounts, and business context',
+      enabled: true,
+      color: 'orange',
+      icon: 'feature.projects',
+      path: '/business/clients'
     },
     {
       id: 'operations',
@@ -341,6 +360,8 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
   roles: DEFAULT_ORGANIZATION_MODEL_ROLES,
   goals: DEFAULT_ORGANIZATION_MODEL_GOALS,
+  systems: DEFAULT_ORGANIZATION_MODEL_SYSTEMS,
+  resources: DEFAULT_ORGANIZATION_MODEL_RESOURCES,
   statuses: DEFAULT_ORGANIZATION_MODEL_STATUSES,
   operations: DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
   knowledge: DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE

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

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 import { IconNameSchema, ModelIdSchema } from './shared'
 import { NodeIdStringSchema } from './features'
+import { RoleIdSchema } from './roles'
 
 // ---------------------------------------------------------------------------
 // KnowledgeLink — a typed graph link pointing to another OM node.
@@ -40,8 +41,8 @@ export const OrgKnowledgeNodeSchema = z.object({
   skills: z.array(KnowledgeSkillBindingSchema).optional(),
   /** Domain key used to derive fast graph->skill registries. */
   domain: KnowledgeDomainBindingSchema.optional(),
-  /** Identifiers of the roles or members who own this knowledge node. */
-  ownerIds: z.array(ModelIdSchema).default([]),
+  /** Role identifiers that own this knowledge node. */
+  ownerIds: z.array(RoleIdSchema).default([]),
   /** ISO date string (YYYY-MM-DD or full ISO 8601) of last meaningful update. */
   updatedAt: z.string().trim().min(1).max(50)
 })

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

@@ -0,0 +1,88 @@
+import { z } from 'zod'
+import { ModelIdSchema } from './shared'
+import { SystemIdSchema } from './systems'
+
+// ---------------------------------------------------------------------------
+// Resources domain
+// ---------------------------------------------------------------------------
+//
+// Resources are governance-only OM descriptors. Runtime code imports these
+// descriptors and attaches executable behavior; it does not re-author identity.
+
+export const ResourceKindSchema = z.enum(['workflow', 'agent', 'integration'])
+export const ResourceGovernanceStatusSchema = z.enum(['active', 'deprecated', 'archived'])
+export const AgentKindSchema = z.enum(['orchestrator', 'specialist', 'utility', 'system'])
+
+export const ResourceIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(255)
+  .regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, 'Resource IDs must use letters, numbers, -, _, or . separators')
+
+const ResourceEntryBaseSchema = z.object({
+  /** Canonical resource id; runtime resourceId derives from this value. */
+  id: ResourceIdSchema,
+  /** Required single System membership. */
+  systemId: SystemIdSchema,
+  /** Optional role responsible for maintaining this resource. */
+  ownerRoleId: ModelIdSchema.optional(),
+  status: ResourceGovernanceStatusSchema
+})
+
+export const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('workflow'),
+  /** Mirrors WorkflowConfig.capabilityKey when the runtime workflow has one. */
+  capabilityKey: z.string().trim().min(1).max(255).optional()
+})
+
+export const AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('agent'),
+  /** Mirrors code-side AgentConfig.kind. */
+  agentKind: AgentKindSchema,
+  /** Role this agent embodies, if any. */
+  actsAsRoleId: ModelIdSchema.optional(),
+  /** Mirrors AgentConfig.sessionCapable. */
+  sessionCapable: z.boolean()
+})
+
+export const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('integration'),
+  provider: z.string().trim().min(1).max(100)
+})
+
+export const ResourceEntrySchema = z.discriminatedUnion('kind', [
+  WorkflowResourceEntrySchema,
+  AgentResourceEntrySchema,
+  IntegrationResourceEntrySchema
+])
+
+export const ResourcesDomainSchema = z.object({
+  entries: z.array(ResourceEntrySchema).default([])
+})
+
+export const DEFAULT_ORGANIZATION_MODEL_RESOURCES: z.infer<typeof ResourcesDomainSchema> = {
+  entries: []
+}
+
+export function defineResource<const TResource extends ResourceEntry>(resource: TResource): TResource {
+  return ResourceEntrySchema.parse(resource) as TResource
+}
+
+export function defineResources<const TResources extends Record<string, ResourceEntry>>(resources: TResources): TResources {
+  for (const resource of Object.values(resources)) {
+    ResourceEntrySchema.parse(resource)
+  }
+
+  return resources
+}
+
+export type ResourceId = z.infer<typeof ResourceIdSchema>
+export type ResourceKind = z.infer<typeof ResourceKindSchema>
+export type ResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>
+export type ResourceAgentKind = z.infer<typeof AgentKindSchema>
+export type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
+export type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
+export type IntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+export type ResourceEntry = z.infer<typeof ResourceEntrySchema>
+export type ResourcesDomain = z.infer<typeof ResourcesDomainSchema>

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

@@ -1,55 +1,93 @@
-import { z } from 'zod'
-
-// ---------------------------------------------------------------------------
-// Role schema — one entry per distinct role in the organization's chart.
-// Inspired by the EOS Accountability Chart but uses plain-language field names
-// throughout. No EOS jargon: "title" (not seatTitle), "responsibilities"
-// (not accountabilities), "reportsToId", "heldBy".
-//
-// Cross-reference: `reportsToId` (when present) must resolve to another
-// `roles[].id` in the same collection. Enforcement is via
-// `OrganizationModelSchema.superRefine()` — not at the individual schema level.
-// Cycle detection is NOT enforced (known limitation; document if needed).
-// ---------------------------------------------------------------------------
-
-export const RoleSchema = z.object({
-  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
-  id: z.string().trim().min(1).max(100),
-  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
-  title: z.string().trim().min(1).max(200),
-  /**
-   * List of responsibilities this role owns — plain-language descriptions of
-   * what the person in this role is accountable for delivering.
-   * Defaults to empty array so minimal role definitions stay concise.
-   */
-  responsibilities: z.array(z.string().trim().max(500)).default([]),
-  /**
-   * Optional: ID of another role this role reports to.
-   * When present, must reference another `roles[].id` in the same organization.
-   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
-   * Absence indicates a top-level role (no reporting line).
-   */
-  reportsToId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional: name or email of the person currently holding this role.
-   * Free-form string — supports "Alice Johnson", "alice@example.com", or
-   * any human-readable identifier. Not validated against any user registry.
-   */
-  heldBy: z.string().trim().max(200).optional()
-})
-
-// ---------------------------------------------------------------------------
-// Roles domain schema — a collection of roles.
-// ---------------------------------------------------------------------------
-
-export const RolesDomainSchema = z.object({
-  roles: z.array(RoleSchema).default([])
-})
-
-// ---------------------------------------------------------------------------
-// Seed — empty by default; adapters populate with real role definitions.
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_ORGANIZATION_MODEL_ROLES: z.infer<typeof RolesDomainSchema> = {
-  roles: []
-}
+import { z } from 'zod'
+import { ResourceIdSchema } from './resources'
+import { ModelIdSchema } from './shared'
+import { SystemIdSchema } from './systems'
+
+// ---------------------------------------------------------------------------
+// Role schema - one entry per distinct role in the organization's chart.
+// Inspired by the EOS Accountability Chart but uses plain-language field names
+// throughout. No EOS jargon: "title" (not seatTitle), "responsibilities"
+// (not accountabilities), "reportsToId", "heldBy".
+//
+// Cross-reference enforcement lives in `OrganizationModelSchema.superRefine()`:
+// `reportsToId` must resolve to another Role, `responsibleFor` entries must
+// resolve to Systems, and agent holders must resolve to Agent Resources.
+// Cycle detection is NOT enforced (known limitation; document if needed).
+// ---------------------------------------------------------------------------
+
+export const RoleIdSchema = ModelIdSchema
+
+export const HumanRoleHolderSchema = z.object({
+  kind: z.literal('human'),
+  userId: z.string().trim().min(1).max(200)
+})
+
+export const AgentRoleHolderSchema = z.object({
+  kind: z.literal('agent'),
+  agentId: ResourceIdSchema
+})
+
+export const TeamRoleHolderSchema = z.object({
+  kind: z.literal('team'),
+  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
+})
+
+export const RoleHolderSchema = z.discriminatedUnion('kind', [
+  HumanRoleHolderSchema,
+  AgentRoleHolderSchema,
+  TeamRoleHolderSchema
+])
+
+export const RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)])
+
+export const RoleSchema = z.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: RoleIdSchema,
+  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
+  title: z.string().trim().min(1).max(200),
+  /**
+   * List of responsibilities this role owns - plain-language descriptions of
+   * what the person in this role is accountable for delivering.
+   * Defaults to empty array so minimal role definitions stay concise.
+   */
+  responsibilities: z.array(z.string().trim().max(500)).default([]),
+  /**
+   * Optional: ID of another role this role reports to.
+   * When present, must reference another `roles[].id` in the same organization.
+   */
+  reportsToId: RoleIdSchema.optional(),
+  /**
+   * Optional: human, agent, or team holder currently filling this role.
+   * Agent holders reference OM Resource IDs and are validated at the model level.
+   */
+  heldBy: RoleHoldersSchema.optional(),
+  /**
+   * Optional Systems this role is accountable for.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  responsibleFor: z.array(SystemIdSchema).optional()
+})
+
+// ---------------------------------------------------------------------------
+// Roles domain schema - a collection of roles.
+// ---------------------------------------------------------------------------
+
+export const RolesDomainSchema = z.object({
+  roles: z.array(RoleSchema).default([])
+})
+
+// ---------------------------------------------------------------------------
+// Seed - empty by default; adapters populate with real role definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_ROLES: z.infer<typeof RolesDomainSchema> = {
+  roles: []
+}
+
+export type RoleId = z.infer<typeof RoleIdSchema>
+export type HumanRoleHolder = z.infer<typeof HumanRoleHolderSchema>
+export type AgentRoleHolder = z.infer<typeof AgentRoleHolderSchema>
+export type TeamRoleHolder = z.infer<typeof TeamRoleHolderSchema>
+export type RoleHolder = z.infer<typeof RoleHolderSchema>
+export type Role = z.infer<typeof RoleSchema>
+export type RolesDomain = z.infer<typeof RolesDomainSchema>

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

@@ -0,0 +1,46 @@
+import { z } from 'zod'
+import { DescriptionSchema, LabelSchema, ModelIdSchema, ReferenceIdsSchema } from './shared'
+
+// ---------------------------------------------------------------------------
+// Systems domain
+// ---------------------------------------------------------------------------
+//
+// A System is a tenant-defined bounded context that groups operational
+// resources and carries governance metadata. The shared schema validates the
+// shape and references; each tenant supplies its own catalog.
+
+export const SystemKindSchema = z.enum(['product', 'operational', 'platform', 'diagnostic'])
+export const SystemStatusSchema = z.enum(['active', 'deprecated', 'archived'])
+export const SystemIdSchema = ModelIdSchema
+
+export const SystemEntrySchema = z.object({
+  /** Stable tenant-defined system id (e.g. "sys.lead-gen"). */
+  id: SystemIdSchema,
+  /** Human-readable system title shown in governance and operations UI. */
+  title: LabelSchema,
+  /** One-paragraph purpose statement for the bounded context. */
+  description: DescriptionSchema,
+  /** Closed system shape enum; catalog values remain tenant-defined. */
+  kind: SystemKindSchema,
+  /** Optional role responsible for this system. */
+  responsibleRoleId: ModelIdSchema.optional(),
+  /** Optional knowledge nodes that govern this system. */
+  governedByKnowledge: ReferenceIdsSchema,
+  /** Optional goals this system contributes to. */
+  drivesGoals: ReferenceIdsSchema,
+  status: SystemStatusSchema
+})
+
+export const SystemsDomainSchema = z.object({
+  systems: z.array(SystemEntrySchema).default([])
+})
+
+export const DEFAULT_ORGANIZATION_MODEL_SYSTEMS: z.infer<typeof SystemsDomainSchema> = {
+  systems: []
+}
+
+export type SystemId = z.infer<typeof SystemIdSchema>
+export type SystemKind = z.infer<typeof SystemKindSchema>
+export type SystemStatus = z.infer<typeof SystemStatusSchema>
+export type SystemEntry = z.infer<typeof SystemEntrySchema>
+export type SystemsDomain = z.infer<typeof SystemsDomainSchema>

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

@@ -16,3 +16,5 @@ export * from './domains/sales'
 export * from './domains/projects'
 export * from './domains/features'
 export * from './domains/prospecting'
+export * from './domains/systems'
+export * from './domains/resources'