@elevasis/sdk 1.16.0 → 1.18.0

package/dist/worker/index.js

@@ -3652,6 +3652,29 @@ function estimateTokens(text) {
   const chars = content.length;
   return Math.ceil(chars / 3.5);
 }
+var UuidSchema = z.string().uuid();
+var NonEmptyStringSchema = z.string().trim().min(1).max(1e3);
+z.enum(["agent", "workflow"]);
+z.enum(["agent", "workflow", "scheduler", "api"]);
+z.string().trim().toLowerCase().min(1, "Credential name required").max(100, "Credential name too long (max 100 chars)").regex(
+  /^[a-z0-9]+(-[a-z0-9]+)+$/,
+  "Credential name must be lowercase letters, numbers, and hyphens in format: service-environment (e.g., gmail-prod, attio-dev)"
+);
+z.enum(["google-sheets", "google-calendar", "dropbox"]);
+z.string().min(10, "Authorization code too short").max(1e3, "Authorization code too long");
+z.string().min(10, "State parameter too short").max(2048, "State parameter too long");
+z.string().trim().transform((str) => str.replace(/[<>'"]/g, ""));
+z.string().email();
+z.string().url();
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+z.string().datetime();
+z.object({
+  startDate: z.string().datetime(),
+  endDate: z.string().datetime()
+});
 
 // ../core/src/platform/constants/limits.ts
 var MAX_SESSION_MEMORY_KEYS = 25;
@@ -4580,6 +4603,1167 @@ Fix the errors and generate a valid output.
     }
   }
 };
