@elevasis/core 0.39.0 → 0.41.0

package/src/organization-model/__tests__/snapshot-hash.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest'
+import { canonicalStringifyOrganizationModel } from '../snapshot-hash'
+import type { OrganizationModel } from '../types'
+import { resolveOrganizationModel } from '../resolve'
+
+// Minimal valid resolved model for hash-stability tests.
+function makeModel(overrides: Partial<OrganizationModel> = {}): OrganizationModel {
+  return resolveOrganizationModel(overrides)
+}
+
+describe('canonicalStringifyOrganizationModel', () => {
+  it('produces the same string regardless of key insertion order', () => {
+    // Two equivalent objects with different key ordering in domainMetadata.
+    const model = makeModel()
+
+    // Produce two copies with the same semantic content but different metadata key order.
+    const a: OrganizationModel = { ...model }
+    const b: OrganizationModel = {
+      ...model,
+      // Re-assign domainMetadata entries in a different key order.
+      domainMetadata: Object.fromEntries(
+        Object.entries(model.domainMetadata).reverse()
+      ) as OrganizationModel['domainMetadata']
+    }
+
+    expect(canonicalStringifyOrganizationModel(a)).toBe(canonicalStringifyOrganizationModel(b))
+  })
+
+  it('excludes the snapshotHash field from the serialized output', () => {
+    const base = makeModel()
+    const withHash: OrganizationModel = { ...base, snapshotHash: 'abc123' }
+    const withOtherHash: OrganizationModel = { ...base, snapshotHash: 'xyz789' }
+    const withoutHash: OrganizationModel = { ...base, snapshotHash: undefined }
+
+    // All three produce the same canonical string — snapshotHash is excluded.
+    expect(canonicalStringifyOrganizationModel(withHash)).toBe(canonicalStringifyOrganizationModel(withoutHash))
+    expect(canonicalStringifyOrganizationModel(withHash)).toBe(canonicalStringifyOrganizationModel(withOtherHash))
+  })
+
+  it('excludes domainMetadata lastModified from the serialized output', () => {
+    const base = makeModel()
+
+    // Two models differing only in lastModified.
+    const earlyDate: OrganizationModel = {
+      ...base,
+      domainMetadata: {
+        ...base.domainMetadata,
+        branding: { version: 1, lastModified: '2026-01-01' }
+      }
+    }
+    const lateDate: OrganizationModel = {
+      ...base,
+      domainMetadata: {
+        ...base.domainMetadata,
+        branding: { version: 1, lastModified: '2026-12-31' }
+      }
+    }
+
+    expect(canonicalStringifyOrganizationModel(earlyDate)).toBe(canonicalStringifyOrganizationModel(lateDate))
+  })
+
+  it('produces different strings for different semantic content', () => {
+    const modelA = makeModel({ version: 1 })
+    const modelB = makeModel({
+      version: 1,
+      branding: { organizationName: 'AlphaOrg', productName: 'AlphaPlatform', shortName: 'Alpha' }
+    })
+
+    // Different semantic content → different canonical strings.
+    expect(canonicalStringifyOrganizationModel(modelA)).not.toBe(canonicalStringifyOrganizationModel(modelB))
+  })
+
+  it('is deterministic across multiple calls with the same input', () => {
+    const model = makeModel()
+    const first = canonicalStringifyOrganizationModel(model)
+    const second = canonicalStringifyOrganizationModel(model)
+    const third = canonicalStringifyOrganizationModel(model)
+
+    expect(first).toBe(second)
+    expect(first).toBe(third)
+  })
+})

package/src/organization-model/cross-ref.ts

@@ -55,6 +55,7 @@ export interface OmCrossRefIndex {
    */
   systemsById: Map<string, unknown>
   resourceIds: Set<string>
+  clientIds: Set<string>
   knowledgeIds: Set<string>
   roleIds: Set<string>
   goalIds: Set<string>
@@ -82,6 +83,7 @@ export function buildOmCrossRefIndex(model: OrganizationModel): OmCrossRefIndex
   }
 
   const resourceIds = new Set(Object.keys(model.resources ?? {}))
