@elevasis/core 0.25.0 → 0.26.0

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

@@ -3,54 +3,109 @@ import { DescriptionSchema, LabelSchema, ModelIdSchema } from './shared'
 import { SystemPathSchema, SystemLifecycleSchema } from './systems'
 import { ActionInvocationSchema } from './actions'
 import { OntologyIdSchema } from '../ontology'
-
-// ---------------------------------------------------------------------------
-// Resources domain
-// ---------------------------------------------------------------------------
-//
-// Resources are governance-only OM descriptors. Runtime code imports these
-// descriptors and attaches executable behavior; it does not re-author identity.
-
-export const ResourceKindSchema = z
-  .enum(['workflow', 'agent', 'integration', 'script'])
-  .meta({ label: 'Resource kind', color: 'orange' })
-export const ResourceGovernanceStatusSchema = z
-  .enum(['active', 'deprecated', 'archived'])
-  .meta({ label: 'Governance status', color: 'teal' })
-export const AgentKindSchema = z
-  .enum(['orchestrator', 'specialist', 'utility', 'platform'])
-  .meta({ label: 'Agent kind', color: 'violet' })
-export const ScriptResourceLanguageSchema = z.enum(['shell', 'sql', 'typescript', 'python']).meta({ label: 'Language' })
-export const CodeReferenceRoleSchema = z
-  .enum(['entrypoint', 'handler', 'schema', 'test', 'docs', 'config'])
-  .meta({ label: 'Code reference role', color: 'blue' })
-
-export const ResourceIdSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(255)
-  .regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, 'Resource IDs must use letters, numbers, -, _, or . separators')
-
-export const EventIdSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(300)
-  .regex(
-    /^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*:[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
-    'Event IDs must use <owner-id>:<event-key>'
-  )
-
-export const EventKeySchema = ModelIdSchema
-
-export const EventEmissionDescriptorSchema = z.object({
-  eventKey: EventKeySchema,
-  label: z.string().trim().min(1).max(120),
-  payloadSchema: ModelIdSchema.optional(),
-  lifecycle: SystemLifecycleSchema.optional()
-})
-
+
+// ---------------------------------------------------------------------------
+// ContractRef — portable, browser-safe ref string for workflow I/O contracts
+// ---------------------------------------------------------------------------
+//
+// Format: `package/subpath#ExportName`
+// Examples:
+//   `@repo/elevasis-core/contracts/apollo-import#inputSchema`
+//   `@repo/elevasis-core/contracts/dtc-subscription-score#outputSchema`
+//
+// Tier-1 validation (schema.ts superRefine): ref-string SHAPE only — no import
+// Tier-2 validation (om:verify): intra-@repo/elevasis-core typed-map resolution
+
+/** Portable `package/subpath#ExportName` contract reference string. Browser-safe; no imports. */
+export const ContractRefSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(500)
+  .regex(
+    /^[A-Za-z0-9@](?:[A-Za-z0-9_./@-]*[A-Za-z0-9_])?\/?[A-Za-z0-9_./@-]*#[A-Za-z_$][A-Za-z0-9_$]*$/,
+    'ContractRef must be in the format package/subpath#ExportName (e.g. @repo/elevasis-core/contracts/apollo-import#inputSchema)'
+  )
+
+export type ContractRef = z.infer<typeof ContractRefSchema>
+
+/** Parsed representation of a ContractRef string. */
+export interface ParsedContractRef {
+  /** The full package + subpath portion before `#`. */
+  moduleSpecifier: string
+  /** The export name after `#`. */
+  exportName: string
+}
+
+/**
+ * Parse a `package/subpath#ExportName` contract ref string.
+ * Browser-safe — no module system interaction.
+ *
+ * @throws {Error} if the ref string does not match the expected format.
+ */
+export function parseContractRef(ref: string): ParsedContractRef {
+  const hashIndex = ref.lastIndexOf('#')
+  if (hashIndex === -1) {
+    throw new Error(`ContractRef "${ref}" is missing the required "#ExportName" suffix`)
+  }
+  const moduleSpecifier = ref.slice(0, hashIndex)
+  const exportName = ref.slice(hashIndex + 1)
+  if (!moduleSpecifier) {
+    throw new Error(`ContractRef "${ref}" has an empty module specifier before "#"`)
+  }
+  if (!exportName) {
+    throw new Error(`ContractRef "${ref}" has an empty export name after "#"`)
+  }
+  return { moduleSpecifier, exportName }
+}
+
+// ---------------------------------------------------------------------------
+// Resources domain
+// ---------------------------------------------------------------------------
+//
+// Resources are governance-only OM descriptors. Runtime code imports these
+// descriptors and attaches executable behavior; it does not re-author identity.
+
+export const ResourceKindSchema = z
+  .enum(['workflow', 'agent', 'integration', 'script'])
+  .meta({ label: 'Resource kind', color: 'orange' })
+export const ResourceGovernanceStatusSchema = z
+  .enum(['active', 'deprecated', 'archived'])
+  .meta({ label: 'Governance status', color: 'teal' })
+export const AgentKindSchema = z
+  .enum(['orchestrator', 'specialist', 'utility', 'platform'])
+  .meta({ label: 'Agent kind', color: 'violet' })
+export const ScriptResourceLanguageSchema = z.enum(['shell', 'sql', 'typescript', 'python']).meta({ label: 'Language' })
+export const CodeReferenceRoleSchema = z
+  .enum(['entrypoint', 'handler', 'schema', 'test', 'docs', 'config'])
+  .meta({ label: 'Code reference role', color: 'blue' })
+
+export const ResourceIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(255)
+  .regex(/^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*$/, 'Resource IDs must use letters, numbers, -, _, or . separators')
+
+export const EventIdSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(300)
+  .regex(
+    /^[A-Za-z0-9]+(?:[-._][A-Za-z0-9]+)*:[a-z0-9]+(?:[-._][a-z0-9]+)*$/,
+    'Event IDs must use <owner-id>:<event-key>'
+  )
+
+export const EventKeySchema = ModelIdSchema
+
+export const EventEmissionDescriptorSchema = z.object({
+  eventKey: EventKeySchema,
+  label: z.string().trim().min(1).max(120),
+  payloadSchema: ModelIdSchema.optional(),
+  lifecycle: SystemLifecycleSchema.optional()
+})
+
 export const EventDescriptorSchema = EventEmissionDescriptorSchema.extend({
   id: EventIdSchema,
   ownerId: z.union([ResourceIdSchema, ModelIdSchema]),
@@ -64,7 +119,22 @@ export const ResourceOntologyBindingSchema = z
     reads: z.array(OntologyIdSchema).optional(),
     writes: z.array(OntologyIdSchema).optional(),
     usesCatalogs: z.array(OntologyIdSchema).optional(),
-    emits: z.array(OntologyIdSchema).optional()
+    emits: z.array(OntologyIdSchema).optional(),
+    /**
+     * 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).
+     *
+     * 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).
+     * Tier-2 validation (om:verify): intra-package typed-map resolution asserts ZodType.
+     */
+    contract: z
+      .object({
+        input: ContractRefSchema.optional(),
+        output: ContractRefSchema.optional()
+      })
+      .optional()
   })
   .superRefine((binding, ctx) => {
     if (binding.primaryAction === undefined) return
@@ -89,29 +159,29 @@ type ResourceOntologyBindingInput = {
 
 export const CodeReferenceSchema = z.object({
   path: z
-    .string()
-    .trim()
-    .min(1)
-    .max(500)
-    .regex(/^[A-Za-z0-9_./$@()[\] -]+$/, 'Code reference paths must be repo-relative paths'),
-  role: CodeReferenceRoleSchema,
-  symbol: z.string().trim().min(1).max(200).optional(),
-  description: z.string().trim().min(1).max(300).optional()
-})
-
-const ResourceEntryBaseSchema = z.object({
-  /** Canonical resource id; runtime resourceId derives from this value. */
-  id: ResourceIdSchema,
-  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
-  order: z.number().default(0),
-  /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
+    .string()
+    .trim()
+    .min(1)
+    .max(500)
+    .regex(/^[A-Za-z0-9_./$@()[\] -]+$/, 'Code reference paths must be repo-relative paths'),
+  role: CodeReferenceRoleSchema,
+  symbol: z.string().trim().min(1).max(200).optional(),
+  description: z.string().trim().min(1).max(300).optional()
+})
+
+const ResourceEntryBaseSchema = z.object({
+  /** Canonical resource id; runtime resourceId derives from this value. */
+  id: ResourceIdSchema,
+  /** Domain-map iteration order. Convention: multiples of 10 (10, 20, 30, ...) to allow easy insertion. */
+  order: z.number().default(0),
+  /** Required single System membership — value is a dot-separated system path (e.g. "sales.lead-gen"). */
   systemPath: SystemPathSchema.meta({ ref: 'system' }),
   /** Executable display title owned by the OM Resource descriptor. */
   title: LabelSchema.optional(),
   /** Executable display description owned by the OM Resource descriptor. */
   description: DescriptionSchema.optional(),
-  /** Optional role responsible for maintaining this resource. */
-  ownerRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
+  /** Optional role responsible for maintaining this resource. */
+  ownerRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
   status: ResourceGovernanceStatusSchema,
   /**
    * Ontology contract bindings for the semantic work this resource performs.
@@ -122,68 +192,68 @@ const ResourceEntryBaseSchema = z.object({
   /** Repo-relative implementation breadcrumbs for agents and operators. */
   codeRefs: z.array(CodeReferenceSchema).default([])
 })
-
+
 export const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
   kind: z.literal('workflow'),
   emits: z.array(EventEmissionDescriptorSchema).optional()
 })
-
-export const AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('agent'),
-  /** Mirrors code-side AgentConfig.kind. */
-  agentKind: AgentKindSchema,
-  /** Role this agent embodies, if any. */
-  actsAsRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
-  /** Mirrors AgentConfig.sessionCapable. */
-  sessionCapable: z.boolean(),
-  /** Broad/composite callable entry points orchestrated by this agent. */
-  invocations: z.array(ActionInvocationSchema).default([]),
-  emits: z.array(EventEmissionDescriptorSchema).optional()
-})
-
-export const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('integration'),
-  provider: z.string().trim().min(1).max(100)
-})
-
-export const ScriptResourceSourceSchema = z.union([
-  z.string().trim().min(1).max(50_000),
-  z.object({
-    file: z.string().trim().min(1).max(500)
-  })
-])
-
-export const ScriptResourceEntrySchema = ResourceEntryBaseSchema.extend({
-  kind: z.literal('script'),
-  language: ScriptResourceLanguageSchema,
-  source: ScriptResourceSourceSchema
-})
-
-export const ResourceEntrySchema = z.discriminatedUnion('kind', [
-  WorkflowResourceEntrySchema,
-  AgentResourceEntrySchema,
-  IntegrationResourceEntrySchema,
-  ScriptResourceEntrySchema
-])
-
-export const ResourcesDomainSchema = z
-  .record(z.string(), ResourceEntrySchema)
-  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
-    message: 'Each resource entry id must match its map key'
-  })
-  .default({})
-
-export const DEFAULT_ORGANIZATION_MODEL_RESOURCES: z.infer<typeof ResourcesDomainSchema> = {}
-
-export function defineResource<const TResource extends ResourceEntry>(resource: TResource): TResource {
-  return ResourceEntrySchema.parse(resource) as TResource
-}
-
+
+export const AgentResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('agent'),
+  /** Mirrors code-side AgentConfig.kind. */
+  agentKind: AgentKindSchema,
+  /** Role this agent embodies, if any. */
+  actsAsRoleId: ModelIdSchema.meta({ ref: 'role' }).optional(),
+  /** Mirrors AgentConfig.sessionCapable. */
+  sessionCapable: z.boolean(),
+  /** Broad/composite callable entry points orchestrated by this agent. */
+  invocations: z.array(ActionInvocationSchema).default([]),
+  emits: z.array(EventEmissionDescriptorSchema).optional()
+})
+
+export const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('integration'),
+  provider: z.string().trim().min(1).max(100)
+})
+
+export const ScriptResourceSourceSchema = z.union([
+  z.string().trim().min(1).max(50_000),
+  z.object({
+    file: z.string().trim().min(1).max(500)
+  })
+])
+
+export const ScriptResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('script'),
+  language: ScriptResourceLanguageSchema,
+  source: ScriptResourceSourceSchema
+})
+
+export const ResourceEntrySchema = z.discriminatedUnion('kind', [
+  WorkflowResourceEntrySchema,
+  AgentResourceEntrySchema,
+  IntegrationResourceEntrySchema,
+  ScriptResourceEntrySchema
+])
+
+export const ResourcesDomainSchema = z
+  .record(z.string(), ResourceEntrySchema)
+  .refine((record) => Object.entries(record).every(([key, entry]) => entry.id === key), {
+    message: 'Each resource entry id must match its map key'
+  })
+  .default({})
+
+export const DEFAULT_ORGANIZATION_MODEL_RESOURCES: z.infer<typeof ResourcesDomainSchema> = {}
+
+export function defineResource<const TResource extends ResourceEntry>(resource: TResource): TResource {
+  return ResourceEntrySchema.parse(resource) as TResource
+}
+
 export function defineResources<const TResources extends Record<string, ResourceEntry>>(
   resources: TResources
 ): TResources {
-  return Object.fromEntries(
-    Object.entries(resources).map(([key, resource]) => [key, ResourceEntrySchema.parse(resource)])
+  return Object.fromEntries(
+    Object.entries(resources).map(([key, resource]) => [key, ResourceEntrySchema.parse(resource)])
   ) as TResources
 }
 
@@ -205,19 +275,20 @@ export function defineResourceOntology(input: ResourceOntologyBindingInput): Res
     emits: ontologyIdArrayFrom(input.emits)
   })
 }
