@elevasis/core 0.5.0 → 0.7.0

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

@@ -0,0 +1,80 @@
+import { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Measurable outcome schema — one trackable result that supports a goal.
+// The field name `keyResults` is used for compatibility with OKR tooling;
+// user-facing surfaces and documentation MUST say "measurable outcomes",
+// never "key results" or "OKR".
+// ---------------------------------------------------------------------------
+
+export const KeyResultSchema = z.object({
+  /** Stable unique identifier for the measurable outcome (e.g. "kr-revenue-q1"). */
+  id: z.string().trim().min(1).max(100),
+  /** Plain-language description of this measurable outcome (e.g. "Increase trial-to-paid conversion"). */
+  description: z.string().trim().min(1).max(500),
+  /**
+   * What is being measured — the metric name (e.g. "monthly revenue", "NPS score",
+   * "trial-to-paid conversion rate"). Free-form string.
+   */
+  targetMetric: z.string().trim().min(1).max(200),
+  /** Current measured value. Defaults to 0 when not yet tracked. */
+  currentValue: z.number().default(0),
+  /**
+   * Target value to reach for this measurable outcome to be considered achieved.
+   * Optional — omit if the outcome is directional (e.g. "reduce churn") without
+   * a hard numeric target.
+   */
+  targetValue: z.number().optional()
+})
+
+// ---------------------------------------------------------------------------
+// Objective schema — one goal the organization is working toward.
+// User-facing label is "goal"; this schema type is named Objective for
+// structural continuity with OKR tooling. Do NOT expose "OKR", "objective",
+// or "key result" in any user-facing label or documentation.
+//
+// Period fields use ISO 8601 date strings (YYYY-MM-DD). Cross-schema
+// validation (periodEnd > periodStart) is enforced in
+// `OrganizationModelSchema.superRefine()`.
+// ---------------------------------------------------------------------------
+
+const ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/
+
+export const ObjectiveSchema = z.object({
+  /** Stable unique identifier for the goal (e.g. "goal-grow-arr-q1-2026"). */
+  id: z.string().trim().min(1).max(100),
+  /** Plain-language description of what the organization wants to achieve. */
+  description: z.string().trim().min(1).max(1000),
+  /**
+   * Start of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly before `periodEnd`.
+   */
+  periodStart: z.string().regex(ISO_DATE_REGEX, 'periodStart must be an ISO date string (YYYY-MM-DD)'),
+  /**
+   * End of the period this goal is active for — ISO 8601 date string (YYYY-MM-DD).
+   * Must be strictly after `periodStart`.
+   * Enforced via `OrganizationModelSchema.superRefine()`.
+   */
+  periodEnd: z.string().regex(ISO_DATE_REGEX, 'periodEnd must be an ISO date string (YYYY-MM-DD)'),
+  /**
+   * List of measurable outcomes that define success for this goal.
+   * Defaults to empty array so goals can be declared before outcomes are defined.
+   */
+  keyResults: z.array(KeyResultSchema).default([])
+})
+
+// ---------------------------------------------------------------------------
+// Goals domain schema — a collection of goals the organization is pursuing.
+// ---------------------------------------------------------------------------
+
+export const GoalsDomainSchema = z.object({
+  objectives: z.array(ObjectiveSchema).default([])
+})
+
+// ---------------------------------------------------------------------------
+// Seed — empty by default; adapters populate with real goal definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_GOALS: z.infer<typeof GoalsDomainSchema> = {
+  objectives: []
+}

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

