@elevasis/core 0.22.0 → 0.23.0

package/src/reference/glossary.md

@@ -13,31 +13,31 @@ description: Terminology disambiguation for Organization OS concepts used in the
 
 **DeploymentSpec** -- runtime/deploy assembly for one organization: workflows, agents, triggers, integrations, relationships, external resources, and human checkpoints. It assembles executable behavior around Organization Model resource descriptors; it is not the source of resource identity.
 
-**Feature** -- either a platform capability, a shell `FeatureModule`, or an Organization Model feature node. In the current shell contract, Organization Model feature nodes drive sidebar hierarchy and access state.
+**Feature** -- legacy or UI-package wording for a platform capability area. In the current Organization Model, use **System** for semantic ownership and **navigation surface** for shell placement. Keep "feature" only when referring to existing UI package folders, exported manifest names, or legacy compatibility recipes.
 
-**FeatureGuard** -- route-level feature gate from `@elevasis/ui/features/auth`.
+**SystemGuard** -- route-level System gate from `@elevasis/ui/features/auth`.
 
-**FeatureModule** -- manifest contract a shell feature provides to `ElevasisFeaturesProvider`. Key fields are `key`, `featureId`, optional `capabilityIds`, optional `icon`, optional `sidebar`, and optional graph bridge metadata.
+**SystemModule** -- manifest contract a shell module provides to `ElevasisSystemsProvider`. Key fields are `key`, optional `systemId`, optional `routePrefixes`, optional `capabilityIds`, optional `icon`, optional `sidebar`, optional `sidebarWidth`, and optional graph bridge metadata.
 
-**featureId** -- the `FeatureModule` field that must match an `OrganizationModel.features[].id`.
+**systemId** -- the `SystemModule` field that points to an `OrganizationModel.systems` entry. Navigation-only app modules may omit it and use route prefixes/surface metadata instead.
 
 **Foundations** -- local adapter layer in external projects that exports `canonicalOrganizationModel`, `organizationModel`, and workflow I/O schemas.
 
-**Graph node ID** -- kind-prefixed cross-collection identifier such as `feature:sales.crm`, `integration:instantly`, or `resource:lead-import`.
+**Graph node ID** -- kind-prefixed cross-collection identifier such as `system:sales.crm`, `integration:instantly`, or `resource:lead-import`.
 
 **Manifest** -- a runtime declaration for a feature or resource collection.
 
-**MembershipFeatureConfig** -- per-member feature override config: `{ features?: Record<string, boolean> }`.
+**MembershipFeatureConfig** -- legacy per-member feature override config. Current System visibility is resolved through Organization Model lifecycle/access metadata and provider compatibility layers.
 
-**OrganizationModel** -- top-level semantic contract for an organization. Current primary fields include `features`, `branding`, `navigation`, `sales`, `prospecting`, `projects`, `identity`, `customers`, `offerings`, `roles`, `goals`, `systems`, `resources`, `statuses`, `operations`, and `knowledge`.
+**OrganizationModel** -- top-level semantic contract for an organization. Current primary fields include `version`, `domainMetadata`, `branding`, `navigation`, `sales`, `prospecting`, `projects`, `identity`, `customers`, `offerings`, `roles`, `goals`, `systems`, `resources`, `actions`, `entities`, `policies`, `statuses`, and `knowledge`.
 
-**OrganizationModelFeature** -- feature node in `OrganizationModel.features`. Fields include `id`, `label`, `description`, `enabled`, `path`, `icon`, `color`, `uiPosition`, `requiresAdmin`, and `devOnly`.
+**OrganizationModelSystemEntry** -- System node in `OrganizationModel.systems`. Fields include `id`, `label`, `description`, `parentSystemId`, `subsystems`, `lifecycle`, `ui`, `requiresAdmin`, `devOnly`, `responsibleRoleId`, `governedByKnowledge`, `drivesGoals`, `actions`, `content`, and `order`.
 
-**Provider / ElevasisFeaturesProvider** -- runtime that registers manifests, resolves feature access against the org model, and exposes shell helpers through `useElevasisFeatures()`.
+**Provider / ElevasisSystemsProvider** -- runtime that registers System modules, resolves System access against the org model, projects sidebar navigation, and exposes shell helpers through `useElevasisSystems()`.
 