+  const clientIds = new Set(Object.keys(model.clients ?? {}))
   const knowledgeIds = new Set(Object.keys(model.knowledge ?? {}))
   const roleIds = new Set(Object.keys(model.roles ?? {}))
   const goalIds = new Set(Object.keys(model.goals ?? {}))
@@ -121,6 +123,7 @@ export function buildOmCrossRefIndex(model: OrganizationModel): OmCrossRefIndex
   return {
     systemsById,
     resourceIds,
+    clientIds,
     knowledgeIds,
     roleIds,
     goalIds,
@@ -147,6 +150,7 @@ export function buildOmCrossRefIndex(model: OrganizationModel): OmCrossRefIndex
  */
 export function knowledgeTargetExists(index: OmCrossRefIndex, kind: string, id: string): boolean {
   if (kind === 'system') return index.systemsById.has(id)
+  if (kind === 'client') return index.clientIds.has(id)
   if (kind === 'resource') return index.resourceIds.has(id)
   if (kind === 'knowledge') return index.knowledgeIds.has(id)
   if (kind === 'stage') return index.stageIds.has(id)

package/src/organization-model/defaults.ts

@@ -23,7 +23,7 @@ import { DEFAULT_ORGANIZATION_MODEL_GOALS } from './domains/goals'
 import { DEFAULT_ORGANIZATION_MODEL_RESOURCES } from './domains/resources'
 import { DEFAULT_ORGANIZATION_MODEL_TOPOLOGY } from './domains/topology'
 import { DEFAULT_ORGANIZATION_MODEL_POLICIES } from './domains/policies'
-import { DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA } from './schema'
+import { DEFAULT_ORGANIZATION_MODEL_CLIENTS, DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA } from './schema'
 import { DEFAULT_ONTOLOGY_SCOPE } from './ontology'
 import type { OrganizationModelNavigation } from './types'
 
@@ -32,7 +32,6 @@ import type { OrganizationModelNavigation } from './types'
 export const DEFAULT_ORGANIZATION_MODEL_KNOWLEDGE = {} as const
 
 export const DEFAULT_ORGANIZATION_MODEL_ENTITIES = {}
-
 const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: OrganizationModelNavigation = {
   sidebar: {
     primary: {},
@@ -47,6 +46,7 @@ export const DEFAULT_ORGANIZATION_MODEL: OrganizationModel = {
   branding: DEFAULT_ORGANIZATION_MODEL_BRANDING,
   navigation: DEFAULT_ORGANIZATION_MODEL_NAVIGATION,
   identity: DEFAULT_ORGANIZATION_MODEL_IDENTITY,
+  clients: DEFAULT_ORGANIZATION_MODEL_CLIENTS,
   customers: DEFAULT_ORGANIZATION_MODEL_CUSTOMERS,
   offerings: DEFAULT_ORGANIZATION_MODEL_OFFERINGS,
   roles: DEFAULT_ORGANIZATION_MODEL_ROLES,

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

@@ -14,6 +14,7 @@ import { defineDomainRecord } from '../helpers'
 export const KnowledgeTargetKindSchema = z
   .enum([
     'system',
+    'client',
     'resource',
     'knowledge',
     'stage',

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

@@ -281,16 +281,33 @@ export function buildOrganizationGraph(input: BuildOrganizationGraphInput): Orga
     label: 'Organization Model'
   }
   pushUniqueNode(nodes, nodeIds, organizationNode)
-  const systemsWithPaths = listAllSystems(organizationModel)
-  const systemPathByRef = new Map<string, string>()
+  const systemsWithPaths = listAllSystems(organizationModel)
+  const systemPathByRef = new Map<string, string>()
   for (const { path, system } of systemsWithPaths) {
     systemPathByRef.set(path, path)
     systemPathByRef.set(system.id, path)
   }
-  const validSystemRefs = new Set(systemPathByRef.keys())
-  const systemNodeId = (systemRef: string) => nodeId('system', systemPathByRef.get(systemRef) ?? systemRef)
-
-  function topologyNodeId(ref: OmTopologyNodeRef): string {
+  const validSystemRefs = new Set(systemPathByRef.keys())
+  const systemNodeId = (systemRef: string) => nodeId('system', systemPathByRef.get(systemRef) ?? systemRef)
+
+  for (const client of Object.values(organizationModel.clients).sort((a, b) => a.slug.localeCompare(b.slug))) {
+    const id = nodeId('client', client.id)
+    pushUniqueNode(nodes, nodeIds, {
+      id,
+      kind: 'client',
+      label: client.name,
+      sourceId: client.id,
+      description: client.identity.clientBrief || undefined
+    })
+    pushUniqueEdge(edges, edgeIds, {
+      id: edgeId('contains', organizationNode.id, id),
+      kind: 'contains',
+      sourceId: organizationNode.id,
+      targetId: id
+    })
+  }
+
+  function topologyNodeId(ref: OmTopologyNodeRef): string {
     if (ref.kind === 'system') return systemNodeId(ref.id)
     if (ref.kind === 'resource') return nodeId('resource', ref.id)
     if (ref.kind === 'ontology') return ontologyGraphNodeId(ref.id)

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

@@ -3,9 +3,10 @@ import { DescriptionSchema, IconNameSchema, LabelSchema } from '../domains/share
 import { OrganizationModelSchema } from '../schema'
 
 export const OrganizationGraphNodeKindSchema = z.enum([
-  'organization',
-  'system',
-  'role',
+  'organization',
+  'system',
+  'client',
+  'role',
   'action',
   'entity',
   'event',

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

@@ -4,9 +4,10 @@ import type { RelationshipType } from '../../platform/registry/command-view'
 import type { OrganizationModelIconToken } from '../icons'
 
 export type OrganizationGraphNodeKind =
-  | 'organization'
-  | 'system'
-  | 'role'
+  | 'organization'
+  | 'system'
+  | 'client'
+  | 'role'
   | 'action'
   | 'entity'
   | 'event'

package/src/organization-model/helpers.ts

@@ -62,6 +62,21 @@ export function listDomain<T extends { id: string; order: number }>(record: Reco
   return Object.values(record).sort((a, b) => a.order - b.order)
 }
 
+export function listClientProfiles(model: OrganizationModel): OrganizationModel['clients'][string][] {
+  return Object.values(model.clients ?? {}).sort((a, b) => a.slug.localeCompare(b.slug))
+}
+
+export function getClientProfile(model: OrganizationModel, id: string): OrganizationModel['clients'][string] | undefined {
+  return model.clients?.[id]
+}
+
+export function getClientProfileBySlug(
+  model: OrganizationModel,
+  slug: string
+): OrganizationModel['clients'][string] | undefined {
+  return Object.values(model.clients ?? {}).find((client) => client.slug === slug)
+}
+
 export function findById(
   systems: Record<string, OrganizationModelSystemEntry>,
   id: string

package/src/organization-model/index.ts

@@ -1,5 +1,6 @@
 export * from './cross-ref'
 export * from './schema'
+export * from './snapshot-hash'
 export * from './types'
 export * from './ontology'
 export * from './contracts'

package/src/organization-model/published.ts

@@ -24,6 +24,15 @@ export {
 } from './ontology'
 export {
   DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA,
+  ClientProfileBrandingSchema,
+  ClientProfileIdentitySchema,
+  ClientProfileLinksSchema,
+  ClientProfilePromptsSchema,
+  ClientProfileSchema,
+  ClientProfileSourceSchema,
+  ClientProfileStatusSchema,
+  ClientProfileWorkspaceSchema,
+  ClientProfilesDomainSchema,
   OrganizationModelDomainKeySchema,
   OrganizationModelDomainMetadataByDomainSchema,
   OrganizationModelDomainMetadataSchema,
@@ -237,7 +246,7 @@ export { defineOrganizationModel, resolveOrganizationModel, resolveOrganizationM
 export type { ResolvedSystemEntry, ResolvedOrganizationModel } from './resolve'
 export { createFoundationOrganizationModel } from './foundation'
 export { scaffoldOrganizationModel } from './scaffolders'
-export { defineDomainRecord, listAllSystems } from './helpers'
+export { defineDomainRecord, getClientProfile, getClientProfileBySlug, listAllSystems, listClientProfiles } from './helpers'
 export { projectOrganizationSurfaces, validateOrganizationSurfaceProjection } from './surface-projection'
 export type {
   BaseOmScaffoldSpec,
@@ -283,11 +292,20 @@ export type {
 
 export type {
   DeepPartial,
+  ClientProfile,
+  ClientProfileBranding,
+  ClientProfileIdentity,
+  ClientProfileLinks,
+  ClientProfilePrompts,
+  ClientProfileSource,
+  ClientProfileStatus,
+  ClientProfileWorkspace,
   KnowledgeLink,
   KnowledgeTargetKind,
   KnowledgeTargetRef,
   OrganizationModel,
   OrganizationModelBranding,
+  OrganizationModelClients,
   OrganizationModelCustomerFirmographics,
   OrganizationModelCustomers,
   OrganizationModelCustomerSegment,

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

@@ -31,10 +31,10 @@ function asRoleHolderArray(heldBy: NonNullable<OrganizationModel['roles'][string
 function isKnowledgeKindCompatibleWithTarget(knowledgeKind: string, targetKind: string): boolean {
   if (knowledgeKind === 'reference') return true
   if (knowledgeKind === 'playbook') {
-    return ['system', 'resource', 'stage', 'action', 'ontology'].includes(targetKind)
+    return ['system', 'client', 'resource', 'stage', 'action', 'ontology'].includes(targetKind)
   }
   if (knowledgeKind === 'strategy') {
-    return ['system', 'goal', 'offering', 'customer-segment', 'ontology'].includes(targetKind)
+    return ['system', 'client', 'goal', 'offering', 'customer-segment', 'ontology'].includes(targetKind)
   }
   return false
 }

package/src/organization-model/schema.ts

@@ -15,12 +15,106 @@ import { EntitiesDomainSchema } from './domains/entities'
 import { PoliciesDomainSchema, DEFAULT_ORGANIZATION_MODEL_POLICIES } from './domains/policies'
 import { DEFAULT_ONTOLOGY_SCOPE, OntologyScopeSchema } from './ontology'
 import { refineOrganizationModel } from './schema-refinements'
+import { JsonValueSchema } from './domains/systems'
+import { LabelSchema, ModelIdSchema } from './domains/shared'
+
+export const ClientProfileIdSchema = z.string().uuid()
+export const ClientProfileStatusSchema = z.enum(['active', 'onboarding', 'paused', 'completed', 'churned'])
+export const ClientProfileSourceSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(64)
+  .regex(/^[a-z][a-z0-9_]*$/, 'Source must use lowercase letters, numbers, and underscores')
+
+export const ClientProfileIdentitySchema = z
+  .object({
+    organizationName: LabelSchema.optional(),
+    shortName: z.string().trim().min(1).max(40).optional(),
+    clientBrief: z.string().trim().max(4000).default(''),
+    geographicFocus: z.array(z.string().trim().min(1).max(200)).default([]),
+    timeZone: z.string().trim().min(1).max(100).default('UTC')
+  })
+  .passthrough()
+  .default({
+    clientBrief: '',
+    geographicFocus: [],
+    timeZone: 'UTC'
+  })
+
+export const ClientProfileBrandingSchema = z
+  .object({
+    voice: z.string().trim().max(280).optional(),
+    tagline: z.string().trim().max(200).optional(),
+    values: z.array(z.string().trim().min(1).max(100)).default([])
+  })
+  .passthrough()
+  .default({
+    values: []
+  })
+
+export const ClientProfileWorkspaceSchema = z
+  .object({
+    kind: z.enum(['external-project', 'internal-project', 'none']).optional(),
+    owner: z.enum(['developer', 'client', 'platform']).optional(),
+    projectId: z.string().trim().min(1).max(200).optional(),
+    workspacePath: z.string().trim().min(1).max(500).optional()
+  })
+  .passthrough()
+  .default({})
+
+export const ClientProfileLinksSchema = z
+  .object({
+    projectIds: z.array(z.string().uuid()).default([]),
+    primaryCompanyId: z.string().uuid().optional(),
+    primaryContactId: z.string().uuid().optional(),
+    sourceDealId: z.string().uuid().optional()
+  })
+  .default({
+    projectIds: []
+  })
+
+export const ClientProfilePromptsSchema = z
+  .object({
+    defaultContext: z.string().trim().max(8000).default('')
+  })
+  .passthrough()
+  .default({
+    defaultContext: ''
+  })
+
+export const ClientProfileSchema = z
+  .object({
+    id: ClientProfileIdSchema,
+    slug: ModelIdSchema,
+    name: LabelSchema,
+    status: ClientProfileStatusSchema.default('onboarding'),
+    source: ClientProfileSourceSchema.optional(),
+    identity: ClientProfileIdentitySchema,
+    branding: ClientProfileBrandingSchema,
+    workspace: ClientProfileWorkspaceSchema,
+    links: ClientProfileLinksSchema,
+    prompts: ClientProfilePromptsSchema,
+    config: z.record(z.string().trim().min(1).max(200), JsonValueSchema).default({}),
+    customValues: z.record(z.string().trim().min(1).max(200), JsonValueSchema).default({})
+  })
+  .strict()
+
+export const ClientProfilesDomainSchema = z
+  .record(ClientProfileIdSchema, ClientProfileSchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each client profile id must match its map key'
+  })
+  .default({})
+
+export const DEFAULT_ORGANIZATION_MODEL_CLIENTS: z.infer<typeof ClientProfilesDomainSchema> = {}
 
 // Phase 4 cut: 'sales', 'prospecting', 'projects', 'statuses' removed.
 // domainMetadata.knowledge covers versioning for the knowledge flat-map (D7).
 export const OrganizationModelDomainKeySchema = z.enum([
   'branding',
   'identity',
+  'clients',
   'customers',
   'offerings',
   'roles',
@@ -46,6 +140,7 @@ export const DEFAULT_ORGANIZATION_MODEL_DOMAIN_METADATA: Record<
 > = {
   branding: { version: 1, lastModified: '2026-05-10' },
   identity: { version: 1, lastModified: '2026-05-10' },
+  clients: { version: 1, lastModified: '2026-05-30' },
   customers: { version: 1, lastModified: '2026-05-10' },
   offerings: { version: 1, lastModified: '2026-05-10' },
   roles: { version: 1, lastModified: '2026-05-10' },
@@ -64,6 +159,7 @@ export const OrganizationModelDomainMetadataByDomainSchema = z
   .object({
     branding: OrganizationModelDomainMetadataSchema,
     identity: OrganizationModelDomainMetadataSchema,
+    clients: OrganizationModelDomainMetadataSchema,
     customers: OrganizationModelDomainMetadataSchema,
     offerings: OrganizationModelDomainMetadataSchema,
     roles: OrganizationModelDomainMetadataSchema,
@@ -91,10 +187,23 @@ export const OrganizationModelDomainMetadataByDomainSchema = z
 //   Surfaces are derived from navigation.sidebar routeable leaves.
 const OrganizationModelSchemaBase = z.object({
   version: z.literal(1).default(1),
+  /**
+   * Deterministic SHA-256 hex hash of the full resolved model, excluding this
+   * field itself and volatile domainMetadata.lastModified values.
+   *
+   * Stamped at deploy time by the platform OM assembly and persisted alongside
+   * the snapshot in the DB. Compared at API boot to detect stale deployed
+   * snapshots (primary gate: deploy; secondary backstop: boot).
+   *
+   * Optional — absent on models that predate Step 2 versioning or that have
+   * not been stamped (e.g. tenant partial overrides before re-deploy).
+   */
+  snapshotHash: z.string().optional(),
   domainMetadata: OrganizationModelDomainMetadataByDomainSchema,
   branding: OrganizationModelBrandingSchema.default(DEFAULT_ORGANIZATION_MODEL_BRANDING),
   navigation: OrganizationModelNavigationSchema,
   identity: IdentityDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_IDENTITY),
+  clients: ClientProfilesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CLIENTS),
   customers: CustomersDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_CUSTOMERS),
   offerings: OfferingsDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_OFFERINGS),
   roles: RolesDomainSchema.default(DEFAULT_ORGANIZATION_MODEL_ROLES),

package/src/organization-model/server/snapshot-hash-server.ts

@@ -0,0 +1,23 @@
+/**
+ * Server-only: compute a deterministic SHA-256 hash for an OrganizationModel snapshot.
+ *
+ * Uses node:crypto — never import this file from browser-reachable code.
+ * For the browser-safe canonical serializer, use `canonicalStringifyOrganizationModel`
+ * from `@repo/core/organization-model`.
+ */
+
+import { createHash } from 'node:crypto'
+import type { OrganizationModel } from '../types'
+import { canonicalStringifyOrganizationModel } from '../snapshot-hash'
+
+/**
+ * Compute a deterministic SHA-256 hex hash for an OrganizationModel.
+ *
+ * Delegates serialization to `canonicalStringifyOrganizationModel` (key-sorted,
+ * excludes `snapshotHash` and `domainMetadata[*].lastModified`) then hashes with SHA-256.
+ *
+ * @returns 64-character lowercase hex string
+ */
+export function computeOrganizationModelSnapshotHash(model: OrganizationModel): string {
+  return createHash('sha256').update(canonicalStringifyOrganizationModel(model)).digest('hex')
+}

package/src/organization-model/snapshot-hash.ts

@@ -0,0 +1,62 @@
+/**
+ * Deterministic canonical serialization helper for OrganizationModel snapshot hashing.
+ *
+ * Provides a stable JSON stringify that produces identical output for equivalent objects
+ * regardless of key insertion order. Used by deploy-time and boot-time snapshot hash
+ * verification to detect stale deployed OM snapshots.
+ *
+ * Only the serialization is here (browser-safe). Callers that need a hash compute it
+ * themselves using their preferred crypto implementation (e.g. node:crypto sha256).
+ */
+
+import type { OrganizationModel } from './types'
+
+/**
+ * Recursively serialize a value to a deterministic JSON string with sorted keys.
+ * Arrays preserve order; objects sort keys lexicographically.
+ */
+function deterministicStringify(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(deterministicStringify).join(',')}]`
+  }
+
+  if (value !== null && typeof value === 'object') {
+    return `{${Object.entries(value as Record<string, unknown>)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, entry]) => `${JSON.stringify(key)}:${deterministicStringify(entry)}`)
+      .join(',')}}`
+  }
+
+  return JSON.stringify(value)
+}
+
+/**
+ * Produce a deterministic canonical string for an OrganizationModel suitable for hashing.
+ *
+ * Exclusions (volatile / self-referential fields that must not be part of the hash input):
+ *   - `snapshotHash`   — the field being populated from this hash; must not be circular
+ *   - `domainMetadata[*].lastModified` — wall-clock date string; changes on every edit
+ *     independent of semantic content, causing spurious hash mismatches
+ *
+ * Same model content → same canonical string, regardless of key insertion order.
+ */
+export function canonicalStringifyOrganizationModel(model: OrganizationModel): string {
+  // Shallow-clone to strip snapshotHash without mutating the caller's object.
+  const { snapshotHash: _snapshotHash, domainMetadata, ...rest } = model
+
+  // Strip lastModified from each domain metadata entry so volatile dates do not
+  // pollute the hash. The domain version numbers are still included.
+  const strippedDomainMetadata = domainMetadata
+    ? Object.fromEntries(
+        Object.entries(domainMetadata).map(([domain, meta]) => {
+          if (meta === null || typeof meta !== 'object') return [domain, meta]
+          const { lastModified: _lastModified, ...metaRest } = meta as Record<string, unknown>
+          return [domain, metaRest]
+        })
+      )
+    : undefined
+
+  const forHashing = strippedDomainMetadata !== undefined ? { ...rest, domainMetadata: strippedDomainMetadata } : rest
+
+  return deterministicStringify(forHashing)
+}

package/src/organization-model/types.ts

@@ -110,7 +110,16 @@ import {
   OrganizationModelDomainKeySchema,
   OrganizationModelDomainMetadataByDomainSchema,
   OrganizationModelDomainMetadataSchema,
-  OrganizationModelSchema
+  OrganizationModelSchema,
+  ClientProfileBrandingSchema,
+  ClientProfileIdentitySchema,
+  ClientProfileLinksSchema,
+  ClientProfilePromptsSchema,
+  ClientProfileSchema,
+  ClientProfileSourceSchema,
+  ClientProfileStatusSchema,
+  ClientProfileWorkspaceSchema,
+  ClientProfilesDomainSchema
 } from './schema'
 
 export type OrganizationModel = z.infer<typeof OrganizationModelSchema>
@@ -118,6 +127,15 @@ export type OrganizationModelDomainKey = z.infer<typeof OrganizationModelDomainK
 export type OrganizationModelDomainMetadata = z.infer<typeof OrganizationModelDomainMetadataSchema>
 export type OrganizationModelDomainMetadataByDomain = z.infer<typeof OrganizationModelDomainMetadataByDomainSchema>
 export type OrganizationModelBranding = z.infer<typeof OrganizationModelBrandingSchema>
+export type ClientProfile = z.infer<typeof ClientProfileSchema>
+export type ClientProfileBranding = z.infer<typeof ClientProfileBrandingSchema>
+export type ClientProfileIdentity = z.infer<typeof ClientProfileIdentitySchema>
+export type ClientProfileLinks = z.infer<typeof ClientProfileLinksSchema>
+export type ClientProfilePrompts = z.infer<typeof ClientProfilePromptsSchema>
+export type ClientProfileSource = z.infer<typeof ClientProfileSourceSchema>
+export type ClientProfileStatus = z.infer<typeof ClientProfileStatusSchema>
+export type ClientProfileWorkspace = z.infer<typeof ClientProfileWorkspaceSchema>
+export type OrganizationModelClients = z.infer<typeof ClientProfilesDomainSchema>
 // Phase 4: OrganizationModelSales, OrganizationModelProspecting, OrganizationModelProjects,
 // OrganizationModelNavigation removed — compound domain top-level fields deleted per D8/D1.
 // Retained as local aliases for content-kind payload shapes used in migration-helpers:

package/src/platform/constants/versions.ts

@@ -1,3 +1,3 @@
 export const VERSION = {
-  CURRENT: '1.12.14'
+  CURRENT: '1.12.17'
 }

package/src/reference/_generated/contracts.md

@@ -39,6 +39,60 @@ export type OrganizationModelDomainMetadataByDomain = z.infer<typeof Organizatio
 export type OrganizationModelBranding = z.infer<typeof OrganizationModelBrandingSchema>
 ```
 
+### `ClientProfile`
+
+```typescript
+export type ClientProfile = z.infer<typeof ClientProfileSchema>
+```
+
+### `ClientProfileBranding`
+
+```typescript
+export type ClientProfileBranding = z.infer<typeof ClientProfileBrandingSchema>
+```
+
+### `ClientProfileIdentity`
+
+```typescript
+export type ClientProfileIdentity = z.infer<typeof ClientProfileIdentitySchema>
+```
+
+### `ClientProfileLinks`
+
+```typescript
+export type ClientProfileLinks = z.infer<typeof ClientProfileLinksSchema>
+```
+
+### `ClientProfilePrompts`
+
+```typescript
+export type ClientProfilePrompts = z.infer<typeof ClientProfilePromptsSchema>
+```
+
+### `ClientProfileSource`
+
+```typescript
+export type ClientProfileSource = z.infer<typeof ClientProfileSourceSchema>
+```
+
+### `ClientProfileStatus`
+
+```typescript
+export type ClientProfileStatus = z.infer<typeof ClientProfileStatusSchema>
+```
+
+### `ClientProfileWorkspace`
+
+```typescript
+export type ClientProfileWorkspace = z.infer<typeof ClientProfileWorkspaceSchema>
+```
+
+### `OrganizationModelClients`
+
+```typescript
+export type OrganizationModelClients = z.infer<typeof ClientProfilesDomainSchema>
+```
+
 ### `SalesPipeline`
 
 ```typescript