@@ -0,0 +1,94 @@
+import { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Business hours — simplest shape that captures weekday ranges.
+// Each day of the week is optional; when present it holds open/close times
+// in "HH:MM" 24-hour format. An empty object (default) means "not configured".
+// ---------------------------------------------------------------------------
+
+export const BusinessHoursDaySchema = z.object({
+  open: z
+    .string()
+    .trim()
+    .regex(/^\d{2}:\d{2}$/, 'Expected HH:MM format'),
+  close: z
+    .string()
+    .trim()
+    .regex(/^\d{2}:\d{2}$/, 'Expected HH:MM format')
+})
+
+export const BusinessHoursSchema = z
+  .object({
+    monday: BusinessHoursDaySchema.optional(),
+    tuesday: BusinessHoursDaySchema.optional(),
+    wednesday: BusinessHoursDaySchema.optional(),
+    thursday: BusinessHoursDaySchema.optional(),
+    friday: BusinessHoursDaySchema.optional(),
+    saturday: BusinessHoursDaySchema.optional(),
+    sunday: BusinessHoursDaySchema.optional()
+  })
+  .default({})
+
+// ---------------------------------------------------------------------------
+// Identity domain schema — legal identity, mission/vision, industry anchors,
+// and temporal/geographic context. Distinct from branding (display identity).
+// ---------------------------------------------------------------------------
+
+export const IdentityDomainSchema = z.object({
+  /** Why the organization exists — one or two plain-language sentences. */
+  mission: z.string().trim().max(1000).default(''),
+  /** Long-term direction the organization is moving toward. */
+  vision: z.string().trim().max(1000).default(''),
+  /** Legal registered name of the entity. */
+  legalName: z.string().trim().max(200).default(''),
+  /**
+   * Type of legal entity (e.g. "LLC", "Corporation", "Sole Proprietor",
+   * "Non-profit"). Free-form string so it covers any jurisdiction.
+   */
+  entityType: z.string().trim().max(100).default(''),
+  /**
+   * Primary jurisdiction of registration or operation
+   * (e.g. "United States – Delaware", "Canada – Ontario").
+   */
+  jurisdiction: z.string().trim().max(200).default(''),
+  /**
+   * Industry category — broad classification (e.g. "Marketing Agency",
+   * "Software / SaaS", "Professional Services").
+   */
+  industryCategory: z.string().trim().max(200).default(''),
+  /**
+   * Geographic focus — where the organization primarily operates or serves
+   * (e.g. "North America", "Global", "Southeast Asia").
+   */
+  geographicFocus: z.string().trim().max(200).default(''),
+  /**
+   * IANA timezone identifier for the organization's primary operating timezone
+   * (e.g. "America/Los_Angeles", "Europe/London", "UTC").
+   */
+  timeZone: z.string().trim().max(100).default('UTC'),
+  /** Typical operating hours per day of week. Empty object means not configured. */
+  businessHours: BusinessHoursSchema,
+  /**
+   * Long-form markdown capturing client context, problem narrative, and domain
+   * background. Populated by /setup; surfaced to agents as organizational context.
+   * Optional — many projects have no external client.
+   */
+  clientBrief: z.string().trim().default('')
+})
+
+// ---------------------------------------------------------------------------
+// Seed — placeholder defaults; external adapters override per organization.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_IDENTITY: z.infer<typeof IdentityDomainSchema> = {
+  mission: '',
+  vision: '',
+  legalName: '',
+  entityType: '',
+  jurisdiction: '',
+  industryCategory: '',
+  geographicFocus: '',
+  timeZone: 'UTC',
+  businessHours: {},
+  clientBrief: ''
+}

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

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { DELIVERY_PROJECTS_VIEW_CAPABILITY_ID, PROJECTS_FEATURE_ID, PROJECTS_INDEX_SURFACE_ID } from '../contracts'
+import { PROJECTS_VIEW_CAPABILITY_ID, PROJECTS_FEATURE_ID, PROJECTS_INDEX_SURFACE_ID } from '../contracts'
 import { DescriptionSchema, IconNameSchema, LabelSchema, ModelIdSchema, PathSchema, ReferenceIdsSchema } from './shared'
 
 export const SurfaceTypeSchema = z.enum(['page', 'dashboard', 'graph', 'detail', 'list', 'settings'])
@@ -20,10 +20,23 @@ export const SurfaceDefinitionSchema = z.object({
   parentId: ModelIdSchema.optional()
 })
 
+/**
+ * Core placement values: 'primary' | 'secondary' | 'bottom'.
+ *
+ * `placement` is intentionally open (`z.string()`) so that per-project adapters can
+ * introduce additional placement IDs (e.g. 'pinned', 'spotlight', 'contextual') without
+ * forking core. Extension pattern: add the new string literal to the project's
+ * `foundations/config/organization-model.ts` adapter — no changes to this file required.
+ *
+ * `surfaceType` and `resourceType` remain closed enums (UI/runtime invariants).
+ */
+export const CORE_PLACEMENT_VALUES = ['primary', 'secondary', 'bottom'] as const
+export type CorePlacement = (typeof CORE_PLACEMENT_VALUES)[number]
+
 export const NavigationGroupSchema = z.object({
   id: ModelIdSchema,
   label: LabelSchema,
-  placement: z.enum(['primary', 'secondary', 'bottom']),
+  placement: z.string().trim().min(1).max(50),
   surfaceIds: z.array(ModelIdSchema).default([])
 })
 
@@ -70,7 +83,7 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
       featureIds: [PROJECTS_FEATURE_ID],
       entityIds: ['delivery.project'],
       resourceIds: [],