-**Resource** -- governance-only descriptor in `OrganizationModel.resources.entries` for a workflow, agent, or integration. Runtime code derives `resourceId` and kind from the descriptor, then attaches executable behavior in operations.
+**Resource** -- governance-only descriptor in `OrganizationModel.resources` for a workflow, agent, integration, or script. Runtime code derives `resourceId` and kind from the descriptor, then attaches executable behavior in operations.
 
-**Resource descriptor** -- OM entry with canonical `id`, required `systemId`, governance `status`, and optional role ownership. Workflow descriptors may mirror `capabilityKey`; agent descriptors carry `agentKind`, `sessionCapable`, and optional `actsAsRoleId`; integration descriptors name a provider.
+**Resource descriptor** -- OM entry with canonical `id`, required `systemPath`, governance `status`, and optional role ownership. Workflow descriptors may mirror `actionKey`; agent descriptors carry `agentKind`, `sessionCapable`, and optional `actsAsRoleId`; integration descriptors name a provider.
 
 **System** -- tenant-defined bounded context in `OrganizationModel.systems.systems` that groups operational resources and carries governance metadata such as responsible role, governing knowledge, driven goals, kind, and status.
 
@@ -45,11 +45,11 @@ description: Terminology disambiguation for Organization OS concepts used in the
 
 **ResourceLink** -- graph binding on resource metadata: `{ nodeId, kind }`.
 
-**Settings asymmetry** -- settings is a feature node, but individual access is normally governed by admin checks rather than user-facing feature toggles.
+**Settings asymmetry** -- Settings is a navigation/app surface whose individual pages are normally governed by admin checks rather than user-facing System toggles.
 
-**Shell model** -- provider output used by sidebars and breadcrumbs. Includes `features`, `childrenOf`, `ancestorsOf`, `parentOf`, `topLevel`, `findByPath`, `uiPositionFor`, `requiresAdminFor`, and `devOnlyFor`.
+**Shell model** -- provider output used by sidebars and breadcrumbs. Includes `systems`, `childrenOf`, `ancestorsOf`, `parentOf`, `topLevel`, `findByPath`, `requiresAdminFor`, and `devOnlyFor`.
 
-**Subshell / Sidebar** -- feature-scoped UI region rendered when the current route matches a feature whose manifest supplies a sidebar.
+**Subshell / Sidebar** -- System- or route-prefix-scoped UI region rendered when the current route matches a module whose manifest supplies a sidebar.
 
 **Topology** -- runtime resource relationships declared in `DeploymentSpec.relationships`.
 
@@ -57,7 +57,7 @@ description: Terminology disambiguation for Organization OS concepts used in the
 
 **`@elevasis/core`**
 
-- `OrganizationModel`, `OrganizationModelFeature`
+- `OrganizationModel`, `OrganizationModelSystemEntry`
 - `SystemEntry`, `ResourceEntry`
 - `resolveOrganizationModel`, `defineOrganizationModel`, `DEFAULT_ORGANIZATION_MODEL`
 - `MembershipFeatureConfig`
@@ -65,9 +65,9 @@ description: Terminology disambiguation for Organization OS concepts used in the
 
 **`@elevasis/ui`**
 
-- `FeatureModule`
-- `FeatureGuard`, `AdminGuard`, `ProtectedRoute`
-- `ElevasisFeaturesProvider`, `ElevasisCoreProvider`, `useElevasisFeatures`
+- `SystemModule`
+- `SystemGuard`, `AdminGuard`, `ProtectedRoute`
+- `ElevasisSystemsProvider`, `ElevasisCoreProvider`, `useElevasisSystems`
 
 **External project source**
 

package/src/supabase/database.types.ts

@@ -2770,6 +2770,66 @@ export type Database = {
           },
         ]
       }
