@elevasis/core 0.20.0 → 0.22.0

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

@@ -4,7 +4,36 @@ import { DescriptionSchema, DisplayMetadataSchema, ModelIdSchema } from './share
 
 export const ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
   id: ModelIdSchema,
-  order: z.number().int().min(0)
+  order: z.number().min(0)
+})
+
+export const RecordColumnConfigSchema = z.object({
+  key: ModelIdSchema,
+  label: z.string().trim().min(1).max(120),
+  path: z.string().trim().min(1).max(500),
+  width: z.union([z.number().positive(), z.string().trim().min(1).max(100)]).optional(),
+  renderType: z.enum(['text', 'badge', 'datetime', 'count', 'json']).optional(),
+  badgeColor: z.string().trim().min(1).max(40).optional()
+})
+
+export const RecordColumnsConfigSchema = z
+  .object({
+    company: z.array(RecordColumnConfigSchema).optional(),
+    contact: z.array(RecordColumnConfigSchema).optional()
+  })
+  .refine((columns) => Boolean(columns.company?.length || columns.contact?.length), {
+    message: 'recordColumns must include at least one entity column set'
+  })
+
+export const CredentialRequirementSchema = z.object({
+  key: ModelIdSchema,
+  provider: ModelIdSchema,
+  credentialType: z.enum(['api-key', 'api-key-secret', 'oauth', 'webhook-secret']),
+  label: z.string().trim().min(1).max(120),
+  required: z.boolean(),
+  selectionMode: z.enum(['single', 'multiple']).optional(),
+  inputPath: z.string().trim().min(1).max(500),
+  verifyOnRun: z.boolean().optional()
 })
 
 export const ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
@@ -12,11 +41,16 @@ export const ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
   primaryEntity: z.enum(['company', 'contact']),
   outputs: z.array(z.enum(['company', 'contact', 'export'])).min(1),
   stageKey: ModelIdSchema,
+  recordEntity: z.enum(['company', 'contact']).optional(),
+  recordsStageKey: ModelIdSchema.optional(),
+  recordSourceStageKey: ModelIdSchema.optional(),
   dependsOn: z.array(ModelIdSchema).optional(),
   dependencyMode: z.literal('per-record-eligibility'),
   capabilityKey: ModelIdSchema,
   defaultBatchSize: z.number().int().positive(),
-  maxBatchSize: z.number().int().positive()
+  maxBatchSize: z.number().int().positive(),
+  recordColumns: RecordColumnsConfigSchema.optional(),
+  credentialRequirements: z.array(CredentialRequirementSchema).optional()
 }).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
   message: 'defaultBatchSize must be less than or equal to maxBatchSize',
   path: ['defaultBatchSize']
@@ -28,9 +62,68 @@ export const ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
 })
 
 export type ListBuilderStep = z.infer<typeof ProspectingBuildTemplateStepSchema>
+export type RecordColumnConfig = z.infer<typeof RecordColumnConfigSchema>
+export type CredentialRequirement = z.infer<typeof CredentialRequirementSchema>
 export type TemplateName = 'localServices' | 'dtcApolloClickup'
 export type StepName = string
 