-      capabilityIds: [DELIVERY_PROJECTS_VIEW_CAPABILITY_ID]
+      capabilityIds: [PROJECTS_VIEW_CAPABILITY_ID]
     },
     {
       id: 'operations.organization-graph',
@@ -216,6 +229,30 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
       resourceIds: [],
       capabilityIds: []
     },
+    {
+      id: 'submitted-requests.list',
+      label: 'Submitted Requests',
+      path: '/monitoring/requests',
+      surfaceType: 'list',
+      enabled: true,
+      featureId: 'submitted-requests',
+      featureIds: ['submitted-requests'],
+      entityIds: ['reported_request'],
+      resourceIds: [],
+      capabilityIds: []
+    },
+    {
+      id: 'submitted-requests.detail',
+      label: 'Request Detail',
+      path: '/monitoring/requests/:requestId',
+      surfaceType: 'detail',
+      enabled: true,
+      featureId: 'submitted-requests',
+      featureIds: ['submitted-requests'],
+      entityIds: ['reported_request'],
+      resourceIds: [],
+      capabilityIds: []
+    },
     {
       id: 'settings.account',
       label: 'Account',
@@ -331,7 +368,9 @@ export const DEFAULT_ORGANIZATION_MODEL_NAVIGATION: z.infer<typeof OrganizationM
         'monitoring.execution-logs',
         'monitoring.execution-health',
         'monitoring.cost-analytics',
-        'monitoring.notifications'
+        'monitoring.notifications',
+        'submitted-requests.list',
+        'submitted-requests.detail'
       ]
     },
     {

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

@@ -0,0 +1,66 @@
+import { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Pricing model — the four canonical pricing structures used in B2B SaaS and
+// professional services. "custom" covers bespoke / negotiated pricing.
+// ---------------------------------------------------------------------------
+
+export const PricingModelSchema = z.enum(['one-time', 'subscription', 'usage-based', 'custom'])
+
+// ---------------------------------------------------------------------------
+// Product schema — one entry per distinct offering (product or service).
+// Modeled after Business Model Canvas "Value Propositions" and company profile
+// product/service catalog language. Fields use plain English throughout.
+// ---------------------------------------------------------------------------
+
+export const ProductSchema = z.object({
+  /** Stable unique identifier for the product (e.g. "product-starter-plan"). */
+  id: z.string().trim().min(1).max(100),
+  /** Human-readable name shown to agents and in UI (e.g. "Starter Plan"). */
+  name: z.string().trim().max(200).default(''),
+  /** One or two sentences describing what this product/service delivers. */
+  description: z.string().trim().max(2000).default(''),
+  /**
+   * How this product is priced:
+   * - "one-time" — single purchase (setup fee, project fee)
+   * - "subscription" — recurring (monthly/annual SaaS, retainer)
+   * - "usage-based" — metered by consumption (API calls, seats)
+   * - "custom" — negotiated or bespoke pricing
+   */
+  pricingModel: PricingModelSchema.default('custom'),
+  /** Base price amount (≥ 0). Currency unit defined by `currency`. */
+  price: z.number().min(0).default(0),
+  /**
+   * ISO 4217 currency code (e.g. "USD", "EUR", "GBP").
+   * Free-form string to accommodate any currency; defaults to "USD".
+   */
+  currency: z.string().trim().max(10).default('USD'),
+  /**
+   * IDs of customer segments this product targets.
+   * Each id must reference a declared `customers.segments[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  targetSegmentIds: z.array(z.string().trim().min(1)).default([]),
+  /**
+   * Optional: ID of the platform feature responsible for delivering this product.
+   * When present, must reference a declared `features[].id`.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  deliveryFeatureId: z.string().trim().min(1).optional()
+})
+
+// ---------------------------------------------------------------------------
+// Offerings domain schema — a collection of products and services.
+// ---------------------------------------------------------------------------
+
+export const OfferingsDomainSchema = z.object({
+  products: z.array(ProductSchema).default([])
+})
+
+// ---------------------------------------------------------------------------
+// Seed — empty by default; adapters populate with real product definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_OFFERINGS: z.infer<typeof OfferingsDomainSchema> = {
+  products: []
+}

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

@@ -0,0 +1,85 @@
+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']
+    }
+  ]
+}

package/src/organization-model/domains/{delivery.ts → projects.ts}

@@ -1,21 +1,21 @@
 import { z } from 'zod'
 import { DisplayMetadataSchema, ModelIdSchema } from './shared'
 
-export const DeliveryStateSchema = DisplayMetadataSchema.extend({
+export const ProjectsDomainStateSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   order: z.number().int().min(0)
 })
 
-export const OrganizationModelDeliverySchema = z.object({
+export const OrganizationModelProjectsSchema = z.object({
   projectEntityId: ModelIdSchema,
   milestoneEntityId: ModelIdSchema,
   taskEntityId: ModelIdSchema,
-  projectStatuses: z.array(DeliveryStateSchema).min(1),
-  milestoneStatuses: z.array(DeliveryStateSchema).min(1),
-  taskStatuses: z.array(DeliveryStateSchema).min(1)
+  projectStatuses: z.array(ProjectsDomainStateSchema).min(1),
+  milestoneStatuses: z.array(ProjectsDomainStateSchema).min(1),
+  taskStatuses: z.array(ProjectsDomainStateSchema).min(1)
 })
 
-export const DEFAULT_ORGANIZATION_MODEL_DELIVERY: z.infer<typeof OrganizationModelDeliverySchema> = {
+export const DEFAULT_ORGANIZATION_MODEL_PROJECTS: z.infer<typeof OrganizationModelProjectsSchema> = {
   projectEntityId: 'delivery.project',
   milestoneEntityId: 'delivery.milestone',
   taskEntityId: 'delivery.task',

package/src/organization-model/domains/{lead-gen.ts → prospecting.ts}

@@ -1,21 +1,21 @@
 import { z } from 'zod'
 import { DescriptionSchema, DisplayMetadataSchema, ModelIdSchema } from './shared'
 
-export const LeadGenLifecycleStageSchema = DisplayMetadataSchema.extend({
+export const ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   order: z.number().int().min(0)
 })
 
-export const OrganizationModelLeadGenSchema = z.object({
+export const OrganizationModelProspectingSchema = z.object({
   listEntityId: ModelIdSchema,
   companyEntityId: ModelIdSchema,
   contactEntityId: ModelIdSchema,
   description: DescriptionSchema.optional(),
-  companyStages: z.array(LeadGenLifecycleStageSchema).min(1),
-  contactStages: z.array(LeadGenLifecycleStageSchema).min(1)
+  companyStages: z.array(ProspectingLifecycleStageSchema).min(1),
+  contactStages: z.array(ProspectingLifecycleStageSchema).min(1)
 })
 
-export const DEFAULT_ORGANIZATION_MODEL_LEAD_GEN: z.infer<typeof OrganizationModelLeadGenSchema> = {
+export const DEFAULT_ORGANIZATION_MODEL_PROSPECTING: z.infer<typeof OrganizationModelProspectingSchema> = {
   listEntityId: 'leadgen.list',
   companyEntityId: 'leadgen.company',
   contactEntityId: 'leadgen.contact',

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

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Role schema — one entry per distinct role in the organization's chart.
+// Inspired by the EOS Accountability Chart but uses plain-language field names
+// throughout. No EOS jargon: "title" (not seatTitle), "responsibilities"
+// (not accountabilities), "reportsToId", "heldBy".
+//
+// Cross-reference: `reportsToId` (when present) must resolve to another
+// `roles[].id` in the same collection. Enforcement is via
+// `OrganizationModelSchema.superRefine()` — not at the individual schema level.
+// Cycle detection is NOT enforced (known limitation; document if needed).
+// ---------------------------------------------------------------------------
+
+export const RoleSchema = z.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: z.string().trim().min(1).max(100),
+  /** Human-readable title shown to agents and in UI (e.g. "CEO", "Head of Sales"). */
+  title: z.string().trim().min(1).max(200),
+  /**
+   * List of responsibilities this role owns — plain-language descriptions of
+   * what the person in this role is accountable for delivering.
+   * Defaults to empty array so minimal role definitions stay concise.
+   */
+  responsibilities: z.array(z.string().trim().max(500)).default([]),
+  /**
+   * Optional: ID of another role this role reports to.
+   * When present, must reference another `roles[].id` in the same organization.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   * Absence indicates a top-level role (no reporting line).
+   */
+  reportsToId: z.string().trim().min(1).max(100).optional(),
+  /**
+   * Optional: name or email of the person currently holding this role.
+   * Free-form string — supports "Alice Johnson", "alice@example.com", or
+   * any human-readable identifier. Not validated against any user registry.
+   */
+  heldBy: z.string().trim().max(200).optional()
+})
+
+// ---------------------------------------------------------------------------
+// Roles domain schema — a collection of roles.
+// ---------------------------------------------------------------------------
+
+export const RolesDomainSchema = z.object({
+  roles: z.array(RoleSchema).default([])
+})
+
+// ---------------------------------------------------------------------------
+// Seed — empty by default; adapters populate with real role definitions.
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_ORGANIZATION_MODEL_ROLES: z.infer<typeof RolesDomainSchema> = {
+  roles: []
+}

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

@@ -0,0 +1,94 @@
+import { z } from 'zod'
+import { DescriptionSchema, DisplayMetadataSchema, ModelIdSchema, ReferenceIdsSchema } from './shared'
+
+export const SalesStageSemanticClassSchema = z.enum(['open', 'active', 'nurturing', 'closed_won', 'closed_lost'])
+
+export const SalesStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().int().min(0),
+  semanticClass: SalesStageSemanticClassSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema
+})
+
+export const SalesPipelineSchema = z.object({
+  id: ModelIdSchema,
+  label: z.string().trim().min(1).max(120),
+  description: DescriptionSchema.optional(),
+  entityId: ModelIdSchema,
+  stages: z.array(SalesStageSchema).min(1)
+})
+
+export const OrganizationModelSalesSchema = z.object({
+  entityId: ModelIdSchema,
+  defaultPipelineId: ModelIdSchema,
+  pipelines: z.array(SalesPipelineSchema).min(1)
+})
+
+export const DEFAULT_ORGANIZATION_MODEL_SALES: z.infer<typeof OrganizationModelSalesSchema> = {
+  entityId: 'crm.deal',
+  defaultPipelineId: 'default',
+  pipelines: [
+    {
+      id: 'default',
+      label: 'Default Pipeline',
+      entityId: 'crm.deal',
+      stages: [
+        {
+          id: 'interested',
+          label: 'Interested',
+          color: 'blue',
+          order: 1,
+          semanticClass: 'open',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        },
+        {
+          id: 'proposal',
+          label: 'Proposal',
+          color: 'yellow',
+          order: 2,
+          semanticClass: 'active',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        },
+        {
+          id: 'closing',
+          label: 'Closing',
+          color: 'lime',
+          order: 3,
+          semanticClass: 'active',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        },
+        {
+          id: 'closed_won',
+          label: 'Closed Won',
+          color: 'green',
+          order: 4,
+          semanticClass: 'closed_won',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        },
+        {
+          id: 'closed_lost',
+          label: 'Closed Lost',
+          color: 'red',
+          order: 5,
+          semanticClass: 'closed_lost',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        },
+        {
+          id: 'nurturing',
+          label: 'Nurturing',
+          color: 'grape',
+          order: 6,
+          semanticClass: 'nurturing',
+          surfaceIds: ['crm.pipeline'],
+          resourceIds: []
+        }
+      ]
+    }
+  ]
+}

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