+      user_notes: {
+        Row: {
+          content: string
+          created_at: string
+          created_by: string
+          id: string
+          metadata: Json
+          organization_id: string | null
+          pinned: boolean
+          priority: string
+          source: string | null
+          title: string | null
+          updated_at: string
+          user_id: string
+        }
+        Insert: {
+          content: string
+          created_at?: string
+          created_by?: string
+          id?: string
+          metadata?: Json
+          organization_id?: string | null
+          pinned?: boolean
+          priority?: string
+          source?: string | null
+          title?: string | null
+          updated_at?: string
+          user_id: string
+        }
+        Update: {
+          content?: string
+          created_at?: string
+          created_by?: string
+          id?: string
+          metadata?: Json
+          organization_id?: string | null
+          pinned?: boolean
+          priority?: string
+          source?: string | null
+          title?: string | null
+          updated_at?: string
+          user_id?: string
+        }
+        Relationships: [
+          {
+            foreignKeyName: "user_notes_organization_id_fkey"
+            columns: ["organization_id"]
+            isOneToOne: false
+            referencedRelation: "organizations"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "user_notes_user_id_fkey"
+            columns: ["user_id"]
+            isOneToOne: false
+            referencedRelation: "users"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       users: {
         Row: {
           config: Json

package/src/test-utils/test-utils.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, it } from 'vitest'
 import { BaseProjectSchema, BaseTaskSchema } from '../business/base-entities'
-import { DEFAULT_ORGANIZATION_MODEL } from '../organization-model'
 import {
   makeInitializationState,
   makeOrganizationModel,
@@ -28,16 +27,12 @@ describe('published test-utils factories', () => {
 
   it('creates organization model and initialization fixtures', () => {
     const model = makeOrganizationModel({
-      branding: { organizationName: 'Test Brand' },
-      features: DEFAULT_ORGANIZATION_MODEL.features.map((feature) =>
-        feature.id === 'seo' ? { ...feature, enabled: true } : feature
-      )
+      branding: { organizationName: 'Test Brand' }
     })
     const profile = makeUserProfile({ id: TEST_USERS.admin.id, email: TEST_USERS.admin.email })
     const state = makeInitializationState({ profile, organizationReady: false, allReady: false })
 
     expect(model.branding.organizationName).toBe('Test Brand')
-    expect(model.features.find((feature) => feature.id === 'seo')?.enabled).toBe(true)
     expect(state.profile?.email).toBe(TEST_USERS.admin.email)
     expect(state.organizationReady).toBe(false)
   })

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

@@ -1,203 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
-  OperationEntrySchema,
-  OperationsDomainSchema,
-  OperationSemanticClassSchema
-} from '../../domains/operations'
-
-// ---------------------------------------------------------------------------
-// Group 1: OperationEntrySchema — positive parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — positive parse', () => {
-  it('accepts a fully-specified entry (id, label, semanticClass, featureId, supportedStatusSemanticClass)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue',
-      semanticClass: 'queue',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['queue']
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('accepts a minimal entry without optional fields', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.sessions',
-      label: 'Sessions',
-      semanticClass: 'sessions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.featureId).toBeUndefined()
-      expect(result.data.supportedStatusSemanticClass).toBeUndefined()
-    }
-  })
-
-  it('trims whitespace from id and label', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: '  trimmed-id  ',
-      label: '  Trimmed Label  ',
-      semanticClass: 'executions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('trimmed-id')
-      expect(result.data.label).toBe('Trimmed Label')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 2: OperationEntrySchema — negative parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — negative parse', () => {
-  it('rejects a missing id field', () => {
-    const result = OperationEntrySchema.safeParse({
-      label: 'No ID',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing label field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing semanticClass field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an unknown semanticClass value', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'some.entry',
-      label: 'Some Entry',
-      semanticClass: 'not-a-real-class'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a non-string id (number)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 42,
-      label: 'Label',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an empty string label (min length 1 after trim)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'some.entry',
-      label: '   ',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 3: OperationsDomainSchema — structural tests
-// ---------------------------------------------------------------------------
-
-describe('OperationsDomainSchema — structural tests', () => {
-  it('accepts an entries-empty domain object', () => {
-    const result = OperationsDomainSchema.safeParse({ entries: [] })
-    expect(result.success).toBe(true)
-  })
-
-  it('applies an empty-array default when entries is omitted', () => {
-    const result = OperationsDomainSchema.safeParse({})
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.entries).toEqual([])
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 4: Semantic class enum — all 5 values declared
-// ---------------------------------------------------------------------------
-
-describe('OperationSemanticClassSchema — enum coverage', () => {
-  const expectedClasses = ['queue', 'executions', 'sessions', 'notifications', 'schedules'] as const
-
-  it('enum exposes exactly 5 semantic classes', () => {
-    expect(OperationSemanticClassSchema.options).toHaveLength(5)
-  })
-
-  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
-    const result = OperationSemanticClassSchema.safeParse(cls)
-    expect(result.success).toBe(true)
-  })
-
-  it('every entry in the seed uses one of the 5 known semanticClass values', () => {
-    const valid = new Set<string>(OperationSemanticClassSchema.options)
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-      expect(
-        valid.has(entry.semanticClass),
-        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
-      ).toBe(true)
-    }
-  })
-
-  it('all 5 semanticClass values have exactly one seed entry', () => {
-    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.semanticClass))
-    for (const cls of OperationSemanticClassSchema.options) {
-      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 5: Seed completeness
-// ---------------------------------------------------------------------------
-
-describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS seed — completeness', () => {
-  it('has exactly 5 entries (one per entity category)', () => {
-    expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
-  })
-
-  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)
-  })
-
-  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('queue entry references queue status semantic class', () => {
-    const queueEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'queue')
-    expect(queueEntry).toBeDefined()
-    expect(queueEntry?.supportedStatusSemanticClass).toContain('queue')
-  })
-
-  it('executions entry references execution status semantic class', () => {
-    const execEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'executions')
-    expect(execEntry).toBeDefined()
-    expect(execEntry?.supportedStatusSemanticClass).toContain('execution')
-  })
-
-  it('schedules entry references schedule and schedule.run status semantic classes', () => {
-    const schedEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'schedules')
-    expect(schedEntry).toBeDefined()
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule')
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule.run')
-  })
-})

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

@@ -1,31 +0,0 @@
-import { z } from 'zod'
-import { ColorTokenSchema, DescriptionSchema, IconNameSchema, LabelSchema, PathSchema } from './shared'
-
-export const NodeIdPathSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(100)
-  .regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, 'Node IDs must be lowercase dotted paths')
-
-export const NodeIdStringSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(200)
-  .regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, 'Node references must use kind:dotted-path')
-
-export const UiPositionSchema = z.enum(['sidebar-primary', 'sidebar-bottom'])
-
-export const FeatureSchema = z.object({
-  id: NodeIdPathSchema,
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  path: PathSchema.optional(),
-  icon: IconNameSchema.optional(),
-  color: ColorTokenSchema.optional(),
-  uiPosition: UiPositionSchema.optional(),
-  requiresAdmin: z.boolean().optional(),
-  devOnly: z.boolean().optional()
-})

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

@@ -1,85 +0,0 @@
-import { z } from 'zod'
-
-// ---------------------------------------------------------------------------
-// Semantic class enum — one value per stateful runtime entity category.
-// Every operation entry declares which category it belongs to via semanticClass.
-// ---------------------------------------------------------------------------
-
-export const OperationSemanticClassSchema = z.enum(['queue', 'executions', 'sessions', 'notifications', 'schedules'])
-
-// ---------------------------------------------------------------------------
-// Operation entry schema
-// ---------------------------------------------------------------------------
-
-export const OperationEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: OperationSemanticClassSchema,
-  /** Optional reference to the feature that owns this runtime entity. */
-  featureId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional pointer to the status semanticClass values that apply to this
-   * entity — ties operations back to the statuses domain for vibe rendering.
-   */
-  supportedStatusSemanticClass: z.array(z.string().trim().min(1).max(80)).optional()
-})
-
-// ---------------------------------------------------------------------------
-// Domain schema — a flat array of operation entries
-// ---------------------------------------------------------------------------
-
-export const OperationsDomainSchema = z.object({
-  entries: z.array(OperationEntrySchema).default([])
-})
-
-// ---------------------------------------------------------------------------
-// Seed — one entry per stateful runtime entity category.
-// Categories: queue (HITL), executions, sessions, notifications, schedules.
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_ORGANIZATION_MODEL_OPERATIONS: z.infer<typeof OperationsDomainSchema> = {
-  entries: [
-    // --- queue (HITL command queue) ---
-    {
-      id: 'operations.queue',
-      label: 'HITL Queue',
-      semanticClass: 'queue',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['queue']
-    },
-
-    // --- executions (workflow / agent executions) ---
-    {
-      id: 'operations.executions',
-      label: 'Executions',
-      semanticClass: 'executions',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['execution']
-    },
-
-    // --- sessions (agent conversation sessions) ---
-    {
-      id: 'operations.sessions',
-      label: 'Sessions',
-      semanticClass: 'sessions',
-      featureId: 'operations'
-    },
-
-    // --- notifications (platform in-app notifications) ---
-    {
-      id: 'operations.notifications',
-      label: 'Notifications',
-      semanticClass: 'notifications',
-      featureId: 'monitoring'
-    },
-
-    // --- schedules (task scheduler) ---
-    {
-      id: 'operations.schedules',
-      label: 'Schedules',
-      semanticClass: 'schedules',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['schedule', 'schedule.run']
-    }
-  ]
-}