+const DTC_RECORD_COLUMNS = {
+  populated: {
+    company: [
+      { key: 'name', label: 'Company', path: 'company.name' },
+      { key: 'domain', label: 'Domain', path: 'company.domain' },
+      { key: 'employee-count', label: 'Employees', path: 'company.numEmployees', renderType: 'count' },
+      { key: 'apollo-industry', label: 'Apollo industry', path: 'company.category' },
+      { key: 'location', label: 'Location', path: 'company.locationState' }
+    ]
+  },
+  crawled: {
+    company: [
+      { key: 'name', label: 'Company', path: 'company.name' },
+      { key: 'domain', label: 'Domain', path: 'company.domain' },
+      { key: 'page-count', label: 'Pages', path: 'company.enrichmentData.websiteCrawl.pageCount', renderType: 'count' },
+      { key: 'crawl-status', label: 'Crawl status', path: 'processingState.crawled.status', renderType: 'badge' }
+    ]
+  },
+  extracted: {
+    company: [
+      { key: 'name', label: 'Company', path: 'company.name' },
+      { key: 'domain', label: 'Domain', path: 'company.domain' },
+      { key: 'description', label: 'Description', path: 'company.enrichmentData.websiteCrawl.companyDescription' },
+      { key: 'services', label: 'Services', path: 'company.enrichmentData.websiteCrawl.services', renderType: 'json' },
+      { key: 'automation-gaps', label: 'Automation gaps', path: 'company.enrichmentData.websiteCrawl.automationGaps', renderType: 'json' },
+      { key: 'contact-count', label: 'Contacts', path: 'company.enrichmentData.websiteCrawl.emailCount', renderType: 'count' }
+    ]
+  },
+  qualified: {
+    company: [
+      { key: 'name', label: 'Company', path: 'company.name' },
+      { key: 'domain', label: 'Domain', path: 'company.domain' },
+      { key: 'score', label: 'Score', path: 'company.qualificationScore', renderType: 'badge', badgeColor: 'green' },
+      { key: 'signals', label: 'Signals', path: 'company.qualificationSignals', renderType: 'json' },
+      { key: 'disqualified-reason', label: 'Disqualified reason', path: 'processingState.qualified.data.disqualifiedReason' }
+    ]
+  },
+  decisionMakers: {
+    contact: [
+      { key: 'name', label: 'Name', path: 'contact.name' },
+      { key: 'title', label: 'Title', path: 'contact.title' },
+      { key: 'email', label: 'Email', path: 'contact.email' },
+      { key: 'linkedin', label: 'LinkedIn', path: 'contact.linkedinUrl' },
+      { key: 'priority-score', label: 'Priority', path: 'contact.enrichmentData.apollo.priorityScore', renderType: 'badge' }
+    ]
+  },
+  uploaded: {
+    company: [
+      { key: 'name', label: 'Company', path: 'company.name' },
+      { key: 'domain', label: 'Domain', path: 'company.domain' },
+      { key: 'contacts', label: 'Contacts', path: 'company.enrichmentData.approvedLeadListExport.contacts', renderType: 'json' },
+      { key: 'score', label: 'Score', path: 'company.qualificationScore', renderType: 'badge', badgeColor: 'green' },
+      { key: 'approval', label: 'Approval', path: 'company.enrichmentData.approvedLeadListExport.approvalStatus', renderType: 'badge' }
+    ]
+  }
+} as const satisfies Record<string, z.infer<typeof RecordColumnsConfigSchema>>
+
 export const CapabilitySchema = z.object({
   id: ModelIdSchema,
   label: z.string(),
@@ -66,6 +159,13 @@ export const CAPABILITY_REGISTRY: CapabilityRegistry = [
     description: 'Check email deliverability before outreach.',
     resourceId: 'lgn-05-email-verification-workflow'
   },
+  {
+    id: 'lead-gen.company.apify-crawl',
+    label: 'Crawl websites',
+    description:
+      'Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis.',
+    resourceId: 'lgn-02a-apify-website-crawl-workflow'
+  },
   {
     id: 'lead-gen.company.website-extract',
     label: 'Extract website signals',
@@ -217,7 +317,46 @@ export const PROSPECTING_STEPS = {
       dependencyMode: 'per-record-eligibility',
       capabilityKey: 'lead-gen.company.apollo-import',
       defaultBatchSize: 250,
-      maxBatchSize: 1000
+      maxBatchSize: 1000,
+      recordColumns: DTC_RECORD_COLUMNS.populated,
+      credentialRequirements: [
+        {
+          key: 'apollo',
+          provider: 'apollo',
+          credentialType: 'api-key-secret',
+          label: 'Apollo API key',
+          required: true,
+          selectionMode: 'single',
+          inputPath: 'credential'
+        }
+      ]
+    },
+    apifyCrawl: {
+      id: 'apify-crawl',
+      label: 'Websites crawled',
+      description:
+        'Crawl company websites via Apify and store raw page markdown in enrichmentData.websiteCrawl.pages for downstream LLM analysis. Overwrites the synthetic seed Apollo Import wrote with real page content.',
+      primaryEntity: 'company',
+      outputs: ['company'],
+      stageKey: 'crawled',
+      dependsOn: ['import-apollo-search'],
+      dependencyMode: 'per-record-eligibility',
+      capabilityKey: 'lead-gen.company.apify-crawl',
+      defaultBatchSize: 50,
+      maxBatchSize: 100,
+      recordColumns: DTC_RECORD_COLUMNS.crawled,
+      credentialRequirements: [
+        {
+          key: 'apify',
+          provider: 'apify',
+          credentialType: 'api-key-secret',
+          label: 'Apify API token',
+          required: true,
+          selectionMode: 'single',
+          inputPath: 'credential',
+          verifyOnRun: true
+        }
+      ]
     },
     analyzeWebsites: {
       id: 'analyze-websites',
@@ -226,11 +365,12 @@ export const PROSPECTING_STEPS = {
       primaryEntity: 'company',
       outputs: ['company'],
       stageKey: 'extracted',
-      dependsOn: ['import-apollo-search'],
+      dependsOn: ['apify-crawl'],
       dependencyMode: 'per-record-eligibility',
       capabilityKey: 'lead-gen.company.website-extract',
       defaultBatchSize: 50,
-      maxBatchSize: 100
+      maxBatchSize: 100,
+      recordColumns: DTC_RECORD_COLUMNS.extracted
     },
     scoreDtcFit: {
       id: 'score-dtc-fit',
@@ -243,7 +383,8 @@ export const PROSPECTING_STEPS = {
       dependencyMode: 'per-record-eligibility',
       capabilityKey: 'lead-gen.company.dtc-subscription-qualify',
       defaultBatchSize: 100,
-      maxBatchSize: 250
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.qualified
     },
     enrichDecisionMakers: {
       id: 'enrich-decision-makers',
@@ -253,37 +394,53 @@ export const PROSPECTING_STEPS = {
       primaryEntity: 'company',
       outputs: ['contact'],
       stageKey: 'decision-makers-enriched',
+      recordEntity: 'contact',
       dependsOn: ['score-dtc-fit'],
       dependencyMode: 'per-record-eligibility',
       capabilityKey: 'lead-gen.contact.apollo-decision-maker-enrich',
       defaultBatchSize: 100,
-      maxBatchSize: 250
-    },
-    verifyEmails: {
-      id: 'verify-emails',
-      label: 'Emails verified',
-      description: 'Verify deliverability before the QC and handoff step.',
-      primaryEntity: 'contact',
-      outputs: ['contact'],
-      stageKey: 'verified',
-      dependsOn: ['enrich-decision-makers'],
-      dependencyMode: 'per-record-eligibility',
-      capabilityKey: 'lead-gen.contact.verify-email',
-      defaultBatchSize: 250,
-      maxBatchSize: 500
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.decisionMakers,
+      credentialRequirements: [
+        {
+          key: 'apollo',
+          provider: 'apollo',
+          credentialType: 'api-key-secret',
+          label: 'Apollo API key',
+          required: true,
+          selectionMode: 'single',
+          inputPath: 'credential'
+        }
+      ]
     },
     reviewAndExport: {
       id: 'review-and-export',
       label: 'Reviewed and exported',
-      description: 'Operator QC approves or rejects leads, then approved records are exported as a lead list.',
+      description:
+        'Operator QC approves or rejects qualified companies, then approved records are exported as a lead list with unverified emails.',
       primaryEntity: 'company',
       outputs: ['export'],
       stageKey: 'uploaded',
-      dependsOn: ['verify-emails'],
+      recordsStageKey: 'uploaded',
+      recordSourceStageKey: 'qualified',
+      dependsOn: ['enrich-decision-makers'],
       dependencyMode: 'per-record-eligibility',
       capabilityKey: 'lead-gen.export.list',
       defaultBatchSize: 100,
-      maxBatchSize: 250
+      maxBatchSize: 250,
+      recordColumns: DTC_RECORD_COLUMNS.uploaded,
+      credentialRequirements: [
+        {
+          key: 'clickup',
+          provider: 'clickup',
+          credentialType: 'api-key-secret',
+          label: 'ClickUp API token',
+          required: true,
+          selectionMode: 'single',
+          inputPath: 'clickupCredential',
+          verifyOnRun: true
+        }
+      ]
     }
   }
 } as const satisfies Record<TemplateName, Record<StepName, ListBuilderStep>>
@@ -311,7 +468,7 @@ function leadGenStagesForEntity(
   entity: LeadGenStageCatalogEntry['entity']
 ): z.infer<typeof ProspectingLifecycleStageSchema>[] {
   return Object.values(LEAD_GEN_STAGE_CATALOG)
-    .filter((stage) => stage.entity === entity)
+    .filter((stage) => stage.entity === entity || stage.additionalEntities?.includes(entity))
     .sort((a, b) => a.order - b.order)
     .map(toProspectingLifecycleStage)
 }
@@ -346,10 +503,10 @@ export const DEFAULT_ORGANIZATION_MODEL_PROSPECTING: z.infer<typeof Organization
         'Prospecting pipeline for DTC subscription or subscription-ready brands where Apollo is the source and contact-enrichment layer, Elevasis handles company research and fit scoring, and approved leads export as an approved lead list.',
       steps: [
         PROSPECTING_STEPS.dtcApolloClickup.importApolloSearch,
+        PROSPECTING_STEPS.dtcApolloClickup.apifyCrawl,
         PROSPECTING_STEPS.dtcApolloClickup.analyzeWebsites,
         PROSPECTING_STEPS.dtcApolloClickup.scoreDtcFit,
         PROSPECTING_STEPS.dtcApolloClickup.enrichDecisionMakers,
-        PROSPECTING_STEPS.dtcApolloClickup.verifyEmails,
         PROSPECTING_STEPS.dtcApolloClickup.reviewAndExport
       ]
     }

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

@@ -0,0 +1,88 @@
+import { z } from 'zod'
+import { ModelIdSchema } from './shared'
+import { SystemIdSchema } from './systems'
+
+// ---------------------------------------------------------------------------
+// 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'])
+export const ResourceGovernanceStatusSchema = z.enum(['active', 'deprecated', 'archived'])
+export const AgentKindSchema = z.enum(['orchestrator', 'specialist', 'utility', 'system'])
+
+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')
+
+const ResourceEntryBaseSchema = z.object({
+  /** Canonical resource id; runtime resourceId derives from this value. */
+  id: ResourceIdSchema,
+  /** Required single System membership. */
+  systemId: SystemIdSchema,
+  /** Optional role responsible for maintaining this resource. */
+  ownerRoleId: ModelIdSchema.optional(),
+  status: ResourceGovernanceStatusSchema
+})
+
+export const WorkflowResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('workflow'),
+  /** Mirrors WorkflowConfig.capabilityKey when the runtime workflow has one. */
+  capabilityKey: z.string().trim().min(1).max(255).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.optional(),
+  /** Mirrors AgentConfig.sessionCapable. */
+  sessionCapable: z.boolean()
+})
+
+export const IntegrationResourceEntrySchema = ResourceEntryBaseSchema.extend({
+  kind: z.literal('integration'),
+  provider: z.string().trim().min(1).max(100)
+})
+
+export const ResourceEntrySchema = z.discriminatedUnion('kind', [
+  WorkflowResourceEntrySchema,
+  AgentResourceEntrySchema,
+  IntegrationResourceEntrySchema
+])
+
+export const ResourcesDomainSchema = z.object({
+  entries: z.array(ResourceEntrySchema).default([])
+})
+
+export const DEFAULT_ORGANIZATION_MODEL_RESOURCES: z.infer<typeof ResourcesDomainSchema> = {
+  entries: []
+}
+
+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 {
+  for (const resource of Object.values(resources)) {
+    ResourceEntrySchema.parse(resource)
+  }
+
+  return resources
+}
+
+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 WorkflowResourceEntry = z.infer<typeof WorkflowResourceEntrySchema>
+export type AgentResourceEntry = z.infer<typeof AgentResourceEntrySchema>
+export type IntegrationResourceEntry = z.infer<typeof IntegrationResourceEntrySchema>
+export type ResourceEntry = z.infer<typeof ResourceEntrySchema>
+export type ResourcesDomain = z.infer<typeof ResourcesDomainSchema>

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

@@ -1,55 +1,93 @@
-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: []
-}
+import { z } from 'zod'
+import { ResourceIdSchema } from './resources'
+import { ModelIdSchema } from './shared'
+import { SystemIdSchema } from './systems'
+
+// ---------------------------------------------------------------------------
+// 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 enforcement lives in `OrganizationModelSchema.superRefine()`:
+// `reportsToId` must resolve to another Role, `responsibleFor` entries must
+// resolve to Systems, and agent holders must resolve to Agent Resources.
+// Cycle detection is NOT enforced (known limitation; document if needed).
+// ---------------------------------------------------------------------------
+
+export const RoleIdSchema = ModelIdSchema
+
+export const HumanRoleHolderSchema = z.object({
+  kind: z.literal('human'),
+  userId: z.string().trim().min(1).max(200)
+})
+
+export const AgentRoleHolderSchema = z.object({
+  kind: z.literal('agent'),
+  agentId: ResourceIdSchema
+})
+
+export const TeamRoleHolderSchema = z.object({
+  kind: z.literal('team'),
+  memberIds: z.array(z.string().trim().min(1).max(200)).min(1)
+})
+
+export const RoleHolderSchema = z.discriminatedUnion('kind', [
+  HumanRoleHolderSchema,
+  AgentRoleHolderSchema,
+  TeamRoleHolderSchema
+])
+
+export const RoleHoldersSchema = z.union([RoleHolderSchema, z.array(RoleHolderSchema).min(1)])
+
+export const RoleSchema = z.object({
+  /** Stable unique identifier for the role (e.g. "role-ceo", "role-head-of-sales"). */
+  id: RoleIdSchema,
+  /** 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.
+   */
+  reportsToId: RoleIdSchema.optional(),
+  /**
+   * Optional: human, agent, or team holder currently filling this role.
+   * Agent holders reference OM Resource IDs and are validated at the model level.
+   */
+  heldBy: RoleHoldersSchema.optional(),
+  /**
+   * Optional Systems this role is accountable for.
+   * Cross-reference enforced in `OrganizationModelSchema.superRefine()`.
+   */
+  responsibleFor: z.array(SystemIdSchema).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: []
+}
+
+export type RoleId = z.infer<typeof RoleIdSchema>
+export type HumanRoleHolder = z.infer<typeof HumanRoleHolderSchema>
+export type AgentRoleHolder = z.infer<typeof AgentRoleHolderSchema>
+export type TeamRoleHolder = z.infer<typeof TeamRoleHolderSchema>
+export type RoleHolder = z.infer<typeof RoleHolderSchema>
+export type Role = z.infer<typeof RoleSchema>
+export type RolesDomain = z.infer<typeof RolesDomainSchema>

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

@@ -113,6 +113,7 @@ export const DEFAULT_ORGANIZATION_MODEL_SALES: z.infer<typeof OrganizationModelS
 //     - interested    (instantly-reply-handler.ts → contacts, initial reply transition)
 //   prospecting/:
 //     - populated     (apify-acquire.ts, apify-scrape.ts → companies)
+//     - crawled       (apify-website-crawl.ts → companies)
 //     - extracted     (website-extract.ts → companies)
 //     - discovered    (email-discovery.ts, anymailfinder-enrich.ts → contacts)
 //     - verified      (email-verification.ts → contacts)
@@ -414,7 +415,7 @@ export const ACQ_LIST_COMPANIES_LEAD_GEN_PIPELINE: StatefulPipelineDefinition =
     {
       stageKey: 'outreach',
       label: 'Outreach',
-      states: [PENDING_STATE]
+      states: [PENDING_STATE, { stateKey: 'uploaded', label: 'Uploaded' }]
     },
     {
       stageKey: 'prospecting',
@@ -472,6 +473,15 @@ export interface LeadGenStageCatalogEntry {
   order: number
   /** Which entity's processing_state jsonb carries this stage status. */
   entity: 'company' | 'contact'
+  /** Additional entities allowed to write/read this processing_state key. */
+  additionalEntities?: Array<'company' | 'contact'>
+  /**
+   * Optional read-side override for Records views when a company-scoped step
+   * produces records on a different entity.
+   */
+  recordEntity?: 'company' | 'contact'
+  /** Stage key to read from recordEntity.processing_state for Records views. */
+  recordStageKey?: string
 }
 
 /**
@@ -496,6 +506,14 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
     order: 2,
     entity: 'company'
   },
+  crawled: {
+    key: 'crawled',
+    label: 'Websites crawled',
+    description:
+      'Company websites have been crawled (e.g. via Apify) and raw page content stored for downstream LLM analysis.',
+    order: 2.5,
+    entity: 'company'
+  },
   extracted: {
     key: 'extracted',
     label: 'Websites analyzed',
@@ -515,7 +533,9 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
     label: 'Decision-makers found',
     description: 'Decision-maker contacts discovered and attached to a qualified company.',
     order: 6,
-    entity: 'company'
+    entity: 'company',
+    recordEntity: 'contact',
+    recordStageKey: 'discovered'
   },
 
   // Prospecting — contact discovery
@@ -556,7 +576,8 @@ export const LEAD_GEN_STAGE_CATALOG: Record<string, LeadGenStageCatalogEntry> =
     label: 'Reviewed and exported',
     description: 'Approved records have been reviewed and exported for handoff.',
     order: 10,
-    entity: 'contact'
+    entity: 'company',
+    additionalEntities: ['contact']
   },
   interested: {
     key: 'interested',

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

@@ -0,0 +1,46 @@
+import { z } from 'zod'
+import { DescriptionSchema, LabelSchema, ModelIdSchema, ReferenceIdsSchema } from './shared'
+
+// ---------------------------------------------------------------------------
+// Systems domain
+// ---------------------------------------------------------------------------
+//
+// A System is a tenant-defined bounded context that groups operational
+// resources and carries governance metadata. The shared schema validates the
+// shape and references; each tenant supplies its own catalog.
+
+export const SystemKindSchema = z.enum(['product', 'operational', 'platform', 'diagnostic'])
+export const SystemStatusSchema = z.enum(['active', 'deprecated', 'archived'])
+export const SystemIdSchema = ModelIdSchema
+
+export const SystemEntrySchema = z.object({
+  /** Stable tenant-defined system id (e.g. "sys.lead-gen"). */
+  id: SystemIdSchema,
+  /** Human-readable system title shown in governance and operations UI. */
+  title: LabelSchema,
+  /** One-paragraph purpose statement for the bounded context. */
+  description: DescriptionSchema,
+  /** Closed system shape enum; catalog values remain tenant-defined. */
+  kind: SystemKindSchema,
+  /** Optional role responsible for this system. */
+  responsibleRoleId: ModelIdSchema.optional(),
+  /** Optional knowledge nodes that govern this system. */
+  governedByKnowledge: ReferenceIdsSchema,
+  /** Optional goals this system contributes to. */
+  drivesGoals: ReferenceIdsSchema,
+  status: SystemStatusSchema
+})
+
+export const SystemsDomainSchema = z.object({
+  systems: z.array(SystemEntrySchema).default([])
+})
+
+export const DEFAULT_ORGANIZATION_MODEL_SYSTEMS: z.infer<typeof SystemsDomainSchema> = {
+  systems: []
+}
+
+export type SystemId = z.infer<typeof SystemIdSchema>
+export type SystemKind = z.infer<typeof SystemKindSchema>
+export type SystemStatus = z.infer<typeof SystemStatusSchema>
+export type SystemEntry = z.infer<typeof SystemEntrySchema>
+export type SystemsDomain = z.infer<typeof SystemsDomainSchema>

package/src/organization-model/icons.ts

@@ -18,6 +18,7 @@ export const ORGANIZATION_MODEL_ICON_TOKENS = [
   'knowledge.reference',
   'feature.dashboard',
   'feature.calendar',
+  'feature.business',
   'feature.sales',
   'feature.crm',
   'feature.finance',