@elevasis/core 0.5.0 → 0.7.0

package/src/_gen/__tests__/scaffold-contracts.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Snapshot test for the scaffold-contracts generator wrapper.
+ *
+ * Calls generate() (which runs the real script) and asserts:
+ * 1. The output file exists and has content.
+ * 2. The content matches the stored snapshot (drift detection).
+ *
+ * If the snapshot is missing it is created on first run. Subsequent runs fail
+ * if the output changes without an intentional snapshot update.
+ */
+
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { describe, it, expect } from 'vitest'
+
+/** Monorepo root relative to packages/core/src/_gen/__tests__/ */
+const ROOT = resolve(import.meta.dirname, '..', '..', '..', '..', '..')
+
+const OUTPUT_PATH = resolve(ROOT, 'packages/core/src/reference/_generated/contracts.md')
+
+describe('scaffold-contracts generator', () => {
+  it('output file exists and has content', () => {
+    // The generator must have been run (either manually or by CI gen step).
+    // This test validates the committed artifact — it does NOT re-run the generator
+    // so the test suite stays fast and deterministic.
+    let content: string
+    try {
+      content = readFileSync(OUTPUT_PATH, 'utf8')
+    } catch {
+      throw new Error(
+        `Generated file not found: ${OUTPUT_PATH}\n` +
+          `Run "pnpm scaffold:generate" or "node scripts/monorepo/generate-scaffold-contracts.js" first.`
+      )
+    }
+
+    expect(content.length).toBeGreaterThan(0)
+  })
+
+  it('output file matches stored snapshot', async () => {
+    let content: string
+    try {
+      content = readFileSync(OUTPUT_PATH, 'utf8')
+    } catch {
+      throw new Error(
+        `Generated file not found: ${OUTPUT_PATH}\n` +
+          `Run "pnpm scaffold:generate" first to produce the artifact before snapshotting.`
+      )
+    }
+
+    // Snapshot stored alongside test file in __snapshots__/
+    await expect(content).toMatchFileSnapshot(resolve(import.meta.dirname, '__snapshots__', 'contracts.md.snap'))
+  })
+})

package/src/_gen/scaffold-contracts.ts

@@ -0,0 +1,45 @@
+/**
+ * Thin _gen/ wrapper for the scaffold-contracts generator.
+ *
+ * The actual generation logic lives in scripts/monorepo/generate-scaffold-contracts.js.
+ * This wrapper provides the canonical generate() entry point so the generator
+ * participates in the @repo/gen-utils pattern (snapshot tests, drift detection,
+ * Turbo gen task).
+ *
+ * DO NOT move logic here — edit the script instead, then re-run generate().
+ */
+
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { resolve, dirname } from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/** Monorepo root — four levels up from packages/core/src/_gen/ */
+const ROOT = resolve(__dirname, '..', '..', '..', '..')
+
+/**
+ * Run the scaffold-contracts generator.
+ * Delegates to scripts/monorepo/generate-scaffold-contracts.js via child process
+ * so the existing script is the single source of implementation.
+ */
+export function generate(): void {
+  const result = spawnSync('node', ['scripts/monorepo/generate-scaffold-contracts.js'], {
+    stdio: 'inherit',
+    cwd: ROOT
+  })
+
+  if (result.error) {
+    throw new Error(`scaffold-contracts generator failed to spawn: ${result.error.message}`)
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`scaffold-contracts generator exited with status ${result.status}`)
+  }
+}
+
+// Allow direct invocation: node packages/core/src/_gen/scaffold-contracts.ts
+if (process.argv[1] && resolve(process.argv[1]) === __filename) {
+  generate()
+}

package/src/business/acquisition/types.ts