+var ORGANIZATION_MODEL_ICON_TOKENS = [
+  "nav.dashboard",
+  "nav.calendar",
+  "nav.sales",
+  "nav.crm",
+  "nav.lead-gen",
+  "nav.projects",
+  "nav.operations",
+  "nav.monitoring",
+  "nav.knowledge",
+  "nav.settings",
+  "nav.admin",
+  "nav.archive",
+  "knowledge.playbook",
+  "knowledge.strategy",
+  "knowledge.reference",
+  "feature.dashboard",
+  "feature.calendar",
+  "feature.sales",
+  "feature.crm",
+  "feature.finance",
+  "feature.lead-gen",
+  "feature.platform",
+  "feature.projects",
+  "feature.operations",
+  "feature.knowledge",
+  "feature.monitoring",
+  "feature.settings",
+  "feature.admin",
+  "feature.archive",
+  "feature.seo",
+  "resource.agent",
+  "resource.workflow",
+  "resource.integration",
+  "resource.database",
+  "resource.user",
+  "resource.team",
+  "integration.gmail",
+  "integration.google-sheets",
+  "integration.attio",
+  "surface.dashboard",
+  "surface.calendar",
+  "surface.overview",
+  "surface.command-view",
+  "surface.command-queue",
+  "surface.pipeline",
+  "surface.lists",
+  "surface.resources",
+  "surface.settings",
+  "status.success",
+  "status.error",
+  "status.warning",
+  "status.info",
+  "status.pending",
+  "action.approve",
+  "action.reject",
+  "action.retry",
+  "action.edit",
+  "action.view",
+  "action.launch",
+  "action.message",
+  "action.escalate",
+  "action.promote",
+  "action.submit",
+  "action.email"
+];
+var CustomIconTokenSchema = z.string().trim().max(80).regex(/^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "Custom icon tokens must start with custom.");
+var OrganizationModelBuiltinIconTokenSchema = z.enum(ORGANIZATION_MODEL_ICON_TOKENS);
+var OrganizationModelIconTokenSchema = z.union([
+  OrganizationModelBuiltinIconTokenSchema,
+  CustomIconTokenSchema
+]);
+
+// ../core/src/organization-model/domains/shared.ts
+var ModelIdSchema = z.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "IDs must be lowercase and use -, _, or . separators");
+var LabelSchema = z.string().trim().min(1).max(120);
+var DescriptionSchema = z.string().trim().min(1).max(2e3);
+var ColorTokenSchema = z.string().trim().min(1).max(50);
+var IconNameSchema = OrganizationModelIconTokenSchema;
+z.string().trim().startsWith("/").max(300);
+var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
+var DisplayMetadataSchema = z.object({
+  label: LabelSchema,
+  description: DescriptionSchema.optional(),
+  color: ColorTokenSchema.optional(),
+  icon: IconNameSchema.optional()
+});
+var 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)
+});
+DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  resourceId: z.string().trim().min(1).max(255),
+  resourceType: z.enum(["workflow", "agent", "trigger", "integration", "external", "human_checkpoint"]),
+  featureIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  surfaceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema,
+  /** Optional tech-stack metadata for external-SaaS integrations. */
+  techStack: TechStackEntrySchema.optional()
+});
+
+// ../core/src/organization-model/domains/sales.ts
+var SalesStageSemanticClassSchema = z.enum(["open", "active", "nurturing", "closed_won", "closed_lost"]);
+var SalesStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().int().min(0),
+  semanticClass: SalesStageSemanticClassSchema,
+  surfaceIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema
+});
+var SalesPipelineSchema = z.object({
+  id: ModelIdSchema,
+  label: z.string().trim().min(1).max(120),
+  description: DescriptionSchema.optional(),
+  entityId: ModelIdSchema,
+  stages: z.array(SalesStageSchema).min(1)
+});
+z.object({
+  entityId: ModelIdSchema,
+  defaultPipelineId: ModelIdSchema,
+  pipelines: z.array(SalesPipelineSchema).min(1)
+});
+var LEAD_GEN_STAGE_CATALOG = {
+  // Prospecting — company population
+  scraped: {
+    key: "scraped",
+    label: "Scraped",
+    description: "Company was scraped from a source directory (Apify actor run).",
+    order: 1,
+    entity: "company"
+  },
+  populated: {
+    key: "populated",
+    label: "Companies found",
+    description: "Companies have been found and added to the lead-gen list.",
+    order: 2,
+    entity: "company"
+  },
+  extracted: {
+    key: "extracted",
+    label: "Websites analyzed",
+    description: "Company websites have been analyzed for business signals.",
+    order: 3,
+    entity: "company"
+  },
+  enriched: {
+    key: "enriched",
+    label: "Enriched",
+    description: "Company or contact enriched with third-party data (e.g. Tomba, Anymailfinder).",
+    order: 4,
+    entity: "company"
+  },
+  "decision-makers-enriched": {
+    key: "decision-makers-enriched",
+    label: "Decision-makers found",
+    description: "Decision-maker contacts discovered and attached to a qualified company.",
+    order: 6,
+    entity: "company"
+  },
+  // Prospecting — contact discovery
+  discovered: {
+    key: "discovered",
+    label: "Decision-makers found",
+    description: "Decision-maker contact details have been found.",
+    order: 5,
+    entity: "contact"
+  },
+  verified: {
+    key: "verified",
+    label: "Emails verified",
+    description: "Contact email addresses have been checked for deliverability.",
+    order: 7,
+    entity: "contact"
+  },
+  // Qualification
+  qualified: {
+    key: "qualified",
+    label: "Companies qualified",
+    description: "Companies have been scored against the qualification criteria.",
+    order: 8,
+    entity: "company"
+  },
+  // Outreach
+  personalized: {
+    key: "personalized",
+    label: "Personalized",
+    description: "Outreach message personalized for the contact (Instantly personalization workflow).",
+    order: 9,
+    entity: "contact"
+  },
+  uploaded: {
+    key: "uploaded",
+    label: "Reviewed and exported",
+    description: "Approved records have been reviewed and exported for handoff.",
+    order: 10,
+    entity: "contact"
+  },
+  interested: {
+    key: "interested",
+    label: "Interested",
+    description: "Contact replied with a positive signal (Instantly reply-handler transition).",
+    order: 11,
+    entity: "contact"
+  }
+};
+
+// ../core/src/organization-model/domains/prospecting.ts
+var ProspectingLifecycleStageSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  order: z.number().int().min(0)
+});
+var ProspectingBuildTemplateStepSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  primaryEntity: z.enum(["company", "contact"]),
+  outputs: z.array(z.enum(["company", "contact", "export"])).min(1),
+  stageKey: ModelIdSchema,
+  dependsOn: z.array(ModelIdSchema).optional(),
+  dependencyMode: z.literal("per-record-eligibility"),
+  capabilityKey: ModelIdSchema,
+  defaultBatchSize: z.number().int().positive(),
+  maxBatchSize: z.number().int().positive()
+}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+  message: "defaultBatchSize must be less than or equal to maxBatchSize",
+  path: ["defaultBatchSize"]
+});
+var ProspectingBuildTemplateSchema = DisplayMetadataSchema.extend({
+  id: ModelIdSchema,
+  steps: z.array(ProspectingBuildTemplateStepSchema).min(1)
+});
+var CAPABILITY_REGISTRY = {
+  "lead-gen.company.source": "lgn-import-workflow",
+  "lead-gen.company.apollo-import": "lgn-01c-apollo-import-workflow",
+  "lead-gen.contact.discover": "lgn-04-email-discovery-workflow",
+  "lead-gen.contact.verify-email": "lgn-05-email-verification-workflow",
+  "lead-gen.company.website-extract": "lgn-02-website-extract-workflow",
+  "lead-gen.company.qualify": "lgn-03-company-qualification-workflow",
+  "lead-gen.company.dtc-subscription-qualify": "lgn-03b-dtc-subscription-score-workflow",
+  "lead-gen.contact.apollo-decision-maker-enrich": "lgn-04b-apollo-decision-maker-enrich-workflow",
+  "lead-gen.contact.personalize": "ist-personalization-workflow",
+  "lead-gen.review.outreach-ready": "ist-upload-contacts-workflow",
+  "lead-gen.export.list": "lgn-06-export-list-workflow",
+  "lead-gen.company.cleanup": "lgn-company-cleanup-workflow"
+};
+var PROSPECTING_STEPS = {
+  localServices: {
+    sourceCompanies: {
+      id: "source-companies",
+      label: "Companies found",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "populated",
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.source",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    },
+    analyzeWebsites: {
+      id: "analyze-websites",
+      label: "Websites analyzed",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "extracted",
+      dependsOn: ["source-companies"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.website-extract",
+      defaultBatchSize: 50,
+      maxBatchSize: 100
+    },
+    qualifyCompanies: {
+      id: "qualify-companies",
+      label: "Companies qualified",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "qualified",
+      dependsOn: ["analyze-websites"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.qualify",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    },
+    findContacts: {
+      id: "find-contacts",
+      label: "Decision-makers found",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "discovered",
+      dependsOn: ["qualify-companies"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.contact.discover",
+      defaultBatchSize: 50,
+      maxBatchSize: 100
+    },
+    verifyEmails: {
+      id: "verify-emails",
+      label: "Emails verified",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "verified",
+      dependsOn: ["find-contacts"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.contact.verify-email",
+      defaultBatchSize: 100,
+      maxBatchSize: 500
+    },
+    personalize: {
+      id: "personalize",
+      label: "Personalize",
+      primaryEntity: "contact",
+      outputs: ["contact"],
+      stageKey: "personalized",
+      dependsOn: ["verify-emails"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.contact.personalize",
+      defaultBatchSize: 25,
+      maxBatchSize: 100
+    },
+    review: {
+      id: "review",
+      label: "Reviewed and exported",
+      primaryEntity: "contact",
+      outputs: ["export"],
+      stageKey: "uploaded",
+      dependsOn: ["personalize"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.review.outreach-ready",
+      defaultBatchSize: 25,
+      maxBatchSize: 100
+    }
+  },
+  dtcApolloClickup: {
+    importApolloSearch: {
+      id: "import-apollo-search",
+      label: "Companies found",
+      description: "Pull companies and seed contact data from a predefined Apollo search or list.",
+      primaryEntity: "company",
+      outputs: ["company", "contact"],
+      stageKey: "populated",
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.apollo-import",
+      defaultBatchSize: 250,
+      maxBatchSize: 1e3
+    },
+    analyzeWebsites: {
+      id: "analyze-websites",
+      label: "Websites analyzed",
+      description: "Extract subscription, product, retention, and tech-stack signals from each brand website.",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "extracted",
+      dependsOn: ["import-apollo-search"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.website-extract",
+      defaultBatchSize: 50,
+      maxBatchSize: 100
+    },
+    scoreDtcFit: {
+      id: "score-dtc-fit",
+      label: "Companies qualified",
+      description: "Classify subscription potential, consumable-product fit, retention maturity, and disqualifiers.",
+      primaryEntity: "company",
+      outputs: ["company"],
+      stageKey: "qualified",
+      dependsOn: ["analyze-websites"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.company.dtc-subscription-qualify",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    },
+    enrichDecisionMakers: {
+      id: "enrich-decision-makers",
+      label: "Decision-makers found",
+      description: "Use Apollo to find qualified contacts at qualified companies - founders, retention leads, lifecycle leads, and marketing owners.",
+      primaryEntity: "company",
+      outputs: ["contact"],
+      stageKey: "decision-makers-enriched",
+      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
+    },
+    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.",
+      primaryEntity: "company",
+      outputs: ["export"],
+      stageKey: "uploaded",
+      dependsOn: ["verify-emails"],
+      dependencyMode: "per-record-eligibility",
+      capabilityKey: "lead-gen.export.list",
+      defaultBatchSize: 100,
+      maxBatchSize: 250
+    }
+  }
+};
+z.object({
+  listEntityId: ModelIdSchema,
+  companyEntityId: ModelIdSchema,
+  contactEntityId: ModelIdSchema,
+  description: DescriptionSchema.optional(),
+  companyStages: z.array(ProspectingLifecycleStageSchema).min(1),
+  contactStages: z.array(ProspectingLifecycleStageSchema).min(1),
+  defaultBuildTemplateId: ModelIdSchema,
+  buildTemplates: z.array(ProspectingBuildTemplateSchema).min(1)
+});
+function toProspectingLifecycleStage(stage) {
+  return {
+    id: stage.key,
+    label: stage.label,
+    order: stage.order
+  };
+}
+function leadGenStagesForEntity(entity) {
+  return Object.values(LEAD_GEN_STAGE_CATALOG).filter((stage) => stage.entity === entity).sort((a, b) => a.order - b.order).map(toProspectingLifecycleStage);
+}
+var DEFAULT_ORGANIZATION_MODEL_PROSPECTING = {
+  companyStages: leadGenStagesForEntity("company"),
+  contactStages: leadGenStagesForEntity("contact"),
+  buildTemplates: [
+    {
+      id: "local-services",
+      label: "Local Services Prospecting",
+      description: "Curated local-services list build using company sourcing, website analysis, qualification, contact discovery, verification, personalization, and review.",
+      steps: [
+        PROSPECTING_STEPS.localServices.sourceCompanies,
+        PROSPECTING_STEPS.localServices.analyzeWebsites,
+        PROSPECTING_STEPS.localServices.qualifyCompanies,
+        PROSPECTING_STEPS.localServices.findContacts,
+        PROSPECTING_STEPS.localServices.verifyEmails,
+        PROSPECTING_STEPS.localServices.personalize,
+        PROSPECTING_STEPS.localServices.review
+      ]
+    },
+    {
+      id: "dtc-subscription-apollo-clickup",
+      label: "DTC Subscription Apollo Export",
+      description: "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.analyzeWebsites,
+        PROSPECTING_STEPS.dtcApolloClickup.scoreDtcFit,
+        PROSPECTING_STEPS.dtcApolloClickup.enrichDecisionMakers,
+        PROSPECTING_STEPS.dtcApolloClickup.verifyEmails,
+        PROSPECTING_STEPS.dtcApolloClickup.reviewAndExport
+      ]
+    }
+  ]
+};
+
+// ../core/src/business/acquisition/build-templates.ts
+var PROSPECTING_BUILD_TEMPLATE_OPTIONS = DEFAULT_ORGANIZATION_MODEL_PROSPECTING.buildTemplates.map(
+  ({ id, label, description }) => ({
+    id,
+    label,
+    description
+  })
+);
+function isProspectingBuildTemplateId(value) {
+  return PROSPECTING_BUILD_TEMPLATE_OPTIONS.some((template) => template.id === value);
+}
+var ProcessingStageStatusSchema = z.enum(["success", "no_result", "skipped", "error"]);
+var LeadGenStageKeySchema = z.string().refine((value) => Object.prototype.hasOwnProperty.call(LEAD_GEN_STAGE_CATALOG, value), {
+  message: "processing state key must match LEAD_GEN_STAGE_CATALOG"
+});
+var LeadGenCapabilityKeySchema = z.string().refine((value) => Object.prototype.hasOwnProperty.call(CAPABILITY_REGISTRY, value), {
+  message: "capabilityKey must match CAPABILITY_REGISTRY"
+});
+var ProcessingStateEntrySchema = z.object({
+  status: ProcessingStageStatusSchema,
+  data: z.unknown().optional()
+}).passthrough();
+var ProcessingStateSchema = z.record(LeadGenStageKeySchema, ProcessingStateEntrySchema);
+var CompanyProcessingStateSchema = ProcessingStateSchema;
+var ContactProcessingStateSchema = ProcessingStateSchema;
+var DealStageSchema = z.enum(["interested", "proposal", "closing", "closed_won", "closed_lost", "nurturing"]);
+var AcqDealTaskKindSchema = z.enum(["call", "email", "meeting", "other"]);
+z.object({
+  dealId: UuidSchema
+});
+z.object({
+  dealId: UuidSchema,
+  taskId: UuidSchema
+});
+z.object({
+  stage: DealStageSchema.optional(),
+  search: z.string().optional(),
+  limit: z.coerce.number().int().positive().default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+}).strict();
+z.object({
+  search: z.string().trim().min(1).max(200).optional(),
+  limit: z.coerce.number().int().min(1).max(25).default(10)
+}).strict();
+z.object({
+  window: z.enum(["overdue", "today", "today_and_overdue", "upcoming"]).optional(),
+  assigneeUserId: UuidSchema.optional()
+}).strict();
+z.object({
+  body: z.string().trim().min(1).max(1e4)
+}).strict();
+z.object({
+  title: z.string().trim().min(1).max(255),
+  description: z.string().nullable().optional(),
+  kind: AcqDealTaskKindSchema.optional(),
+  dueAt: z.string().datetime().nullable().optional(),
+  assigneeUserId: UuidSchema.nullable().optional()
+}).strict();
+z.object({
+  pipelineKey: z.string().min(1),
+  stageKey: z.string().min(1),
+  stateKey: z.string().nullable().optional(),
+  reason: z.string().optional(),
+  expectedUpdatedAt: z.string().datetime().optional()
+}).strict();
+z.object({
+  stateKey: z.string().min(1),
+  reason: z.string().optional(),
+  expectedUpdatedAt: z.string().datetime().optional()
+}).strict();
+z.object({
+  dealId: UuidSchema,
+  actionKey: NonEmptyStringSchema
+}).strict();
+z.object({
+  payload: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var DealContactSummarySchema = z.object({
+  id: z.string(),
+  first_name: z.string().nullable(),
+  last_name: z.string().nullable(),
+  email: z.string(),
+  title: z.string().nullable(),
+  headline: z.string().nullable(),
+  linkedin_url: z.string().nullable(),
+  processing_state: ProcessingStateSchema.nullable(),
+  enrichment_data: z.record(z.string(), z.unknown()).nullable(),
+  company: z.object({
+    id: z.string(),
+    name: z.string(),
+    domain: z.string().nullable(),
+    website: z.string().nullable(),
+    linkedin_url: z.string().nullable(),
+    segment: z.string().nullable(),
+    category: z.string().nullable(),
+    num_employees: z.number().nullable()
+  }).nullable()
+});
+var DealPrioritySchema = z.object({
+  bucketKey: z.enum(["needs_response", "follow_up_due", "waiting", "stale", "closed_low"]),
+  rank: z.number().int(),
+  label: z.string(),
+  color: z.string(),
+  reason: z.string(),
+  latestActivityAt: z.string().nullable(),
+  nextActionAt: z.string().nullable()
+});
+var DealListItemSchema = z.object({
+  // acq_deals columns
+  id: z.string(),
+  organization_id: z.string(),
+  contact_id: z.string().nullable(),
+  contact_email: z.string(),
+  pipeline_key: z.string(),
+  stage_key: z.string().nullable(),
+  state_key: z.string().nullable(),
+  activity_log: z.unknown(),
+  discovery_data: z.unknown().nullable(),
+  discovery_submitted_at: z.string().nullable(),
+  discovery_submitted_by: z.string().nullable(),
+  proposal_data: z.unknown().nullable(),
+  proposal_sent_at: z.string().nullable(),
+  proposal_pdf_url: z.string().nullable(),
+  signature_envelope_id: z.string().nullable(),
+  source_list_id: z.string().nullable(),
+  source_type: z.string().nullable(),
+  initial_fee: z.number().nullable(),
+  monthly_fee: z.number().nullable(),
+  closed_lost_at: z.string().nullable(),
+  closed_lost_reason: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string(),
+  priority: DealPrioritySchema,
+  ownership: z.enum(["us", "them"]).nullable(),
+  nextAction: z.string().nullable(),
+  // joined relation
+  contact: DealContactSummarySchema.nullable()
+});
+z.object({
+  data: z.array(DealListItemSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+var DealStageSummarySchema = z.object({
+  stage: z.string(),
+  count: z.number().int(),
+  totalValue: z.number(),
+  oldestUpdatedAt: z.string().nullable(),
+  newestUpdatedAt: z.string().nullable()
+});
+var StaleDealSummarySchema = z.object({
+  id: z.string(),
+  contactEmail: z.string(),
+  stageKey: z.string(),
+  updatedAt: z.string(),
+  daysStale: z.number().int()
+});
+z.object({
+  totalDeals: z.number().int(),
+  openDeals: z.number().int(),
+  wonDeals: z.number().int(),
+  lostDeals: z.number().int(),
+  winRate: z.number(),
+  avgDealSize: z.number(),
+  totalPipelineValue: z.number(),
+  stageSummary: z.array(DealStageSummarySchema),
+  staleDeals: z.array(StaleDealSummarySchema)
+});
+var DealLookupItemSchema = z.object({
+  id: z.string(),
+  contactEmail: z.string(),
+  stageKey: z.string().nullable(),
+  updatedAt: z.string(),
+  contactName: z.string().nullable(),
+  companyName: z.string().nullable(),
+  displayLabel: z.string()
+});
+z.array(DealLookupItemSchema);
+var ConversationMessageSchema = z.object({
+  id: z.string(),
+  direction: z.enum(["inbound", "outbound"]),
+  fromEmail: z.string(),
+  toEmail: z.string(),
+  subject: z.string().nullable(),
+  body: z.string(),
+  sentAt: z.string().nullable()
+});
+var DealConversationSchema = z.object({
+  messages: z.array(ConversationMessageSchema)
+});
+DealListItemSchema.extend({
+  conversation: DealConversationSchema
+});
+var DealNoteResponseSchema = z.object({
+  id: z.string(),
+  dealId: z.string(),
+  organizationId: z.string(),
+  authorUserId: z.string().nullable(),
+  body: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+z.array(DealNoteResponseSchema);
+var DealTaskResponseSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  dealId: z.string(),
+  title: z.string(),
+  description: z.string().nullable(),
+  kind: AcqDealTaskKindSchema,
+  dueAt: z.string().nullable(),
+  assigneeUserId: z.string().nullable(),
+  completedAt: z.string().nullable(),
+  completedByUserId: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  createdByUserId: z.string().nullable()
+});
+z.array(DealTaskResponseSchema);
+var ListStatusSchema = z.enum(["draft", "enriching", "launched", "closing", "archived"]);
+var ScrapingConfigSchema = z.object({
+  vertical: z.string().trim().max(255).optional(),
+  geography: z.string().trim().max(500).optional(),
+  size: z.string().trim().max(255).optional(),
+  apifyInput: z.record(z.string(), z.unknown()).optional()
+});
+var IcpRubricSchema = z.object({
+  qualificationRubricKey: z.string().trim().max(255).nullish(),
+  targetDescription: z.string().optional(),
+  minReviewCount: z.number().int().min(0).optional(),
+  minRating: z.number().min(0).max(5).optional(),
+  excludeFranchises: z.boolean().optional(),
+  customRules: z.string().optional()
+});
+var PipelineStageSchema = z.object({
+  key: z.string().refine((value) => Object.prototype.hasOwnProperty.call(LEAD_GEN_STAGE_CATALOG, value), {
+    message: "pipeline stage key must match LEAD_GEN_STAGE_CATALOG"
+  }),
+  label: z.string().optional(),
+  enabled: z.boolean().optional(),
+  order: z.number().int().optional()
+});
+var PipelineConfigSchema = z.object({
+  stages: z.array(PipelineStageSchema).optional()
+});
+var BuildPlanSnapshotStepSchema = z.object({
+  id: z.string().trim().min(1).max(100),
+  label: z.string().trim().min(1).max(120),
+  description: z.string().trim().min(1).max(2e3).optional(),
+  primaryEntity: z.enum(["company", "contact"]),
+  outputs: z.array(z.enum(["company", "contact", "export"])).min(1),
+  stageKey: LeadGenStageKeySchema,
+  dependsOn: z.array(z.string().trim().min(1).max(100)).optional(),
+  dependencyMode: z.literal("per-record-eligibility"),
+  capabilityKey: LeadGenCapabilityKeySchema,
+  defaultBatchSize: z.number().int().positive(),
+  maxBatchSize: z.number().int().positive()
+}).refine((step) => step.defaultBatchSize <= step.maxBatchSize, {
+  message: "defaultBatchSize must be less than or equal to maxBatchSize",
+  path: ["defaultBatchSize"]
+});
+var BuildPlanSnapshotSchema = z.object({
+  templateId: z.string().trim().min(1).max(100),
+  templateLabel: z.string().trim().min(1).max(120),
+  steps: z.array(BuildPlanSnapshotStepSchema).min(1)
+}).superRefine((snapshot, ctx) => {
+  const stepIds = /* @__PURE__ */ new Set();
+  snapshot.steps.forEach((step, index) => {
+    if (stepIds.has(step.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate build-plan step id "${step.id}"`,
+        path: ["steps", index, "id"]
+      });
+    }
+    stepIds.add(step.id);
+  });
+  snapshot.steps.forEach((step, index) => {
+    for (const dependencyId of step.dependsOn ?? []) {
+      if (!stepIds.has(dependencyId)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `dependsOn references unknown build-plan step "${dependencyId}"`,
+          path: ["steps", index, "dependsOn"]
+        });
+      }
+    }
+  });
+});
+var AcqListMetadataSchema = z.object({
+  buildPlanSnapshot: BuildPlanSnapshotSchema.optional()
+}).catchall(z.unknown());
+var ProspectingBuildTemplateIdSchema = z.string().trim().min(1).max(100).refine(isProspectingBuildTemplateId, {
+  message: "buildTemplateId must match a known prospecting build template"
+});
+var ListStageCountsSchema = z.object({
+  // Attempted counts by canonical lead-gen stage. The detailed status
+  // distribution lives on ListProgress; telemetry keeps the overview payload small.
+  stageCounts: z.object({
+    populated: z.number().int(),
+    extracted: z.number().int(),
+    qualified: z.number().int(),
+    discovered: z.number().int(),
+    verified: z.number().int(),
+    personalized: z.number().int(),
+    uploaded: z.number().int()
+  }),
+  deliverability: z.object({
+    valid: z.number().int(),
+    risky: z.number().int(),
+    invalid: z.number().int(),
+    unknown: z.number().int(),
+    bounced: z.number().int()
+  })
+});
+var ListTelemetrySchema = z.object({
+  listId: UuidSchema,
+  totalCompanies: z.number().int(),
+  totalContacts: z.number().int(),
+  stageCounts: ListStageCountsSchema.shape.stageCounts,
+  deliverability: ListStageCountsSchema.shape.deliverability,
+  activeWorkflows: z.array(z.string()).optional()
+});
+z.object({
+  listId: UuidSchema
+});
+z.object({
+  name: z.string().trim().min(1).max(255),
+  description: z.string().trim().nullable().optional(),
+  status: ListStatusSchema.optional(),
+  buildTemplateId: ProspectingBuildTemplateIdSchema.optional(),
+  scrapingConfig: ScrapingConfigSchema.optional(),
+  icp: IcpRubricSchema.optional(),
+  pipelineConfig: PipelineConfigSchema.optional()
+}).strict();
+z.object({
+  name: z.string().trim().min(1).max(255).optional(),
+  description: z.string().trim().nullable().optional(),
+  batchIds: z.array(z.string()).optional(),
+  buildTemplateId: ProspectingBuildTemplateIdSchema.optional(),
+  confirmBuildTemplateChange: z.literal(true).optional()
+}).strict().refine(
+  (data) => data.name !== void 0 || data.description !== void 0 || data.batchIds !== void 0 || data.buildTemplateId !== void 0,
+  {
+    message: "At least one field (name, description, batchIds, or buildTemplateId) must be provided"
+  }
+).refine((data) => data.buildTemplateId === void 0 || data.confirmBuildTemplateChange === true, {
+  message: "confirmBuildTemplateChange must be true when changing buildTemplateId",
+  path: ["confirmBuildTemplateChange"]
+});
+z.object({
+  status: ListStatusSchema
+}).strict();
+z.object({
+  scrapingConfig: ScrapingConfigSchema.partial().optional(),
+  icp: IcpRubricSchema.partial().optional(),
+  pipelineConfig: PipelineConfigSchema.partial().optional()
+}).strict().refine((data) => data.scrapingConfig !== void 0 || data.icp !== void 0 || data.pipelineConfig !== void 0, {
+  message: "At least one of scrapingConfig, icp, or pipelineConfig must be provided"
+});
+z.object({
+  companyIds: z.array(UuidSchema).min(1).max(1e3)
+}).strict();
+z.object({
+  companyIds: z.array(UuidSchema).min(1).max(1e3)
+}).strict();
+z.object({
+  contactIds: z.array(UuidSchema).min(1).max(1e3)
+}).strict();
+z.object({
+  executionId: UuidSchema,
+  configSnapshot: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var AcqListResponseSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  batchIds: z.array(z.string()),
+  instantlyCampaignId: z.string().nullable(),
+  /** Lifecycle status (draft | enriching | launched | closing | archived). */
+  status: ListStatusSchema,
+  metadata: AcqListMetadataSchema,
+  launchedAt: z.string().nullable(),
+  completedAt: z.string().nullable(),
+  createdAt: z.string(),
+  /** Scraping criteria stored as jsonb on the row. */
+  scrapingConfig: ScrapingConfigSchema,
+  /** ICP / qualification rubric stored as jsonb on the row. */
+  icp: IcpRubricSchema,
+  /** Pipeline presentation contract stored as jsonb on the row. */
+  pipelineConfig: PipelineConfigSchema
+});
+z.array(AcqListResponseSchema);
+z.array(ListTelemetrySchema);
+var ListStageProgressSchema = z.object({
+  total: z.number().int().min(0),
+  attempted: z.number().int().min(0),
+  success: z.number().int().min(0),
+  noResult: z.number().int().min(0),
+  skipped: z.number().int().min(0),
+  error: z.number().int().min(0),
+  other: z.number().int().min(0),
+  notAttempted: z.number().int().min(0)
+});
+z.object({
+  totalMembers: z.number().int().min(0),
+  totalCompanies: z.number().int().min(0),
+  byCompanyStage: z.record(z.string(), ListStageProgressSchema),
+  byContactStage: z.record(z.string(), ListStageProgressSchema)
+});
+var ListExecutionSummarySchema = z.object({
+  executionId: z.string(),
+  resourceId: z.string(),
+  status: z.string(),
+  createdAt: z.string(),
+  completedAt: z.string().nullable(),
+  durationMs: z.number().int().nullable(),
+  input: z.unknown().nullable().optional()
+});
+z.array(ListExecutionSummarySchema);
+var QueryBooleanSchema = z.preprocess((value) => {
+  if (value === "true" || value === "1" || value === true) return true;
+  if (value === "false" || value === "0" || value === false) return false;
+  return value;
+}, z.boolean());
+var AcqCompanyStatusSchema = z.enum(["active", "invalid"]);
+var AcqContactStatusSchema = z.enum(["active", "invalid"]);
+var AcqEmailValidSchema = z.enum(["VALID", "INVALID", "RISKY", "UNKNOWN"]);
+z.object({
+  companyId: UuidSchema
+});
+z.object({
+  contactId: UuidSchema
+});
+z.object({
+  search: z.string().trim().min(1).max(200).optional(),
+  listId: UuidSchema.optional(),
+  domain: z.string().trim().min(1).max(255).optional(),
+  website: z.string().trim().min(1).max(2048).optional(),
+  segment: z.string().trim().min(1).max(255).optional(),
+  category: z.string().trim().min(1).max(255).optional(),
+  pipelineStatus: z.unknown().optional(),
+  batchId: z.string().trim().min(1).max(255).optional(),
+  status: AcqCompanyStatusSchema.optional(),
+  includeAll: QueryBooleanSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(5e3).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+}).strict();
+z.object({
+  search: z.string().trim().min(1).max(200).optional(),
+  listId: UuidSchema.optional(),
+  openingLineIsNull: QueryBooleanSchema.optional(),
+  batchId: z.string().trim().min(1).max(255).optional(),
+  contactStatus: AcqContactStatusSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(5e3).default(5e3),
+  offset: z.coerce.number().int().min(0).default(0)
+}).strict();
+z.object({
+  name: z.string().trim().min(1).max(255),
+  domain: z.string().trim().min(1).max(255).optional(),
+  linkedinUrl: z.string().trim().url().optional(),
+  website: z.string().trim().url().optional(),
+  numEmployees: z.number().int().min(0).optional(),
+  foundedYear: z.number().int().optional(),
+  locationCity: z.string().trim().min(1).max(255).optional(),
+  locationState: z.string().trim().min(1).max(255).optional(),
+  category: z.string().trim().min(1).max(255).optional(),
+  source: z.string().trim().min(1).max(255).optional(),
+  batchId: z.string().trim().min(1).max(255).optional(),
+  pipelineStatus: z.unknown().optional(),
+  verticalResearch: z.string().trim().min(1).max(5e3).optional()
+}).strict();
+z.object({
+  name: z.string().trim().min(1).max(255).optional(),
+  domain: z.string().trim().min(1).max(255).optional(),
+  linkedinUrl: z.string().trim().url().optional(),
+  website: z.string().trim().url().optional(),
+  numEmployees: z.number().int().min(0).optional(),
+  foundedYear: z.number().int().optional(),
+  locationCity: z.string().trim().min(1).max(255).optional(),
+  locationState: z.string().trim().min(1).max(255).optional(),
+  category: z.string().trim().min(1).max(255).optional(),
+  segment: z.string().trim().min(1).max(255).optional(),
+  processingState: CompanyProcessingStateSchema.optional(),
+  pipelineStatus: z.unknown().optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).optional(),
+  source: z.string().trim().min(1).max(255).optional(),
+  batchId: z.string().trim().min(1).max(255).optional(),
+  status: AcqCompanyStatusSchema.optional(),
+  verticalResearch: z.string().trim().min(1).max(5e3).nullable().optional()
+}).strict().refine(
+  (data) => data.name !== void 0 || data.domain !== void 0 || data.linkedinUrl !== void 0 || data.website !== void 0 || data.numEmployees !== void 0 || data.foundedYear !== void 0 || data.locationCity !== void 0 || data.locationState !== void 0 || data.category !== void 0 || data.segment !== void 0 || data.processingState !== void 0 || data.pipelineStatus !== void 0 || data.enrichmentData !== void 0 || data.source !== void 0 || data.batchId !== void 0 || data.status !== void 0 || data.verticalResearch !== void 0,
+  {
+    message: "At least one field must be provided"
+  }
+);
+z.object({
+  email: z.string().trim().email(),
+  companyId: UuidSchema.optional(),
+  firstName: z.string().trim().min(1).max(255).optional(),
+  lastName: z.string().trim().min(1).max(255).optional(),
+  linkedinUrl: z.string().trim().url().optional(),
+  title: z.string().trim().min(1).max(255).optional(),
+  source: z.string().trim().min(1).max(255).optional(),
+  sourceId: z.string().trim().min(1).max(255).optional(),
+  batchId: z.string().trim().min(1).max(255).optional(),
+  pipelineStatus: z.unknown().optional()
+}).strict();
+z.object({
+  companyId: UuidSchema.optional(),
+  emailValid: AcqEmailValidSchema.optional(),
+  firstName: z.string().trim().min(1).max(255).optional(),
+  lastName: z.string().trim().min(1).max(255).optional(),
+  linkedinUrl: z.string().trim().url().optional(),
+  title: z.string().trim().min(1).max(255).optional(),
+  headline: z.string().trim().min(1).max(5e3).optional(),
+  filterReason: z.string().trim().min(1).max(5e3).optional(),
+  openingLine: z.string().trim().min(1).max(5e3).optional(),
+  processingState: ContactProcessingStateSchema.optional(),
+  pipelineStatus: z.unknown().optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).optional(),
+  status: AcqContactStatusSchema.optional()
+}).strict().refine(
+  (data) => data.companyId !== void 0 || data.emailValid !== void 0 || data.firstName !== void 0 || data.lastName !== void 0 || data.linkedinUrl !== void 0 || data.title !== void 0 || data.headline !== void 0 || data.filterReason !== void 0 || data.openingLine !== void 0 || data.processingState !== void 0 || data.pipelineStatus !== void 0 || data.enrichmentData !== void 0 || data.status !== void 0,
+  {
+    message: "At least one field must be provided"
+  }
+);
+var AcqCompanyResponseSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  name: z.string(),
+  domain: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  website: z.string().nullable(),
+  numEmployees: z.number().nullable(),
+  foundedYear: z.number().nullable(),
+  locationCity: z.string().nullable(),
+  locationState: z.string().nullable(),
+  category: z.string().nullable(),
+  categoryPain: z.string().nullable(),
+  segment: z.string().nullable(),
+  processingState: CompanyProcessingStateSchema.nullable(),
+  pipelineStatus: z.unknown().nullable().optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).nullable(),
+  source: z.string().nullable(),
+  batchId: z.string().nullable(),
+  status: AcqCompanyStatusSchema,
+  contactCount: z.number().int().min(0),
+  verticalResearch: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+z.object({
+  data: z.array(AcqCompanyResponseSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+z.object({
+  segments: z.array(z.string()),
+  categories: z.array(z.string()),
+  statuses: z.array(AcqCompanyStatusSchema)
+});
+var AcqContactCompanySummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  domain: z.string().nullable(),
+  website: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  segment: z.string().nullable(),
+  category: z.string().nullable(),
+  status: AcqCompanyStatusSchema
+});
+var AcqContactResponseSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  companyId: z.string().nullable(),
+  email: z.string(),
+  emailValid: AcqEmailValidSchema.nullable(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  title: z.string().nullable(),
+  headline: z.string().nullable(),
+  filterReason: z.string().nullable(),
+  openingLine: z.string().nullable(),
+  source: z.string().nullable(),
+  sourceId: z.string().nullable(),
+  processingState: ContactProcessingStateSchema.nullable(),
+  pipelineStatus: z.unknown().nullable().optional(),
+  enrichmentData: z.record(z.string(), z.unknown()).nullable(),
+  attioPersonId: z.string().nullable(),
+  batchId: z.string().nullable(),
+  status: AcqContactStatusSchema,
+  company: AcqContactCompanySummarySchema.nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+z.object({
+  data: z.array(AcqContactResponseSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+var AcqArtifactOwnerKindSchema = z.enum(["company", "contact", "deal", "list", "list_member"]);
+z.object({
+  ownerKind: AcqArtifactOwnerKindSchema,
+  ownerId: UuidSchema
+}).strict();
+z.object({
+  ownerKind: AcqArtifactOwnerKindSchema,
+  ownerId: UuidSchema,
+  kind: z.string().trim().min(1).max(255),
+  content: z.record(z.string(), z.unknown()),
+  sourceExecutionId: UuidSchema.optional()
+}).strict();
+var AcqArtifactResponseSchema = z.object({
+  id: z.string(),
+  organizationId: z.string(),
+  ownerKind: z.string(),
+  ownerId: z.string(),
+  kind: z.string(),
+  content: z.record(z.string(), z.unknown()),
+  sourceExecutionId: z.string().nullable(),
+  createdBy: z.string().nullable(),
+  createdAt: z.string(),
+  version: z.number().int()
+});
+z.object({
+  artifacts: z.array(AcqArtifactResponseSchema)
+});
+z.object({
+  limit: z.coerce.number().int().min(1).max(500).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+}).strict();
+z.object({
+  memberId: UuidSchema
+});
+var AcqListMemberContactSummarySchema = z.object({
+  id: z.string(),
+  email: z.string(),
+  firstName: z.string().nullable(),
+  lastName: z.string().nullable(),
+  title: z.string().nullable(),
+  linkedinUrl: z.string().nullable(),
+  companyId: z.string().nullable()
+});
+var AcqListMemberResponseSchema = z.object({
+  id: z.string(),
+  listId: z.string(),
+  contactId: z.string(),
+  pipelineKey: z.string(),
+  stageKey: z.string(),
+  stateKey: z.string(),
+  activityLog: z.unknown(),
+  addedAt: z.string(),
+  addedBy: z.string().nullable(),
+  sourceExecutionId: z.string().nullable(),
+  contact: AcqListMemberContactSummarySchema.nullable()
+});
+z.object({
+  members: z.array(AcqListMemberResponseSchema)
+});
+z.object({
+  listCompanyId: UuidSchema
+});
+z.object({
+  id: z.string(),
+  listId: z.string(),
+  companyId: z.string(),
+  pipelineKey: z.string(),
+  stageKey: z.string(),
+  stateKey: z.string(),
+  activityLog: z.unknown(),
+  addedAt: z.string(),
+  addedBy: z.string().nullable(),
+  sourceExecutionId: z.string().nullable()
+});
 var RETRYABLE_CODES = /* @__PURE__ */ new Set([
   "rate_limit_exceeded",
   "network_error",
@@ -5067,7 +6251,9 @@ var list = createAdapter("list", [
   "getConfig",
   "recordExecution",
   "updateCompanyStage",
-  "updateContactStage"
+  "updateContactStage",
+  "listPendingCompanyIds",
+  "listPendingContactIds"
 ]);
 
 // src/worker/adapters/pdf.ts
@@ -5081,6 +6267,191 @@ var execution = createAdapter("execution", ["trigger", "triggerAsync"]);
 
 // src/worker/adapters/email.ts
 var email = createAdapter("email", ["send"]);
+var listBuilderStageKeys = Object.keys(LEAD_GEN_STAGE_CATALOG);
+var ListBuilderStageKeySchema = z.enum(listBuilderStageKeys);
+
+// src/worker/list-builder-workflow.ts
+var ListBuilderResultSchema = z.object({
+  entity: z.enum(["company", "contact"]),
+  id: z.string().min(1),
+  status: ProcessingStageStatusSchema,
+  stageKey: ListBuilderStageKeySchema.optional(),
+  data: z.unknown().optional()
+});
+var ListBuilderResultsSchema = z.array(ListBuilderResultSchema);
+function getObjectShape(schema) {
+  const candidate = schema;
+  if ("shape" in candidate && candidate.shape && typeof candidate.shape === "object") {
+    return candidate.shape;
+  }
+  return null;
+}
+function assertNoReservedInputKeys(schema) {
+  const shape = getObjectShape(schema);
+  if (!shape) {
+    return;
+  }
+  const reservedKeys = ["params", "batch"].filter((key) => Object.prototype.hasOwnProperty.call(shape, key));
+  if (reservedKeys.length > 0) {
+    throw new Error(`listBuilderWorkflow inputSchema cannot define reserved top-level key(s): ${reservedKeys.join(", ")}`);
+  }
+}
+function resolveListAdapter(context) {
+  const contextWithAdapters = context;
+  return contextWithAdapters.adapters?.list ?? list;
+}
+function getRecordId(record) {
+  return record.id;
+}
+function assertResultStageTarget(result, defaultStageKey) {
+  const stageKey = result.stageKey ?? defaultStageKey;
+  const catalogEntry = LEAD_GEN_STAGE_CATALOG[stageKey];
+  if (!catalogEntry) {
+    throw new Error(`listBuilderWorkflow result stageKey "${stageKey}" is not in LEAD_GEN_STAGE_CATALOG`);
+  }
+  if (catalogEntry.entity !== result.entity) {
+    throw new Error(
+      `listBuilderWorkflow result for ${result.entity} "${result.id}" targets ${catalogEntry.entity} stage "${stageKey}"; set result.stageKey to a ${result.entity} stage`
+    );
+  }
+  return stageKey;
+}
+async function filterPendingRecords(records, params, context, options) {
+  if (params.forceRefresh) {
+    return records;
+  }
+  if (!params.listId) {
+    if (params.batchId) {
+      context.logger.warn(
+        `[list-builder] batchId-only input for stage "${options.buildStep.stageKey}" cannot apply pending-ID filter; processing loaded records without resolving batchId to listId.`
+      );
+    }
+    return records;
+  }
+  const listAdapter = resolveListAdapter(context);
+  const limit = typeof params.limit === "number" ? params.limit : void 0;
+  const pendingIds = options.buildStep.primaryEntity === "company" ? await listAdapter.listPendingCompanyIds({ listId: params.listId, stageKey: options.buildStep.stageKey, limit }) : await listAdapter.listPendingContactIds({ listId: params.listId, stageKey: options.buildStep.stageKey, limit });
+  const pending = new Set(pendingIds);
+  return records.filter((record) => pending.has(getRecordId(record)));
+}
+async function dispatchResults(envelope, context) {
+  if (!envelope.batch.listId) {
+    if (envelope.results.length > 0) {
+      context.logger.warn(
+        `[list-builder] stage "${envelope.batch.stageKey}" produced ${envelope.results.length} result(s), but no listId was provided; stage updates were skipped.`
+      );
+    }
+    return envelope.results;
+  }
+  const listAdapter = resolveListAdapter(context);
+  for (const result of envelope.results) {
+    const stage = assertResultStageTarget(result, envelope.batch.stageKey);
+    if (result.entity === "company") {
+      await listAdapter.updateCompanyStage({
+        listId: envelope.batch.listId,
+        companyId: result.id,
+        stage,
+        status: result.status,
+        ...result.data !== void 0 ? { data: result.data } : {},
+        executionId: context.executionId
+      });
+      continue;
+    }
+    await listAdapter.updateContactStage({
+      listId: envelope.batch.listId,
+      contactId: result.id,
+      stage,
+      status: result.status,
+      ...result.data !== void 0 ? { data: result.data } : {},
+      executionId: context.executionId
+    });
+  }
+  return envelope.results;
+}
+function listBuilderWorkflow(options) {
+  const stageKey = ListBuilderStageKeySchema.parse(options.buildStep.stageKey);
+  assertNoReservedInputKeys(options.inputSchema);
+  const outputSchema = options.outputSchema ?? ListBuilderResultsSchema;
+  const batchSchema = z.object({
+    records: z.array(z.object({ id: z.string().min(1) }).passthrough()),
+    stageKey: ListBuilderStageKeySchema,
+    listId: z.string().optional()
+  });
+  const envelopeSchema = z.object({
+    params: options.inputSchema,
+    batch: batchSchema,
+    results: ListBuilderResultsSchema
+  });
+  return {
+    config: options.config,
+    contract: {
+      inputSchema: options.inputSchema,
+      outputSchema
+    },
+    stageImplemented: stageKey,
+    steps: {
+      "prepare-batch": {
+        id: "prepare-batch",
+        name: `Prepare ${options.buildStep.label}`,
+        description: `Load and filter records for ${options.buildStep.label}.`,
+        inputSchema: options.inputSchema,
+        outputSchema: envelopeSchema,
+        handler: async (rawInput, context) => {
+          const params = options.inputSchema.parse(rawInput);
+          const runtimeContext = context;
+          const initialRecords = await options.loadRecords(params, context);
+          const additionallyFilteredRecords = options.additionalFilter ? await options.additionalFilter(initialRecords, params) : initialRecords;
+          const records = await filterPendingRecords(
+            additionallyFilteredRecords,
+            params,
+            runtimeContext,
+            options
+          );
+          return {
+            params,
+            batch: {
+              records,
+              stageKey,
+              listId: params.listId
+            },
+            results: []
+          };
+        },
+        next: { type: "linear", target: "run-handler" }
+      },
+      "run-handler": {
+        id: "run-handler",
+        name: options.buildStep.label,
+        description: options.buildStep.description ?? `Process ${options.buildStep.label}.`,
+        inputSchema: envelopeSchema,
+        outputSchema: envelopeSchema,
+        handler: async (rawInput, context) => {
+          const envelope = envelopeSchema.parse(rawInput);
+          const results = await options.handler(envelope, context);
+          return {
+            ...envelope,
+            results: ListBuilderResultsSchema.parse(results)
+          };
+        },
+        next: { type: "linear", target: "dispatch-results" }
+      },
+      "dispatch-results": {
+        id: "dispatch-results",
+        name: `Dispatch ${options.buildStep.label} Results`,
+        description: `Persist ${options.buildStep.stageKey} processing-state results.`,
+        inputSchema: envelopeSchema,
+        outputSchema,
+        handler: async (rawInput, context) => {
+          const envelope = envelopeSchema.parse(rawInput);
+          const results = await dispatchResults(envelope, context);
+          return outputSchema.parse(results);
+        },
+        next: null
+      }
+    },
+    entryPoint: "prepare-batch"
+  };
+}
 
 // src/worker/index.ts
 function captureConsole(executionId, logs) {
@@ -5452,4 +6823,4 @@ if (workerData != null && workerData.kind === "static") {
   })();
 }
 
-export { PlatformToolError, acqDb, approval, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, list, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };
+export { ListBuilderResultSchema, ListBuilderResultsSchema, PlatformToolError, acqDb, approval, createAdapter, createAnymailfinderAdapter, createApifyAdapter, createAttioAdapter, createDropboxAdapter, createGmailAdapter, createGoogleSheetsAdapter, createInstantlyAdapter, createMillionVerifierAdapter, createResendAdapter, createSignatureApiAdapter, createStripeAdapter, createTombaAdapter, crm, email, executeWorkflow, execution, list, listBuilderWorkflow, llm, notifications, pdf, platform, projects, scheduler, startWorker, storage };