@@ -22,6 +22,33 @@ export const DisplayMetadataSchema = z.object({
   icon: IconNameSchema.optional()
 })
 
+// ---------------------------------------------------------------------------
+// TechStack subsection — optional extension on a ResourceMapping entry that
+// captures external-SaaS integration metadata: which platform, its purpose,
+// credential health, and whether it is the system of record for its domain.
+// Backward-compatible: existing entries without this key parse cleanly.
+// ---------------------------------------------------------------------------
+
+export const TechStackEntrySchema = z.object({
+  /** Name of the external platform (e.g. "HubSpot", "Stripe", "Notion"). */
+  platform: z.string().trim().min(1).max(200),
+  /** Free-form description of what this integration is used for. */
+  purpose: z.string().trim().min(1).max(500),
+  /**
+   * Health of the credential backing this integration.
+   * - configured: credential present and valid
+   * - pending: not yet set up
+   * - expired: credential existed but has lapsed
+   * - missing: expected but not present
+   */
+  credentialStatus: z.enum(['configured', 'pending', 'expired', 'missing']),
+  /**
+   * Whether this integration is the primary system of record for its domain
+   * (e.g. HubSpot is SoR for contacts). Defaults to false.
+   */
+  isSystemOfRecord: z.boolean().default(false)
+})
+
 export const ResourceMappingSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
   resourceId: z.string().trim().min(1).max(255),
@@ -29,5 +56,7 @@ export const ResourceMappingSchema = DisplayMetadataSchema.extend({
   featureIds: ReferenceIdsSchema,
   entityIds: ReferenceIdsSchema,
   surfaceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema
+  capabilityIds: ReferenceIdsSchema,
+  /** Optional tech-stack metadata for external-SaaS integrations. */
+  techStack: TechStackEntrySchema.optional()
 })