-
-export type ResourceId = z.infer<typeof ResourceIdSchema>
-export type ResourceKind = z.infer<typeof ResourceKindSchema>
-export type ResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>
-export type ResourceAgentKind = z.infer<typeof AgentKindSchema>
+
+export type ResourceId = z.infer<typeof ResourceIdSchema>
+export type ResourceKind = z.infer<typeof ResourceKindSchema>
+export type ResourceGovernanceStatus = z.infer<typeof ResourceGovernanceStatusSchema>
+export type ResourceAgentKind = z.infer<typeof AgentKindSchema>
 export type CodeReferenceRole = z.infer<typeof CodeReferenceRoleSchema>
 export type ResourceOntologyBinding = z.infer<typeof ResourceOntologyBindingSchema>
+export type ResourceOntologyBindingContract = NonNullable<ResourceOntologyBinding['contract']>
 export type CodeReference = z.infer<typeof CodeReferenceSchema>
-export type ScriptResourceLanguage = z.infer<typeof ScriptResourceLanguageSchema>
-export type ScriptResourceSource = z.infer<typeof ScriptResourceSourceSchema>
-export type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
-export type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
-export type IntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
-export type ScriptResourceEntry = z.infer<typeof ScriptResourceEntrySchema>
-export type ResourceEntry = z.infer<typeof ResourceEntrySchema>
-export type ResourcesDomain = z.infer<typeof ResourcesDomainSchema>
+export type ScriptResourceLanguage = z.infer<typeof ScriptResourceLanguageSchema>
+export type ScriptResourceSource = z.infer<typeof ScriptResourceSourceSchema>
+export type WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
+export type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
+export type IntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+export type ScriptResourceEntry = z.infer<typeof ScriptResourceEntrySchema>
+export type ResourceEntry = z.infer<typeof ResourceEntrySchema>
+export type ResourcesDomain = z.infer<typeof ResourcesDomainSchema>

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

