@elevasis/core 0.42.1 → 0.44.0

package/dist/test-utils/index.js

@@ -19426,16 +19426,13 @@ var OntologyKindSchema = z.enum([
   "value-type",
   "property",
   "group",
-  "surface"
+  "endpoint"
 ]);
 var SYSTEM_PATH_PATTERN = "[a-z0-9][a-z0-9-]*(?:\\.[a-z0-9][a-z0-9-]*)*";
 var LOCAL_ID_PATTERN = "[a-z0-9][a-z0-9._-]*";
 var ONTOLOGY_ID_PATTERN = `^(global|${SYSTEM_PATH_PATTERN}):(${OntologyKindSchema.options.join("|")})\\/(${LOCAL_ID_PATTERN})$`;
 var ONTOLOGY_ID_REGEX = new RegExp(ONTOLOGY_ID_PATTERN);
-var OntologyIdSchema = z.string().trim().min(1).max(300).regex(
-  ONTOLOGY_ID_REGEX,
-  "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>"
-);
+var OntologyIdSchema = z.string().trim().min(1).max(300).regex(ONTOLOGY_ID_REGEX, "Ontology IDs must use <system-path>:<kind>/<local-id> or global:<kind>/<local-id>");
 function parseOntologyId(id) {
   const normalized = OntologyIdSchema.parse(id);
   const match = ONTOLOGY_ID_REGEX.exec(normalized);
@@ -19498,7 +19495,7 @@ var OntologySharedPropertySchema = OntologyRecordBaseSchema.extend({
 var OntologyGroupSchema = OntologyRecordBaseSchema.extend({
   members: OntologyReferenceListSchema
 });
-var OntologySurfaceTypeSchema = OntologyRecordBaseSchema.extend({
+var OntologyEndpointTypeSchema = OntologyRecordBaseSchema.extend({
   route: z.string().trim().min(1).max(500).optional()
 });
 var OntologyScopeSchema = z.object({
@@ -19511,7 +19508,7 @@ var OntologyScopeSchema = z.object({
   valueTypes: z.record(OntologyIdSchema, OntologyValueTypeSchema).default({}).optional(),
   sharedProperties: z.record(OntologyIdSchema, OntologySharedPropertySchema).default({}).optional(),
   groups: z.record(OntologyIdSchema, OntologyGroupSchema).default({}).optional(),
-  surfaces: z.record(OntologyIdSchema, OntologySurfaceTypeSchema).default({}).optional()
+  endpoints: z.record(OntologyIdSchema, OntologyEndpointTypeSchema).default({}).optional()
 }).default({});
 var DEFAULT_ONTOLOGY_SCOPE = {
   valueTypes: {
@@ -19547,7 +19544,7 @@ var SCOPE_KIND = {
   valueTypes: "value-type",
   sharedProperties: "property",
   groups: "group",
-  surfaces: "surface"
+  endpoints: "endpoint"
 };
 var SCOPE_KEYS = Object.keys(SCOPE_KIND);
 function listResolvedOntologyRecords(index2) {
@@ -19580,7 +19577,7 @@ function createEmptyIndex() {
     valueTypes: {},
     sharedProperties: {},
     groups: {},
-    surfaces: {}
+    endpoints: {}
   };
 }
 function sortResolvedOntologyIndex(index2) {
@@ -20415,8 +20412,6 @@ var SystemEntrySchema = z.object({
   path: PathSchema.optional(),
   /** @deprecated Use ui.icon. Kept for one-cycle Feature compatibility. */
   icon: IconNameSchema.optional(),
-  /** @deprecated Feature color token, retained for one-cycle compatibility. */
-  color: ColorTokenSchema.optional(),
   /** @deprecated UI placement hint, retained for one-cycle compatibility. */
   uiPosition: UiPositionSchema.optional(),
   /** @deprecated Use lifecycle. */
@@ -20498,7 +20493,7 @@ var ResourceOntologyBindingSchema = z.object({
   /**
    * Optional typed contract binding for this resource's workflow I/O.
    * Each ref is a `package/subpath#ExportName` string that resolves to a
-   * Zod schema in `@repo/elevasis-core` (or the consumer's equivalent package).
+   * Zod schema in the tenant-owned organization model package.
    *
    * Absence of this field preserves all existing behavior — it is additive + optional.
    * Tier-1 validation (schema.ts): ref-string shape only (browser-safe, no imports).
@@ -20939,10 +20934,11 @@ var ONTOLOGY_REFERENCE_KEY_KINDS = {
   interfaceType: "interface",
   propertyType: "property",
   groupType: "group",
-  surfaceType: "surface",
+  endpointType: "endpoint",
   stepCatalog: "catalog"
 };
-function buildOmCrossRefIndex(model) {
+var omCompilationContextCache = /* @__PURE__ */ new WeakMap();
+function buildOmCrossRefIndexFromOntology(model, ontologyCompilation) {
   const systemsById = /* @__PURE__ */ new Map();
   for (const { path, system } of listAllSystems(model)) {
     systemsById.set(path, system);
@@ -20956,7 +20952,6 @@ function buildOmCrossRefIndex(model) {
   const actionIds = new Set(Object.keys(model.actions ?? {}));
   const customerSegmentIds = new Set(Object.keys(model.customers ?? {}));
   const offeringIds = new Set(Object.keys(model.offerings ?? {}));
-  const ontologyCompilation = compileOrganizationOntology(model);
   const ontologyIndexByKind = {
     object: ontologyCompilation.ontology.objectTypes,
     link: ontologyCompilation.ontology.linkTypes,
@@ -20967,7 +20962,7 @@ function buildOmCrossRefIndex(model) {
     "value-type": ontologyCompilation.ontology.valueTypes,
     property: ontologyCompilation.ontology.sharedProperties,
     group: ontologyCompilation.ontology.groups,
-    surface: ontologyCompilation.ontology.surfaces
+    endpoint: ontologyCompilation.ontology.endpoints
   };
   const ontologyIds = new Set(Object.values(ontologyIndexByKind).flatMap((index2) => Object.keys(index2)));
   const stageIds = /* @__PURE__ */ new Set();
@@ -20995,6 +20990,15 @@ function buildOmCrossRefIndex(model) {
     stageIds
   };
 }
+function buildOmCompilationContext(model) {
+  const cached = omCompilationContextCache.get(model);
+  if (cached !== void 0) return cached;
+  const ontologyCompilation = compileOrganizationOntology(model);
+  const crossRefIndex = buildOmCrossRefIndexFromOntology(model, ontologyCompilation);
+  const context = { crossRefIndex, ontologyCompilation };
+  omCompilationContextCache.set(model, context);
+  return context;
+}
 function knowledgeTargetExists(index2, kind, id) {
   if (kind === "system") return index2.systemsById.has(id);
   if (kind === "client") return index2.clientIds.has(id);
@@ -21331,9 +21335,8 @@ function refineOrganizationModel(model, ctx) {
       }
     });
   });
-  const idx = buildOmCrossRefIndex(model);
+  const { crossRefIndex: idx, ontologyCompilation } = buildOmCompilationContext(model);
   const { ontologyIndexByKind, ontologyIds } = idx;
-  const ontologyCompilation = compileOrganizationOntology(model);
   function topologyTargetExists(ref) {
     if (ref.kind === "system") return systemsById.has(ref.id);
     if (ref.kind === "resource") return resourcesById.has(ref.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.42.1",
+  "version": "0.44.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,
@@ -45,8 +45,8 @@
     "rollup-plugin-dts": "^6.3.0",
     "tsup": "^8.0.0",
     "typescript": "5.9.2",
-    "@repo/eslint-config": "0.0.0",
-    "@repo/typescript-config": "0.0.0"
+    "@repo/typescript-config": "0.0.0",
+    "@repo/eslint-config": "0.0.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.62.0",

package/src/auth/access-keys.ts

@@ -51,14 +51,20 @@ export const AccessKeys = {
   organizationManage: { systemPath: 'permission.org', action: 'manage' },
   membersManage: { systemPath: 'permission.members', action: 'manage' },
   rolesManage: { systemPath: 'permission.roles', action: 'manage' },
+  /** @reserved Reserved for first-class secret administration routes and command surfaces. */
   secretsManage: { systemPath: 'permission.secrets', action: 'manage' },
   operationsRead: { systemPath: 'permission.operations', action: DEFAULT_ACCESS_ACTION },
+  /** @reserved Reserved for write-level operations administration beyond read-only monitoring. */
   operationsManage: { systemPath: 'permission.operations', action: 'manage' },
   leadGenManage: { systemPath: 'sales.lead-gen', action: 'manage' },
+  /** @reserved Reserved for acquisition administration once that permission namespace is wired. */
   acquisitionManage: { systemPath: 'permission.acquisition', action: 'manage' },
+  /** @reserved Reserved for project administration permission catalog compatibility. */
   projectsManage: { systemPath: 'permission.projects', action: 'manage' },
+  /** @reserved Reserved for client administration permission catalog compatibility. */
   clientsManage: { systemPath: 'permission.clients', action: 'manage' },
   operationsOverview: { systemPath: 'diagnostic.operations.overview', action: DEFAULT_ACCESS_ACTION },
+  /** @reserved Reserved for a diagnostics surface that lists recent operations executions. */
   operationsRecentExecutions: { systemPath: 'diagnostic.operations.recent-executions', action: DEFAULT_ACCESS_ACTION },
   monitoringExecutionLogs: { systemPath: 'diagnostic.monitoring.execution-logs', action: DEFAULT_ACCESS_ACTION },
   monitoringNotifications: { systemPath: 'diagnostic.monitoring.notifications', action: DEFAULT_ACCESS_ACTION }

package/src/business/acquisition/api-schemas.ts

@@ -10,7 +10,7 @@ export const LeadGenStageKeySchema = z.string().trim().min(1)
 
 export const LeadGenActionKeySchema = z.string().trim().min(1)
 
-// CRM stage/state catalogs are model-owned (authored in @repo/elevasis-core
+// CRM stage/state catalogs are model-owned (authored in the tenant-owned organization model package
 // canonicalOrganizationModel). The published core schema validates only the
 // transport shape; closed-catalog membership is enforced by the caller/API
 // layer via model-injected validators (mirrors LeadGenStageKeySchema).

package/src/business/base-entities.ts

@@ -12,7 +12,7 @@ import { z } from 'zod'
  * layer; use the row types internally for direct Supabase access.
  *
  * Usage in a client project:
- *   import { BaseProject } from '@elevasis/core' (or '@repo/core' internally)
+ *   import { BaseProject } from '@elevasis/core'
  *   type Project = BaseProject<{ budget: number; riskScore: 'low' | 'medium' | 'high' }>
  *
  * Extending a Zod schema in a client project:

package/src/knowledge/cli-helpers.ts

@@ -0,0 +1,211 @@
+import type {
+  OrganizationModel,
+  OrganizationModelAction,
+  OrganizationModelActionInvocation,
+  OrganizationModelAgentResourceEntry
+} from '../organization-model/types'
+import { getSystem } from '../organization-model/helpers'
+import type { listAllResources, listAllRoles, listAllSystemsFlat, OmSearchHitKind } from './queries'
+
+export const OM_SEARCH_HIT_KINDS: OmSearchHitKind[] = ['system', 'resource', 'knowledge', 'ontology', 'role', 'policy']
+
+export function parseKnowledgeSearchLimit(raw: string | undefined, commandName = 'knowledge:search'): number {
+  if (raw === undefined) return 10
+  const n = Number.parseInt(raw, 10)
+  if (Number.isNaN(n) || n < 0) {
+    throw new Error(`${commandName}: --limit must be a non-negative integer (got "${raw}")`)
+  }
+  return n
+}
+
+export function parseKnowledgeSearchKinds(
+  raw: string | undefined,
+  commandName = 'knowledge:search'
+): OmSearchHitKind[] | undefined {
+  if (raw === undefined) return undefined
+  const requested = raw
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter((s) => s.length > 0)
+  const valid: OmSearchHitKind[] = []
+  const invalid: string[] = []
+  for (const kind of requested) {
+    if (OM_SEARCH_HIT_KINDS.includes(kind as OmSearchHitKind)) {
+      valid.push(kind as OmSearchHitKind)
+    } else {
+      invalid.push(kind)
+    }
+  }
+  if (invalid.length > 0) {
+    throw new Error(`${commandName}: unknown kind(s) "${invalid.join(', ')}". Valid: ${OM_SEARCH_HIT_KINDS.join(', ')}`)
+  }
+  return valid.length > 0 ? valid : undefined
+}
+
+export function formatKnowledgeSystemsList(entries: ReturnType<typeof listAllSystemsFlat>): string {
+  if (entries.length === 0) return '(no results)'
+  const pathWidth = Math.max(...entries.map((e) => e.path.length), 4)
+  const header = `${'PATH'.padEnd(pathWidth)}  LABEL`
+  const divider = '-'.repeat(header.length + 20)
+  const rows = entries.map((e) => {
+    const label = e.system.label ?? e.system.title ?? e.path
+    return `${e.path.padEnd(pathWidth)}  ${label}`
+  })
+  return [header, divider, ...rows].join('\n')
+}
+
+export function formatKnowledgeResourcesList(resources: ReturnType<typeof listAllResources>): string {
+  if (resources.length === 0) return '(no results)'
+  const idWidth = Math.max(...resources.map((r) => r.id.length), 4)
+  const kindWidth = Math.max(...resources.map((r) => r.kind.length), 4)
+  const header = `${'ID'.padEnd(idWidth)}  ${'KIND'.padEnd(kindWidth)}  TITLE`
+  const divider = '-'.repeat(header.length + 20)
+  const rows = resources.map((r) => {
+    const title = r.title ?? r.id
+    return `${r.id.padEnd(idWidth)}  ${r.kind.padEnd(kindWidth)}  ${title}`
+  })
+  return [header, divider, ...rows].join('\n')
+}
+
+export function formatKnowledgeRolesList(roles: ReturnType<typeof listAllRoles>): string {
+  if (roles.length === 0) return '(no results)'
+  const idWidth = Math.max(...roles.map((r) => r.id.length), 4)
+  const header = `${'ID'.padEnd(idWidth)}  TITLE`
+  const divider = '-'.repeat(header.length + 20)
+  const rows = roles.map((r) => `${r.id.padEnd(idWidth)}  ${r.title}`)
+  return [header, divider, ...rows].join('\n')
+}
+
+export interface KnowledgeInvocationSource {
+  kind: 'action' | 'agent-resource'
+  id: string
+  label: string
+  targetNodeId: string
+  invocations: OrganizationModelActionInvocation[]
+}
+
+export interface KnowledgeInvocationNeighborsResult {
+  id: string
+  title: string
+  invocationSources: KnowledgeInvocationSource[]
+}
+
+export function normalizeKnowledgeNodeId(id: string): string {
+  return id.startsWith('knowledge:') ? id.slice('knowledge:'.length) : id
+}
+
+export function formatKnowledgeInvocationLabel(invocation: OrganizationModelActionInvocation): string {
+  switch (invocation.kind) {
+    case 'slash-command':
+      return invocation.command
+    case 'mcp-tool':
+      return `${invocation.server}/${invocation.name}`
+    case 'api-endpoint':
+      return `${invocation.method} ${invocation.path}`
+    case 'script-execution':
+      return invocation.resourceId
+  }
+}
+
+function pushActionSource(
+  sources: KnowledgeInvocationSource[],
+  seen: Set<string>,
+  action: OrganizationModelAction | undefined
+): void {
+  if (!action || action.invocations.length === 0) return
+
+  const key = `action:${action.id}`
+  if (seen.has(key)) return
+  seen.add(key)
+
+  sources.push({
+    kind: 'action',
+    id: action.id,
+    label: action.label,
+    targetNodeId: `action:${action.id}`,
+    invocations: action.invocations
+  })
+}
+
+function pushAgentResourceSource(
+  sources: KnowledgeInvocationSource[],
+  seen: Set<string>,
+  resource: OrganizationModel['resources'][string] | undefined
+): void {
+  if (!resource || resource.kind !== 'agent' || resource.invocations.length === 0) return
+
+  const agentResource = resource as OrganizationModelAgentResourceEntry
+  const key = `agent-resource:${agentResource.id}`
+  if (seen.has(key)) return
+  seen.add(key)
+
+  sources.push({
+    kind: 'agent-resource',
+    id: agentResource.id,
+    label: agentResource.id,
+    targetNodeId: `resource:${agentResource.id}`,
+    invocations: agentResource.invocations
+  })
+}
+
+export function resolveKnowledgeInvocationNeighbors(
+  model: OrganizationModel,
+  id: string
+): KnowledgeInvocationNeighborsResult | undefined {
+  const normalizedNodeId = normalizeKnowledgeNodeId(id)
+  const node = model.knowledge[normalizedNodeId]
+  if (!node) return undefined
+
+  const sources: KnowledgeInvocationSource[] = []
+  const seen = new Set<string>()
+
+  for (const link of node.links) {
+    const target = link.target
+
+    if (target.kind === 'action') {
+      pushActionSource(sources, seen, model.actions[target.id])
+      continue
+    }
+
+    if (target.kind === 'resource') {
+      pushAgentResourceSource(sources, seen, model.resources[target.id])
+      continue
+    }
+
+    if (target.kind === 'system') {
+      const system = getSystem(model, target.id)
+      for (const actionRef of system?.actions ?? []) {
+        pushActionSource(sources, seen, model.actions[actionRef.actionId])
+      }
+
+      for (const resource of Object.values(model.resources)) {
+        if (resource.systemPath === target.id) {
+          pushAgentResourceSource(sources, seen, resource)
+        }
+      }
+    }
+  }
+
+  return {
+    id: node.id,
+    title: node.title,
+    invocationSources: sources.sort((a, b) => a.targetNodeId.localeCompare(b.targetNodeId))
+  }
+}
+
+export function formatKnowledgeInvocationNeighbors(result: KnowledgeInvocationNeighborsResult): string {
+  const lines = [`Invocation-bearing graph neighbors for ${result.id}`, '']
+
+  if (result.invocationSources.length === 0) {
+    lines.push('  (none)')
+  } else {
+    for (const source of result.invocationSources) {
+      lines.push(`${source.kind}: ${source.id}`)
+      for (const invocation of source.invocations) {
+        lines.push(`  ${invocation.kind}: ${formatKnowledgeInvocationLabel(invocation)}`)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}

package/src/knowledge/index.ts

@@ -29,3 +29,16 @@ export type {
 
 export { formatText, formatJson, formatIdsOnly, formatOmSearchHits, formatOmDescribe } from './format'
 export type { KnowledgeJsonEnvelope } from './format'
+export {
+  OM_SEARCH_HIT_KINDS,
+  parseKnowledgeSearchLimit,
+  parseKnowledgeSearchKinds,
+  formatKnowledgeSystemsList,
+  formatKnowledgeResourcesList,
+  formatKnowledgeRolesList,
+  normalizeKnowledgeNodeId,
+  formatKnowledgeInvocationLabel,
+  resolveKnowledgeInvocationNeighbors,
+  formatKnowledgeInvocationNeighbors
+} from './cli-helpers'
+export type { KnowledgeInvocationSource, KnowledgeInvocationNeighborsResult } from './cli-helpers'

package/src/knowledge/published.ts

@@ -1,5 +1,18 @@
-export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
-export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
-
-export { formatText, formatJson, formatIdsOnly } from './format'
-export type { KnowledgeJsonEnvelope } from './format'
+export { bySystem, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export type { KnowledgeMount, ParsedKnowledgePath, OmSearchHitKind } from './queries'
+
+export { formatText, formatJson, formatIdsOnly } from './format'
+export type { KnowledgeJsonEnvelope } from './format'
+export {
+  OM_SEARCH_HIT_KINDS,
+  parseKnowledgeSearchLimit,
+  parseKnowledgeSearchKinds,
+  formatKnowledgeSystemsList,
+  formatKnowledgeResourcesList,
+  formatKnowledgeRolesList,
+  normalizeKnowledgeNodeId,
+  formatKnowledgeInvocationLabel,
+  resolveKnowledgeInvocationNeighbors,
+  formatKnowledgeInvocationNeighbors
+} from './cli-helpers'
+export type { KnowledgeInvocationSource, KnowledgeInvocationNeighborsResult } from './cli-helpers'

package/src/knowledge/queries.ts

@@ -719,7 +719,7 @@ function collectOntologyEntries(scope: {
   valueTypes?: Record<string, OntologyRecordLike>
   sharedProperties?: Record<string, OntologyRecordLike>
   groups?: Record<string, OntologyRecordLike>
-  surfaces?: Record<string, OntologyRecordLike>
+  endpoints?: Record<string, OntologyRecordLike>
 }): SearchableEntry[] {
   const entries: SearchableEntry[] = []
 
@@ -733,7 +733,7 @@ function collectOntologyEntries(scope: {
     ['value-type', scope.valueTypes],
     ['property', scope.sharedProperties],
     ['group', scope.groups],
-    ['surface', scope.surfaces]
+    ['endpoint', scope.endpoints]
   ]
 
   for (const [subKind, records] of buckets) {
@@ -874,7 +874,7 @@ export interface OmDescribePolicy {
  * - Matches a key in `model.resources` → resource
  */
 function detectKind(model: OrganizationModel, id: string): OmSearchHitKind | undefined {
-  if (/:(object|action|event|catalog|link|interface|value-type|property|group|surface)\//.test(id)) {
+  if (/:(object|action|event|catalog|link|interface|value-type|property|group|endpoint)\//.test(id)) {
     return 'ontology'
   }
   if (id.startsWith('knowledge.')) return 'knowledge'
@@ -972,7 +972,7 @@ function describeSystem(model: OrganizationModel, path: string): OmDescribeSyste
       ['value-type', ontology.valueTypes],
       ['property', ontology.sharedProperties],
       ['group', ontology.groups],
-      ['surface', ontology.surfaces]
+      ['endpoint', ontology.endpoints]
     ]
     for (const [k, records] of buckets) {
       const count = records ? Object.keys(records).length : 0
@@ -1058,7 +1058,7 @@ function describeOntology(model: OrganizationModel, id: string): OmDescribeOntol
     ['value-type', 'valueTypes'],
     ['property', 'sharedProperties'],
     ['group', 'groups'],
-    ['surface', 'surfaces']
+    ['endpoint', 'endpoints']
   ]
   const bucketKey = buckets.find((b) => b[0] === ontologyKind)?.[1]
   if (!bucketKey) return undefined

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

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import { DEFAULT_ORGANIZATION_MODEL } from '../defaults'
-import { buildOmCrossRefIndex, knowledgeTargetExists } from '../cross-ref'
+import { buildOmCompilationContext, buildOmCrossRefIndex, knowledgeTargetExists } from '../cross-ref'
 import { OrganizationModelSchema } from '../schema'
 import type { OrganizationModel } from '../types'
 
@@ -80,6 +80,16 @@ function makeModelWithStage(): OrganizationModel {
 // ---------------------------------------------------------------------------
 
 describe('knowledgeTargetExists — stage kind', () => {
+  it('buildOmCompilationContext returns a memoized cross-ref index plus ontology compilation', () => {
+    const model = makeModelWithStage()
+    const context = buildOmCompilationContext(model)
+
+    expect(buildOmCompilationContext(model)).toBe(context)
+    expect(context.crossRefIndex.stageIds.has('prospect')).toBe(true)
+    expect(context.ontologyCompilation.ontology.catalogTypes['sales.lead-gen:catalog/company-stage']).toBeDefined()
+    expect(buildOmCrossRefIndex(model)).toBe(context.crossRefIndex)
+  })
+
   it('returns true for a stage id that exists in a stage-kind catalog', () => {
     const model = makeModelWithStage()
     const idx = buildOmCrossRefIndex(model)

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

@@ -123,10 +123,10 @@ describe('SystemEntrySchema - positive parse', () => {
     }
   })
 
-  it('accepts deprecated status and maps it to lifecycle for one-cycle compatibility', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
-
-    const result = SystemEntrySchema.safeParse({
+  it('accepts deprecated status and maps it to lifecycle for one-cycle compatibility', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    const result = SystemEntrySchema.safeParse({
       ...VALID_SYSTEM,
       status: 'deprecated'
     })
@@ -137,10 +137,32 @@ describe('SystemEntrySchema - positive parse', () => {
       expect(result.data.lifecycle).toBe('deprecated')
     }
     expect(warn).toHaveBeenCalledWith('[organization-model] System.status is deprecated; use System.lifecycle instead.')
-
-    warn.mockRestore()
-  })
-})
+
+    warn.mockRestore()
+  })
+
+  it('keeps non-color compatibility fields readable', () => {
+    const result = SystemEntrySchema.safeParse({
+      ...VALID_SYSTEM,
+      path: '/lead-gen',
+      icon: 'settings',
+      uiPosition: 'sidebar-primary',
+      enabled: true,
+      devOnly: false
+    })
+
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data).toMatchObject({
+        path: '/lead-gen',
+        icon: 'settings',
+        uiPosition: 'sidebar-primary',
+        enabled: true,
+        devOnly: false
+      })
+    }
+  })
+})
 
 describe('SystemEntrySchema - negative parse', () => {
   it('rejects missing required fields', () => {
@@ -159,6 +181,10 @@ describe('SystemEntrySchema - negative parse', () => {
     expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, id: 'Sys Lead Gen' }).success).toBe(false)
   })
 
+  it('rejects the retired color compatibility field', () => {
+    expect(SystemEntrySchema.safeParse({ ...VALID_SYSTEM, color: 'blue' }).success).toBe(false)
+  })
+
   it('rejects malformed System Interface states', () => {
     expect(SystemApiInterfaceSchema.safeParse({ kind: 'api', lifecycle: 'active' }).success).toBe(false)
     expect(SystemApiInterfaceSchema.safeParse({ lifecycle: 'paused' }).success).toBe(false)

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

@@ -44,7 +44,11 @@ describe('organization-model scaffolders', () => {
         'packages/elevasis-core/src/organization-model/knowledge.ts'
       ])
     )
-    expect(plan.writes.some((write) => write.path.endsWith('manifest.stub.ts'))).toBe(true)
+    const manifestStub = plan.writes.find((write) => write.path.endsWith('manifest.stub.ts'))
+    expect(manifestStub?.content).toContain('key: "sales-partners"')
+    expect(manifestStub?.content).toContain('systemId: "sales.partners"')
+    expect(manifestStub?.content).not.toContain('label:')
+    expect(manifestStub?.content).not.toContain('routes:')
     expect(plan.writes.some((write) => write.path.includes('/routes/'))).toBe(false)
     expect(plan.projectCommand).toBeUndefined()
   })
@@ -82,6 +86,31 @@ describe('organization-model scaffolders', () => {
     expect(knowledge.projectCommand).toBeUndefined()
   })
 
+  it('emits required link ontology stubs', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'ontology',
+      id: 'deal-owner',
+      systemPath: 'sales.crm',
+      kind: 'link'
+    })
+
+    expect(plan.edits[0]?.snippet).toContain('"sales.crm:link/deal-owner": {')
+    expect(plan.edits[0]?.snippet).toContain('"from": "sales.crm:object/source-object"')
+    expect(plan.edits[0]?.snippet).toContain('"to": "sales.crm:object/target-object"')
+  })
+
+  it('emits action ontology actsOn stubs', () => {
+    const plan = scaffoldOrganizationModel(BASE_MODEL, {
+      intent: 'ontology',
+      id: 'update-deal',
+      systemPath: 'sales.crm',
+      kind: 'action'
+    })
+
+    expect(plan.edits[0]?.snippet).toContain('"sales.crm:action/update-deal": {')
+    expect(plan.edits[0]?.snippet).toContain('"actsOn": []')
+  })
+
   it('rejects duplicate system paths during planning', () => {
     expect(() =>
       scaffoldOrganizationModel(BASE_MODEL, {