@@ -268,6 +268,8 @@ export interface DealContact {
 export interface DealFilters {
   stage?: DealStage
   search?: string
+  limit?: number
+  offset?: number
 }
 
 /** Deal list item with joined contact and company data */

package/src/commands/queue/types/task.ts

@@ -25,7 +25,7 @@ export interface Task extends OriginTracking {
   humanCheckpoint?: string
 
   // Status (updated to include 'completed')
-  status: TaskStatus
+  status: QueueTaskStatus
 
   /**
    * Target resource tracking — mirrors origin columns.
@@ -59,7 +59,7 @@ export interface Task extends OriginTracking {
  * - failed: execution failed, task can be retried
  * - expired: timed out before action
  */
-export type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired'
+export type QueueTaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired'
 
 /**
  * Parameters for creating a new HITL task
@@ -106,7 +106,7 @@ export interface PatchTaskParams {
  */
 export interface ListTasksFilters {
   organizationId: string
-  status?: TaskStatus
+  status?: QueueTaskStatus
   humanCheckpoint?: string
   timeRange?: TimeRange
   priorityMin?: number

package/src/execution/engine/index.ts

@@ -278,12 +278,20 @@ export {
   type AddContactsToListResult,
   type BulkImportParams,
   type BulkImportResult,
+  type BulkImportCompanyEntry,
+  type BulkImportCompaniesParams,
+  type BulkImportCompaniesResult,
   type DeactivateContactsByCompanyParams,
   type DeactivateContactsByCompanyResult,
   // Deal types (acq_deals table)
   type UpsertDealParams,
   type AcqDeal,
   type DealActivityEntry,
+  // Deal analytics types
+  type DealStageSummary,
+  type StaleDeal,
+  type DealPipelineAnalytics,
+  type DealAnalyticsParams,
   // Deal-sync param types
   type UpdateDiscoveryDataParams,
   type UpdateProposalDataParams,

package/src/execution/engine/tools/registry.ts

@@ -21,14 +21,9 @@ import type {
   MilestoneRow,
   TaskRow,
   NoteRow
-} from '../../../business/delivery'
-import type {
-  DealListItem,
-  DealDetail,
-  DealStage,
-  ListDealsQuery
-} from '../../../business/acquisition'
-import type { RecentActivityEntry } from '../../../business/crm/api-schemas'
+} from '../../../business/projects'
+import type { DealListItem, DealDetail, DealStage, ListDealsQuery } from '../../../business/acquisition'
+import type { RecentActivityEntry } from '../../../business/sales/api-schemas'
 import type { Database } from '../../../supabase/database.types'
 
 /**
@@ -148,12 +143,24 @@ export interface ICrmService {
   getDeal(dealId: string, organizationId: string): Promise<DealDetail | null>
   getDealByEmail(email: string, organizationId: string): Promise<DealDetail | null>
   updateDealStage(dealId: string, organizationId: string, stage: DealStage): Promise<void>
-  createDealNote(params: import('./lead-service-types').CreateDealNoteParams): Promise<import('./lead-service-types').AcqDealNote>
-  listDealNotes(params: import('./lead-service-types').ListDealNotesParams): Promise<import('./lead-service-types').AcqDealNote[]>
-  createDealTask(params: import('./lead-service-types').CreateDealTaskParams): Promise<import('./lead-service-types').AcqDealTask>
-  listDealTasks(params: import('./lead-service-types').ListDealTasksParams): Promise<import('./lead-service-types').AcqDealTask[]>
-  listDealTasksDue(params: import('./lead-service-types').ListDealTasksDueParams): Promise<import('./lead-service-types').AcqDealTask[]>
-  completeDealTask(params: import('./lead-service-types').CompleteDealTaskParams): Promise<import('./lead-service-types').AcqDealTask>
+  createDealNote(
+    params: import('./lead-service-types').CreateDealNoteParams
+  ): Promise<import('./lead-service-types').AcqDealNote>
+  listDealNotes(
+    params: import('./lead-service-types').ListDealNotesParams
+  ): Promise<import('./lead-service-types').AcqDealNote[]>
+  createDealTask(
+    params: import('./lead-service-types').CreateDealTaskParams
+  ): Promise<import('./lead-service-types').AcqDealTask>
+  listDealTasks(
+    params: import('./lead-service-types').ListDealTasksParams
+  ): Promise<import('./lead-service-types').AcqDealTask[]>
+  listDealTasksDue(
+    params: import('./lead-service-types').ListDealTasksDueParams
+  ): Promise<import('./lead-service-types').AcqDealTask[]>
+  completeDealTask(
+    params: import('./lead-service-types').CompleteDealTaskParams
+  ): Promise<import('./lead-service-types').AcqDealTask>
   recordActivity(params: import('./lead-service-types').RecordDealActivityParams): Promise<void>
   deleteDeal(params: import('./lead-service-types').DeleteDealParams): Promise<void>
 }
@@ -208,11 +215,7 @@ export interface IProjectsService {
   ): Promise<TaskRow[]>
   getTask(id: string, organizationId: string): Promise<TaskRow | null>
   createTask(input: Omit<TaskInsert, 'organization_id'> & { organizationId: string }): Promise<TaskRow>
-  updateTask(
-    id: string,
-    organizationId: string,
-    input: Omit<TaskUpdate, 'organization_id'>
-  ): Promise<TaskRow | null>
+  updateTask(id: string, organizationId: string, input: Omit<TaskUpdate, 'organization_id'>): Promise<TaskRow | null>
   deleteTask(id: string, organizationId: string): Promise<boolean>
   mergeTaskResumeContext(
     id: string,
@@ -221,11 +224,7 @@ export interface IProjectsService {
   ): Promise<TaskResumeContextRow | null>
   listNotes(projectId: string, organizationId: string): Promise<NoteRow[]>
   createNote(input: Omit<NoteInsert, 'organization_id'> & { organizationId: string }): Promise<NoteRow>
-  updateNote(
-    id: string,
-    organizationId: string,
-    input: Omit<NoteUpdate, 'organization_id'>
-  ): Promise<NoteRow | null>
+  updateNote(id: string, organizationId: string, input: Omit<NoteUpdate, 'organization_id'>): Promise<NoteRow | null>
   deleteNote(id: string, organizationId: string): Promise<boolean>
 }
 
@@ -548,6 +547,9 @@ export {
   type AddContactsToListResult,
   type BulkImportParams,
   type BulkImportResult,
+  type BulkImportCompanyEntry,
+  type BulkImportCompaniesParams,
+  type BulkImportCompaniesResult,
   type DeactivateContactsByCompanyParams,
   type DeactivateContactsByCompanyResult,
   type ILeadService,

package/src/execution/engine/tools/tool-maps.ts

@@ -261,8 +261,8 @@ import type {
 } from './lead-service-types'
 
 import type { DealListItem, DealDetail } from '../../../business/acquisition'
-import { CrmSchemas } from '../../../business/crm/api-schemas'
-import type { RecentActivityEntry } from '../../../business/crm/api-schemas'
+import { CrmSchemas } from '../../../business/sales/api-schemas'
+import type { RecentActivityEntry } from '../../../business/sales/api-schemas'
 import { DealSchemas } from '../../../business/acquisition'
 import { ProjectSchemas } from '../../../projects/api-schemas'
 import type {
@@ -272,7 +272,7 @@ import type {
   NoteRow,
   ProjectWithCounts,
   ProjectDetail
-} from '../../../business/delivery'
+} from '../../../business/projects'
 import type { z } from 'zod'
 
 // ---------------------------------------------------------------------------
@@ -357,14 +357,14 @@ export type NotificationToolMap = {
 type ProjectsListParams = z.infer<typeof ProjectSchemas.GetProjectsQuery>
 type ProjectCreateParams = z.infer<typeof ProjectSchemas.CreateProjectRequest>
 type ProjectUpdateParams = z.infer<typeof ProjectSchemas.UpdateProjectRequest>
-type MilestoneCreateParams =
-  z.infer<typeof ProjectSchemas.ProjectIdPathParams> & z.infer<typeof ProjectSchemas.CreateMilestoneRequest>
+type MilestoneCreateParams = z.infer<typeof ProjectSchemas.ProjectIdPathParams> &
+  z.infer<typeof ProjectSchemas.CreateMilestoneRequest>
 type MilestoneUpdateParams = z.infer<typeof ProjectSchemas.UpdateMilestoneRequest>
 type TaskListParams = z.infer<typeof ProjectSchemas.ProjectIdPathParams> & z.infer<typeof ProjectSchemas.GetTasksQuery>
 type TaskCreateParams = z.infer<typeof ProjectSchemas.CreateTaskRequest>
 type TaskUpdateParams = z.infer<typeof ProjectSchemas.UpdateTaskRequest>
-type TaskResumeContextParams =
-  z.infer<typeof ProjectSchemas.TaskIdParams> & z.infer<typeof ProjectSchemas.MergeResumeContextRequest>
+type TaskResumeContextParams = z.infer<typeof ProjectSchemas.TaskIdParams> &
+  z.infer<typeof ProjectSchemas.MergeResumeContextRequest>
 type NoteListParams = z.infer<typeof ProjectSchemas.ProjectIdPathParams>
 type NoteCreateParams = z.infer<typeof ProjectSchemas.CreateNoteRequest>
 type NoteUpdateParams = z.infer<typeof ProjectSchemas.UpdateNoteRequest>
@@ -378,7 +378,10 @@ export type ProjectsToolMap = {
   deleteProject: { params: z.infer<typeof ProjectSchemas.ProjectIdParams>; result: void }
   listMilestones: { params: z.infer<typeof ProjectSchemas.ProjectIdPathParams>; result: MilestoneRow[] }
   createMilestone: { params: MilestoneCreateParams; result: MilestoneRow }
-  updateMilestone: { params: z.infer<typeof ProjectSchemas.MilestoneIdParams> & MilestoneUpdateParams; result: MilestoneRow }
+  updateMilestone: {
+    params: z.infer<typeof ProjectSchemas.MilestoneIdParams> & MilestoneUpdateParams
+    result: MilestoneRow
+  }
   deleteMilestone: { params: z.infer<typeof ProjectSchemas.MilestoneIdParams>; result: void }
   listTasks: { params: TaskListParams; result: TaskRow[] }
   getTask: { params: z.infer<typeof ProjectSchemas.TaskIdParams>; result: TaskRow }
@@ -399,7 +402,8 @@ export type ProjectsToolMap = {
 type CrmRecentActivityParams = Partial<z.infer<typeof CrmSchemas.GetRecentActivityQuery>>
 type CrmListDealsParams = Partial<z.infer<typeof DealSchemas.ListDealsQuery>>
 type CrmGetDealParams = z.infer<typeof DealSchemas.DealIdParams>
-type CrmUpdateDealStageParams = z.infer<typeof DealSchemas.DealIdParams> & z.infer<typeof DealSchemas.SyncDealStageRequest>
+type CrmUpdateDealStageParams = z.infer<typeof DealSchemas.DealIdParams> &
+  z.infer<typeof DealSchemas.SyncDealStageRequest>
 type CrmGetDealByEmailParams = { email: string }
 type CrmTaskDueParams = Partial<z.infer<typeof DealSchemas.ListDealTasksDueQuery>>
 type CrmDealTaskParams = Omit<CreateDealTaskParams, 'organizationId'>

package/src/execution/engine/workflow/types.ts

@@ -28,10 +28,9 @@ export type StepHandler = (input: unknown, context: ExecutionContext) => Promise
 // Step type for flow control
 export const StepType = {
   LINEAR: 'linear',
-  CONDITIONAL: 'conditional',
+  CONDITIONAL: 'conditional'
 } as const
-// eslint-disable-next-line no-redeclare -- intentional const+type pattern (enum-like)
-export type StepType = typeof StepType[keyof typeof StepType]
+export type StepType = (typeof StepType)[keyof typeof StepType]
 
 // Next step configuration types
 export interface LinearNext {

package/src/index.ts

@@ -52,3 +52,13 @@ export * from './integrations/oauth/index'
 
 // Credential types and utilities
 export * from './integrations/credentials/index'
+
+// Scaffold registry — browser-safe schema types and Zod schemas only.
+// For server-side loader functions, use: import { ... } from '@repo/core/scaffold-registry'
+export { ScaffoldRegistrySchema, ScaffoldEntryKindSchema } from './scaffold-registry/schema'
+export type {
+  ScaffoldRegistry,
+  ScaffoldRegistryEntry,
+  ScaffoldRef,
+  ScaffoldEntryKind
+} from './scaffold-registry/schema'

package/src/organization-model/README.md

@@ -14,7 +14,7 @@ The public entry point exposes:
 - `resolveOrganizationModel`
 - `PROJECTS_FEATURE_ID`
 - `PROJECTS_INDEX_SURFACE_ID`
-- `DELIVERY_PROJECTS_VIEW_CAPABILITY_ID`
+- `PROJECTS_VIEW_CAPABILITY_ID`
 - `OrganizationModel` and the supporting domain types
 
 Import it from the published subpath:
@@ -22,7 +22,7 @@ Import it from the published subpath:
 ```ts
 import {
   DEFAULT_ORGANIZATION_MODEL,
-  DELIVERY_PROJECTS_VIEW_CAPABILITY_ID,
+  PROJECTS_VIEW_CAPABILITY_ID,
   defineOrganizationModel,
   PROJECTS_FEATURE_ID,
   PROJECTS_INDEX_SURFACE_ID,
@@ -41,30 +41,34 @@ Top-level fields:
 - `branding` - organization branding defaults and overrides.
 - `features` - unified feature entries that combine enablement, labels, and semantic references.
 - `navigation` - navigation model for the product shell.
-- `crm` - CRM-specific contract data.
-- `leadGen` - lead generation contract data.
-- `delivery` - delivery and project contract data.
-- `resourceMappings` - cross-surface resource mappings.
+- `sales` - sales pipeline and relationship management.
+- `prospecting` - lists, companies, and contacts.
+- `projects` - projects, milestones, and tasks.
+- `identity`, `customers`, `offerings`, `roles`, `goals` - reality domains (2026-04 expansion).
+- `statuses` - unified status registry across delivery / hitl / execution / request / schedule.
+- `operations` - catalog of stateful runtime entities (HITL queue, sessions, executions, notifications, schedules).
+- `resourceMappings` - cross-surface resource mappings (includes techStack subsection).
 
 ## Default Feature Set
 
-The default model includes seven feature IDs:
+The default model includes eight feature IDs:
 
-- `crm` - deal pipeline and relationship management.
-- `lead-gen` - lists, companies, and contacts.
+- `sales` - deal pipeline and relationship management.
+- `prospecting` - lists, companies, and contacts.
 - `projects` - projects, milestones, and tasks.
 - `operations` - organization graph and command-view surfaces.
 - `monitoring` - monitoring surfaces.
 - `settings` - organization settings.
 - `seo` - SEO surfaces (disabled by default).
+- `configure` - `/configure` skill entry point (external projects).
 
 ## Project Bridge Constants
 
-The organization-model surface now exports a narrow set of canonical IDs for the shared Projects bridge:
+The organization-model surface exports a narrow set of canonical IDs for the shared Projects bridge:
 
 - `PROJECTS_FEATURE_ID` -> `projects`
 - `PROJECTS_INDEX_SURFACE_ID` -> `projects.index`
-- `DELIVERY_PROJECTS_VIEW_CAPABILITY_ID` -> `delivery.projects.view`
+- `PROJECTS_VIEW_CAPABILITY_ID` -> `delivery.projects.view`
 
 Use these when wiring shared UI manifests, template adapters, or other consumers that need to agree on the same Projects contract without repeating raw literals.
 
@@ -89,5 +93,5 @@ Use these when wiring shared UI manifests, template adapters, or other consumers
 
 - Use `resolveOrganizationModel()` when you need a runtime-safe model for rendering or policy checks.
 - Use `defineOrganizationModel()` when authoring a static partial model in source.
-- Treat feature IDs such as `crm`, `lead-gen`, and `projects` as the canonical shell-level contract in new organization-model authoring.
+- Treat feature IDs such as `sales`, `prospecting`, and `projects` as the canonical shell-level contract in new organization-model authoring.
 - Keep feature IDs, surface IDs, and capability IDs stable because downstream UI and policy code depend on them.

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

@@ -0,0 +1,175 @@
+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 { 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
+  }
+] 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)
+    })
+  })
+
+  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)
+    })
+  })
+})