@@ -1,12 +1,12 @@
 import { z } from 'zod'
 import { DescriptionSchema, DisplayMetadataSchema, ModelIdSchema, ReferenceIdsSchema } from './shared'
 
-export { LEAD_GEN_STAGE_CATALOG, type LeadGenStageCatalogEntry } from '../catalogs/lead-gen'
+export type { LeadGenStageCatalogEntry } from '../catalogs/lead-gen'
 
-// Phase 4 cut: OrganizationModelSalesSchema and DEFAULT_ORGANIZATION_MODEL_SALES removed.
-// Pipeline/stage data moved into system.content as (schema:pipeline) and (schema:stage)
-// content nodes on the owning system (e.g. sales.crm). Use getAllPipelines() /
-// getStagesInPipeline() from migration-helpers to read pipeline data portably.
+// OrganizationModelSalesSchema and DEFAULT_ORGANIZATION_MODEL_SALES are retired.
+// Pipeline/stage data lives in System.ontology.catalogTypes on the owning system
+// (e.g. sales.crm). Use getAllPipelines() / getStagesInPipeline() from
+// migration-helpers to read pipeline data portably.
 //
 // SalesStageSemanticClassSchema, SalesStageSchema, SalesPipelineSchema are retained
 // below as TypeScript types used by CRM business logic and the Stateful pipeline definitions.

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

@@ -9,7 +9,6 @@ import {
   PathSchema,
   ReferenceIdsSchema
 } from './shared'
-import { ContentNodeSchema } from '../content-kinds/types'
 import { OntologyScopeSchema, type OntologyScope } from '../ontology'
 
 // ---------------------------------------------------------------------------
@@ -48,12 +47,11 @@ export const NodeIdStringSchema = z
   .trim()
   .min(1)
   .max(200)
-  // D4: kind prefix allows hyphens (e.g. 'content-node'); id allows colons for
-  // qualified content-node references ('content-node:sales.crm:default-pipeline').
+  // Kind prefix allows hyphens; id allows scoped references such as ontology targets.
   .regex(
     /^[a-z][a-z-]*:([a-z0-9-]+)(\.[a-z0-9-]+)*(:[a-z0-9.-]+)*$/,
-    'Node references must use kind:dotted-path (e.g. system:sales.crm or content-node:sales.crm:pipeline-id)'
-  )
+    'Node references must use kind:dotted-path (e.g. system:sales.crm or resource:lead-gen.company.qualify)'
+  )
 
 export const SystemUiSchema = z.object({
   path: PathSchema,
@@ -72,8 +70,6 @@ export const SystemUiSchema = z.object({
 //      the declared interface instead of trying to infer through the cycle.
 // ---------------------------------------------------------------------------
 
-import type { ContentNode } from '../content-kinds/types'
-
 export type JsonPrimitive = string | number | boolean | null
 export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue }
 
@@ -121,16 +117,11 @@ export interface SystemEntry {
   config?: Record<string, JsonValue>
   ontology?: OntologyScope
   systems?: Record<string, SystemEntry>
-  /**
-   * @deprecated Compatibility-only bridge for old tenant data and migration readers.
-   * Author new semantic catalogs in `ontology` and local settings in `config`.
-   */
-  content?: Record<string, ContentNode>
   subsystems?: Record<string, SystemEntry>
 }
 
-export const SystemEntrySchema: ZodType<SystemEntry> = z
-  .object({
+export const SystemEntrySchema: ZodType<SystemEntry> = z
+  .object({
     /** Stable tenant-defined system id (e.g. "sys.lead-gen" or "sales.crm"). */
     id: SystemIdSchema,
     /** Human-readable system label shown in UI, governance, and operations surfaces. */
@@ -195,14 +186,7 @@ export const SystemEntrySchema: ZodType<SystemEntry> = z
      */
     ontology: OntologyScopeSchema.optional(),
     /**
-     * @deprecated Compatibility-only bridge for old tenant content nodes and
-     * migration readers. New schema/catalog authoring belongs in ontology;
-     * new system-local settings belong in config. Bridge nodes are keyed by
-     * local NodeId and may still project to content-node:* graph IDs.
-     */
-    content: z.record(z.string().trim().min(1).max(200), ContentNodeSchema).optional(),
-    /**
-     * Recursive child systems, authored via nesting (per L11).
+     * Recursive child systems, authored via nesting (per L11).
      * The key is the local system id; the full path is computed by joining
      * ancestor keys with `.` (e.g. parent key `'sales'` + child key `'crm'` → `'sales.crm'`).
      * Per Phase 4: `id` and `parentSystemId` fields will be removed in favour of
@@ -212,7 +196,8 @@ export const SystemEntrySchema: ZodType<SystemEntry> = z
     /** @deprecated Use systems. Accepted as a compatibility alias during the ontology bridge. */
     subsystems: z.lazy(() => z.record(z.string().trim().min(1).max(100), SystemEntrySchema)).optional()
   })
-  .refine((system: SystemEntry) => system.label !== undefined || system.title !== undefined, {
+  .strict()
+  .refine((system: SystemEntry) => system.label !== undefined || system.title !== undefined, {
     path: ['label'],
     message: 'System must provide label or title'
   })