@elevasis/sdk 1.16.0 → 1.18.0

package/dist/test-utils/index.js

@@ -5560,6 +5560,29 @@ function estimateTokens(text) {
   const chars4 = content.length;
   return Math.ceil(chars4 / 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;
@@ -6488,6 +6511,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((a3, b2) => a3.order - b2.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, index2) => {
+    if (stepIds.has(step.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `duplicate build-plan step id "${step.id}"`,
+        path: ["steps", index2, "id"]
+      });
+    }
+    stepIds.add(step.id);
+  });
+  snapshot.steps.forEach((step, index2) => {
+    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", index2, "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",
@@ -6821,7 +8005,9 @@ createAdapter("list", [
   "getConfig",
   "recordExecution",
   "updateCompanyStage",
-  "updateContactStage"
+  "updateContactStage",
+  "listPendingCompanyIds",
+  "listPendingContactIds"
 ]);
 
 // src/worker/adapters/pdf.ts
@@ -6836,728 +8022,740 @@ createAdapter("execution", ["trigger", "triggerAsync"]);
 // src/worker/adapters/email.ts
 createAdapter("email", ["send"]);
 
-// src/worker/index.ts
-function captureConsole(executionId, logs) {
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const origError = console.error;
-  const postLog = (level, message, logContext) => {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const entry = { level, message, timestamp, context: logContext };
-    logs.push(entry);
-    parentPort?.postMessage({
-      type: "log",
-      entry: { level, message, timestamp, executionId, context: logContext }
-    });
-  };
-  const capture = (level, orig) => (...args) => {
-    postLog(level, args.map(String).join(" "));
-    orig(...args);
-  };
-  console.log = capture("info", origLog);
-  console.warn = capture("warn", origWarn);
-  console.error = capture("error", origError);
-  return {
-    restore: () => {
-      console.log = origLog;
-      console.warn = origWarn;
-      console.error = origError;
-    },
-    postLog
-  };
-}
-var LOG_STRING_TRUNCATE_LIMIT = 200;
-function truncateForLogging(value) {
-  if (value === null || value === void 0) return value;
-  if (typeof value === "string") {
-    return value.length > LOG_STRING_TRUNCATE_LIMIT ? value.slice(0, LOG_STRING_TRUNCATE_LIMIT) + `\u2026 [${value.length} chars]` : value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(truncateForLogging);
+// ../core/src/platform/registry/validation.ts
+var RegistryValidationError = class extends Error {
+  constructor(orgName, resourceId, field, message) {
+    super(message);
+    this.orgName = orgName;
+    this.resourceId = resourceId;
+    this.field = field;
+    this.name = "RegistryValidationError";
   }
-  if (typeof value === "object") {
-    const result = {};
-    for (const [k2, v2] of Object.entries(value)) {
-      result[k2] = truncateForLogging(v2);
+};
+function validateDeploymentSpec(orgName, resources) {
+  const seenIds = /* @__PURE__ */ new Set();
+  resources.workflows?.forEach((workflow) => {
+    const id = workflow.config.resourceId;
+    if (seenIds.has(id)) {
+      throw new RegistryValidationError(
+        orgName,
+        id,
+        null,
+        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+      );
     }
-    return result;
-  }
-  return value;
+    seenIds.add(id);
+    if ("modelConfig" in workflow && workflow.modelConfig) {
+      validateResourceModelConfig(orgName, id, workflow.modelConfig);
+    }
+    if (workflow.interface) {
+      validateExecutionInterface(orgName, id, workflow.interface, workflow.contract.inputSchema);
+    }
+  });
+  resources.agents?.forEach((agent) => {
+    const id = agent.config.resourceId;
+    if (seenIds.has(id)) {
+      throw new RegistryValidationError(
+        orgName,
+        id,
+        null,
+        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+      );
+    }
+    seenIds.add(id);
+    validateResourceModelConfig(orgName, id, agent.modelConfig);
+    if (agent.interface) {
+      validateExecutionInterface(orgName, id, agent.interface, agent.contract.inputSchema);
+    }
+  });
 }
-function resolveNext(next, data) {
-  if (next === null) return null;
-  if (next.type === "linear") return next.target;
-  for (const route of next.routes) {
-    if (route.condition(data)) return route.target;
+function validateResourceModelConfig(orgName, resourceId, modelConfig) {
+  try {
+    validateModelConfig(modelConfig);
+  } catch (error) {
+    if (error instanceof ModelConfigError) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        error.field,
+        `Invalid model config in ${orgName}/${resourceId}: ${error.message} (field: ${error.field})`
+      );
+    }
+    throw error;
   }
-  return next.default;
 }
-function safeZodToJsonSchema(schema) {
-  if (!schema || typeof schema !== "object" || !("parse" in schema)) return void 0;
-  try {
-    const result = zodToJsonSchema(schema, { $refStrategy: "none", errorMessages: true });
-    if (result && typeof result === "object" && Object.keys(result).some((k2) => k2 !== "$schema")) {
-      return result;
-    }
-  } catch {
+function validateExecutionInterface(orgName, resourceId, executionInterface, inputSchema) {
+  const form = executionInterface.form;
+  const fieldMappings = form.fieldMappings ?? {};
+  const schemaShape = extractZodShape(inputSchema);
+  if (!schemaShape) {
+    return;
   }
-  return void 0;
-}
-function serializeNext(next) {
-  if (next === null) return null;
-  if (next.type === "linear") return { type: "linear", target: next.target };
-  return { type: "conditional", routes: next.routes.map((r2) => ({ target: r2.target })), default: next.default };
-}
-async function executeWorkflow(workflow, input, context) {
-  const logs = [];
-  const { restore, postLog } = captureConsole(context.executionId, logs);
-  try {
-    let currentData = workflow.contract.inputSchema ? workflow.contract.inputSchema.parse(input) : input;
-    let stepId = workflow.entryPoint;
-    while (stepId !== null) {
-      const step = workflow.steps[stepId];
-      if (!step) {
-        throw new Error(`Step '${stepId}' not found in workflow '${workflow.config.resourceId}'`);
-      }
-      const stepStartTime = Date.now();
-      const stepInput = step.inputSchema.parse(currentData);
-      postLog("info", `Step '${step.name}' started`, {
-        type: "workflow",
-        contextType: "step-started",
-        stepId: step.id,
-        stepStatus: "started",
-        input: truncateForLogging(stepInput),
-        startTime: stepStartTime
-      });
-      try {
-        const rawOutput = await step.handler(stepInput, {
-          executionId: context.executionId,
-          organizationId: context.organizationId,
-          organizationName: context.organizationName,
-          resourceId: workflow.config.resourceId,
-          sessionId: context.sessionId,
-          sessionTurnNumber: context.sessionTurnNumber,
-          parentExecutionId: context.parentExecutionId,
-          executionDepth: context.executionDepth,
-          adapters: context.adapters,
-          store: /* @__PURE__ */ new Map(),
-          logger: {
-            debug: (msg) => console.log(`[debug] ${msg}`),
-            info: (msg) => console.log(`[info] ${msg}`),
-            warn: (msg) => console.warn(`[warn] ${msg}`),
-            error: (msg) => console.error(`[error] ${msg}`)
-          }
-        });
-        currentData = step.outputSchema.parse(rawOutput);
-        const stepEndTime = Date.now();
-        const nextStepId = resolveNext(step.next, currentData);
-        postLog("info", `Step '${step.name}' completed (${stepEndTime - stepStartTime}ms)`, {
-          type: "workflow",
-          contextType: "step-completed",
-          stepId: step.id,
-          stepStatus: "completed",
-          output: truncateForLogging(currentData),
-          duration: stepEndTime - stepStartTime,
-          isTerminal: nextStepId === null,
-          startTime: stepStartTime,
-          endTime: stepEndTime
-        });
-        if (step.next?.type === "conditional" && nextStepId !== null) {
-          postLog("info", `Routing from '${step.name}' to '${nextStepId}'`, {
-            type: "workflow",
-            contextType: "conditional-route",
-            stepId: step.id,
-            target: nextStepId
-          });
+  const schemaFieldNames = Object.keys(schemaShape);
+  const formToSchemaMap = /* @__PURE__ */ new Map();
+  for (const field of form.fields) {
+    const schemaKey = fieldMappings[field.name] ?? field.name;
+    formToSchemaMap.set(field.name, schemaKey);
+  }
+  for (const schemaFieldName of schemaFieldNames) {
+    const schemaField = schemaShape[schemaFieldName];
+    const isRequired = !isZodOptional(schemaField);
+    let hasFormField = false;
+    for (const [formFieldName, mappedSchemaName] of Array.from(formToSchemaMap.entries())) {
+      if (mappedSchemaName === schemaFieldName) {
+        hasFormField = true;
+        const formField = form.fields.find((f4) => f4.name === formFieldName);
+        if (isRequired && !formField?.required) {
+          throw new RegistryValidationError(
+            orgName,
+            resourceId,
+            `interface.form.fields.${formFieldName}`,
+            `ExecutionInterface field "${formFieldName}" should be required to match inputSchema field "${schemaFieldName}" in ${orgName}/${resourceId}`
+          );
         }
-        stepId = nextStepId;
-      } catch (err) {
-        const stepEndTime = Date.now();
-        postLog("error", `Step '${step.name}' failed: ${String(err)}`, {
-          type: "workflow",
-          contextType: "step-failed",
-          stepId: step.id,
-          stepStatus: "failed",
-          error: String(err),
-          duration: stepEndTime - stepStartTime,
-          startTime: stepStartTime,
-          endTime: stepEndTime
-        });
-        throw err;
+        break;
       }
     }
-    if (workflow.contract.outputSchema) {
-      currentData = workflow.contract.outputSchema.parse(currentData);
+    if (isRequired && !hasFormField) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        "interface.form.fields",
+        `ExecutionInterface missing required field "${schemaFieldName}" from inputSchema in ${orgName}/${resourceId}`
+      );
     }
-    return { output: currentData, logs };
-  } finally {
-    restore();
   }
-}
-function buildWorkerExecutionContext(params) {
-  const { executionId } = params;
-  const postLog = (level, message) => {
-    parentPort.postMessage({
-      type: "log",
-      entry: { level, message, timestamp: (/* @__PURE__ */ new Date()).toISOString(), executionId }
-    });
-  };
-  return {
-    executionId: params.executionId,
-    organizationId: params.organizationId,
-    organizationName: params.organizationName,
-    resourceId: params.resourceId,
-    sessionId: params.sessionId,
-    sessionTurnNumber: params.sessionTurnNumber,
-    parentExecutionId: params.parentExecutionId,
-    executionDepth: params.executionDepth,
-    signal: params.signal,
-    store: /* @__PURE__ */ new Map(),
-    logger: {
-      debug: (msg) => {
-        console.log(`[debug] ${msg}`);
-        postLog("info", msg);
-      },
-      info: (msg) => {
-        console.log(`[info] ${msg}`);
-        postLog("info", msg);
-      },
-      warn: (msg) => {
-        console.warn(`[warn] ${msg}`);
-        postLog("warn", msg);
-      },
-      error: (msg) => {
-        console.error(`[error] ${msg}`);
-        postLog("error", msg);
-      }
-    },
-    onMessageEvent: async (event) => {
-      parentPort.postMessage({ type: "message-event", executionId, event });
+  for (const [formFieldName, schemaFieldName] of Array.from(formToSchemaMap.entries())) {
+    if (schemaFieldName.includes(".")) {
+      const topLevelField = schemaFieldName.split(".")[0];
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        `interface.form.fields.${formFieldName}`,
+        `ExecutionInterface field "${formFieldName}" uses nested notation. Flatten the inputSchema by moving nested fields to top-level (e.g., "${topLevelField}.x" \u2192 "x") in ${orgName}/${resourceId}`
+      );
     }
-  };
-}
-function startWorker(org) {
-  const workflows = new Map((org.workflows ?? []).map((w2) => [w2.config.resourceId, w2]));
-  const agents = new Map((org.agents ?? []).map((a3) => [a3.config.resourceId, a3]));
-  let localAbortController = new AbortController();
-  console.log(`[SDK-WORKER] Worker started with ${workflows.size} workflow(s), ${agents.size} agent(s)`);
-  parentPort.on("message", async (msg) => {
-    if (msg.type === "manifest") {
-      parentPort.postMessage({
-        type: "manifest",
-        workflows: (org.workflows ?? []).map((w2) => ({
-          resourceId: w2.config.resourceId,
-          name: w2.config.name,
-          type: w2.config.type,
-          status: w2.config.status,
-          description: w2.config.description,
-          version: w2.config.version,
-          links: w2.config.links,
-          category: w2.config.category,
-          contract: {
-            inputSchema: safeZodToJsonSchema(w2.contract?.inputSchema),
-            outputSchema: safeZodToJsonSchema(w2.contract?.outputSchema)
-          },
-          steps: Object.values(w2.steps).map((step) => ({
-            id: step.id,
-            name: step.name,
-            description: step.description,
-            inputSchema: safeZodToJsonSchema(step.inputSchema),
-            outputSchema: safeZodToJsonSchema(step.outputSchema),
-            next: serializeNext(step.next)
-          })),
-          entryPoint: w2.entryPoint
-        })),
-        agents: (org.agents ?? []).map((a3) => ({
-          resourceId: a3.config.resourceId,
-          name: a3.config.name,
-          type: a3.config.type,
-          status: a3.config.status,
-          description: a3.config.description,
-          version: a3.config.version,
-          links: a3.config.links,
-          category: a3.config.category,
-          contract: {
-            inputSchema: safeZodToJsonSchema(a3.contract?.inputSchema),
-            outputSchema: safeZodToJsonSchema(a3.contract?.outputSchema)
-          }
-        })),
-        triggers: org.triggers ?? [],
-        integrations: org.integrations ?? [],
-        humanCheckpoints: org.humanCheckpoints ?? [],
-        relationships: org.relationships ?? void 0
-      });
-      return;
+    if (!schemaFieldNames.includes(schemaFieldName)) {
+      throw new RegistryValidationError(
+        orgName,
+        resourceId,
+        `interface.form.fields.${formFieldName}`,
+        `ExecutionInterface field "${formFieldName}" maps to non-existent schema field "${schemaFieldName}" in ${orgName}/${resourceId}`
+      );
     }
-    if (msg.type === "tool-result") {
-      handleToolResult(msg);
-      return;
+  }
+}
+function extractZodShape(schema) {
+  if ("shape" in schema && typeof schema.shape === "object") {
+    return schema.shape;
+  }
+  if ("_def" in schema) {
+    const def = schema._def;
+    if (def.innerType) {
+      return extractZodShape(def.innerType);
     }
-    if (msg.type === "credential-result") {
-      handleCredentialResult(msg);
-      return;
+    if (def.schema) {
+      return extractZodShape(def.schema);
     }
-    if (msg.type === "abort") {
-      console.log("[SDK-WORKER] Abort requested by parent");
-      localAbortController.abort();
-      return;
-    }
-    if (msg.type === "execute") {
-      const {
-        resourceId,
-        executionId,
-        input,
-        organizationId,
-        organizationName,
-        sessionId,
-        sessionTurnNumber,
-        parentExecutionId,
-        executionDepth
-      } = msg;
-      console.log(`[SDK-WORKER] Execute request: resourceId=${resourceId}, executionId=${executionId}`);
-      localAbortController = new AbortController();
-      const workflow = workflows.get(resourceId);
-      if (workflow) {
-        const startTime = Date.now();
-        try {
-          console.log(`[SDK-WORKER] Running workflow '${resourceId}' (${Object.keys(workflow.steps).length} steps)`);
-          const { output, logs } = await executeWorkflow(workflow, input, {
-            executionId,
-            organizationId: organizationId ?? "",
-            organizationName: organizationName ?? "",
-            sessionId,
-            sessionTurnNumber,
-            parentExecutionId,
-            executionDepth: executionDepth ?? 0
-          });
-          const durationMs = Date.now() - startTime;
-          console.log(`[SDK-WORKER] Workflow '${resourceId}' completed (${durationMs}ms)`);
-          parentPort.postMessage({ type: "result", status: "completed", output, logs, metrics: { durationMs } });
-        } catch (err) {
-          const durationMs = Date.now() - startTime;
-          console.error(`[SDK-WORKER] Workflow '${resourceId}' failed (${durationMs}ms): ${String(err)}`);
-          parentPort.postMessage({
-            type: "result",
-            status: "failed",
-            error: String(err),
-            logs: [],
-            metrics: { durationMs }
-          });
-        }
-        return;
-      }
-      const agentDef = agents.get(resourceId);
-      if (agentDef) {
-        const logs = [];
-        const { restore } = captureConsole(executionId, logs);
-        const startTime = Date.now();
-        try {
-          console.log(`[SDK-WORKER] Running agent '${resourceId}' (${agentDef.tools.length} tools)`);
-          const adapterFactory = createPostMessageAdapterFactory();
-          const agentInstance = new Agent(agentDef, adapterFactory);
-          const context = buildWorkerExecutionContext({
-            executionId,
-            organizationId: organizationId ?? "",
-            organizationName: organizationName ?? "",
-            resourceId,
-            sessionId,
-            sessionTurnNumber,
-            parentExecutionId,
-            executionDepth: executionDepth ?? 0,
-            signal: localAbortController.signal
-          });
-          const output = await agentInstance.execute(input, context);
-          const durationMs = Date.now() - startTime;
-          console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
-          parentPort.postMessage({ type: "result", status: "completed", output, logs, metrics: { durationMs } });
-        } catch (err) {
-          const durationMs = Date.now() - startTime;
-          const errorMessage = err?.message ?? String(err);
-          err?.code ?? "unknown";
-          const errorName = err?.name ?? err?.constructor?.name ?? "Error";
-          console.error(`[SDK-WORKER] Agent '${resourceId}' failed (${durationMs}ms): [${errorName}] ${errorMessage}`);
-          parentPort.postMessage({
-            type: "result",
-            status: "failed",
-            error: `${errorName}: ${errorMessage}`,
-            logs,
-            metrics: { durationMs }
-          });
-        } finally {
-          restore();
-        }
-        return;
-      }
-      console.error(`[SDK-WORKER] Resource not found: ${resourceId}`);
-      parentPort.postMessage({
-        type: "result",
-        status: "failed",
-        error: `Resource not found: ${resourceId}`,
-        logs: []
-      });
-    }
-  });
+  }
+  return null;
 }
-if (workerData != null && workerData.kind === "static") {
-  const { modulePath } = workerData;
-  void (async () => {
-    const mod = await import(modulePath);
-    startWorker(mod.default);
-  })();
+function isZodOptional(schema) {
+  return schema.isOptional();
 }
-
-// src/test-utils/workflow.ts
-function extractStepEvents(logs) {
-  return logs.flatMap((log) => {
-    const context = log.context;
-    if (!context || context.type !== "workflow" || typeof context.contextType !== "string") {
-      return [];
-    }
-    return [
-      {
-        type: context.contextType,
-        stepId: typeof context.stepId === "string" ? context.stepId : void 0,
-        stepStatus: typeof context.stepStatus === "string" ? context.stepStatus : void 0,
-        input: context.input,
-        output: context.output,
-        error: context.error,
-        duration: typeof context.duration === "number" ? context.duration : void 0,
-        target: typeof context.target === "string" ? context.target : void 0,
-        raw: context
-      }
-    ];
-  });
+function validateRelationships(orgName, resources) {
+  if (!resources.relationships && !resources.triggers && !resources.externalResources && !resources.humanCheckpoints)
+    return;
+  const validAgentIds = new Set(resources.agents?.map((a3) => a3.config.resourceId) ?? []);
+  const validWorkflowIds = new Set(resources.workflows?.map((w2) => w2.config.resourceId) ?? []);
+  const validIntegrationIds = new Set(resources.integrations?.map((i) => i.resourceId) ?? []);
+  const validTriggerIds = new Set(resources.triggers?.map((t) => t.resourceId) ?? []);
+  const allInternalIds = /* @__PURE__ */ new Set([
+    ...Array.from(validAgentIds),
+    ...Array.from(validWorkflowIds),
+    ...Array.from(validTriggerIds),
+    ...Array.from(validIntegrationIds)
+  ]);
+  validateTriggers(orgName, resources.triggers ?? []);
+  validateResourceRelationships(
+    orgName,
+    resources.relationships ?? {},
+    validAgentIds,
+    validWorkflowIds,
+    validIntegrationIds,
+    validTriggerIds
+  );
+  validateExternalResources(
+    orgName,
+    resources.externalResources ?? [],
+    allInternalIds,
+    validAgentIds,
+    validWorkflowIds,
+    validIntegrationIds
+  );
+  validateHumanCheckpoints(orgName, resources.humanCheckpoints ?? [], allInternalIds, validAgentIds, validWorkflowIds);
 }
-async function runWorkflow(definition, input, options = {}) {
-  const context = options.context ?? {};
-  const { output, logs } = await executeWorkflow(definition, input, {
-    executionId: context.executionId ?? `test-${Date.now()}`,
-    organizationId: context.organizationId ?? "test-org",
-    organizationName: context.organizationName ?? "Test Organization",
-    sessionId: context.sessionId,
-    sessionTurnNumber: context.sessionTurnNumber,
-    parentExecutionId: context.parentExecutionId,
-    executionDepth: context.executionDepth ?? 0,
-    adapters: options.adapters
-  });
-  return {
-    output,
-    logs,
-    stepEvents: extractStepEvents(logs)
-  };
+function validateTriggers(_orgName, _triggers, _validAgentIds, _validWorkflowIds) {
 }
-
-// ../core/src/platform/registry/validation.ts
-var RegistryValidationError = class extends Error {
-  constructor(orgName, resourceId, field, message) {
-    super(message);
-    this.orgName = orgName;
-    this.resourceId = resourceId;
-    this.field = field;
-    this.name = "RegistryValidationError";
-  }
-};
-function validateDeploymentSpec(orgName, resources) {
-  const seenIds = /* @__PURE__ */ new Set();
-  resources.workflows?.forEach((workflow) => {
-    const id = workflow.config.resourceId;
-    if (seenIds.has(id)) {
+function validateResourceRelationships(orgName, relationships, validAgentIds, validWorkflowIds, validIntegrationIds, validTriggerIds) {
+  for (const [resourceId, declaration] of Object.entries(relationships)) {
+    const resourceExists = validAgentIds.has(resourceId) || validWorkflowIds.has(resourceId) || validTriggerIds.has(resourceId);
+    if (!resourceExists) {
       throw new RegistryValidationError(
         orgName,
-        id,
+        resourceId,
         null,
-        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+        `[${orgName}] Relationship declared for non-existent resource: ${resourceId}`
       );
     }
-    seenIds.add(id);
-    if ("modelConfig" in workflow && workflow.modelConfig) {
-      validateResourceModelConfig(orgName, id, workflow.modelConfig);
-    }
-    if (workflow.interface) {
-      validateExecutionInterface(orgName, id, workflow.interface, workflow.contract.inputSchema);
-    }
-  });
-  resources.agents?.forEach((agent) => {
-    const id = agent.config.resourceId;
-    if (seenIds.has(id)) {
+    declaration.triggers?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "triggers.agents",
+          `[${orgName}] Resource '${resourceId}' triggers non-existent agent: ${agentId}`
+        );
+      }
+    });
+    declaration.triggers?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "triggers.workflows",
+          `[${orgName}] Resource '${resourceId}' triggers non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    declaration.uses?.integrations?.forEach((integrationId) => {
+      if (!validIntegrationIds.has(integrationId)) {
+        throw new RegistryValidationError(
+          orgName,
+          resourceId,
+          "uses.integrations",
+          `[${orgName}] Resource '${resourceId}' uses non-existent integration: ${integrationId}`
+        );
+      }
+    });
+  }
+}
+function validateExternalResources(orgName, externalResources, allInternalIds, validAgentIds, validWorkflowIds, validIntegrationIds) {
+  externalResources.forEach((external) => {
+    if (allInternalIds.has(external.resourceId)) {
       throw new RegistryValidationError(
         orgName,
-        id,
+        external.resourceId,
         null,
-        `Duplicate resourceId "${id}" in organization "${orgName}". Workflows and agents must have unique IDs within an organization.`
+        `[${orgName}] External resource ID '${external.resourceId}' conflicts with internal resource ID`
       );
     }
-    seenIds.add(id);
-    validateResourceModelConfig(orgName, id, agent.modelConfig);
-    if (agent.interface) {
-      validateExecutionInterface(orgName, id, agent.interface, agent.contract.inputSchema);
-    }
+    external.triggers?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "triggers.agents",
+          `[${orgName}] External resource '${external.resourceId}' triggers non-existent agent: ${agentId}`
+        );
+      }
+    });
+    external.triggers?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "triggers.workflows",
+          `[${orgName}] External resource '${external.resourceId}' triggers non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    external.uses?.integrations?.forEach((integrationId) => {
+      if (!validIntegrationIds.has(integrationId)) {
+        throw new RegistryValidationError(
+          orgName,
+          external.resourceId,
+          "uses.integrations",
+          `[${orgName}] External resource '${external.resourceId}' uses non-existent integration: ${integrationId}`
+        );
+      }
+    });
   });
 }
-function validateResourceModelConfig(orgName, resourceId, modelConfig) {
-  try {
-    validateModelConfig(modelConfig);
-  } catch (error) {
-    if (error instanceof ModelConfigError) {
+function validateHumanCheckpoints(orgName, humanCheckpoints, allInternalIds, validAgentIds, validWorkflowIds) {
+  humanCheckpoints.forEach((humanCheckpoint) => {
+    if (allInternalIds.has(humanCheckpoint.resourceId)) {
       throw new RegistryValidationError(
         orgName,
-        resourceId,
-        error.field,
-        `Invalid model config in ${orgName}/${resourceId}: ${error.message} (field: ${error.field})`
+        humanCheckpoint.resourceId,
+        null,
+        `[${orgName}] Human checkpoint ID '${humanCheckpoint.resourceId}' conflicts with internal resource ID`
       );
     }
-    throw error;
-  }
+    humanCheckpoint.requestedBy?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "requestedBy.agents",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent agent: ${agentId}`
+        );
+      }
+    });
+    humanCheckpoint.requestedBy?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "requestedBy.workflows",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+    humanCheckpoint.routesTo?.agents?.forEach((agentId) => {
+      if (!validAgentIds.has(agentId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "routesTo.agents",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent agent: ${agentId}`
+        );
+      }
+    });
+    humanCheckpoint.routesTo?.workflows?.forEach((workflowId) => {
+      if (!validWorkflowIds.has(workflowId)) {
+        throw new RegistryValidationError(
+          orgName,
+          humanCheckpoint.resourceId,
+          "routesTo.workflows",
+          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent workflow: ${workflowId}`
+        );
+      }
+    });
+  });
 }
-function validateExecutionInterface(orgName, resourceId, executionInterface, inputSchema) {
-  const form = executionInterface.form;
-  const fieldMappings = form.fieldMappings ?? {};
-  const schemaShape = extractZodShape(inputSchema);
-  if (!schemaShape) {
-    return;
-  }
-  const schemaFieldNames = Object.keys(schemaShape);
-  const formToSchemaMap = /* @__PURE__ */ new Map();
-  for (const field of form.fields) {
-    const schemaKey = fieldMappings[field.name] ?? field.name;
-    formToSchemaMap.set(field.name, schemaKey);
+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()
+});
+z.array(ListBuilderResultSchema);
+
+// src/worker/index.ts
+function captureConsole(executionId, logs) {
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origError = console.error;
+  const postLog = (level, message, logContext) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { level, message, timestamp, context: logContext };
+    logs.push(entry);
+    parentPort?.postMessage({
+      type: "log",
+      entry: { level, message, timestamp, executionId, context: logContext }
+    });
+  };
+  const capture = (level, orig) => (...args) => {
+    postLog(level, args.map(String).join(" "));
+    orig(...args);
+  };
+  console.log = capture("info", origLog);
+  console.warn = capture("warn", origWarn);
+  console.error = capture("error", origError);
+  return {
+    restore: () => {
+      console.log = origLog;
+      console.warn = origWarn;
+      console.error = origError;
+    },
+    postLog
+  };
+}
+var LOG_STRING_TRUNCATE_LIMIT = 200;
+function truncateForLogging(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") {
+    return value.length > LOG_STRING_TRUNCATE_LIMIT ? value.slice(0, LOG_STRING_TRUNCATE_LIMIT) + `\u2026 [${value.length} chars]` : value;
   }
-  for (const schemaFieldName of schemaFieldNames) {
-    const schemaField = schemaShape[schemaFieldName];
-    const isRequired = !isZodOptional(schemaField);
-    let hasFormField = false;
-    for (const [formFieldName, mappedSchemaName] of Array.from(formToSchemaMap.entries())) {
-      if (mappedSchemaName === schemaFieldName) {
-        hasFormField = true;
-        const formField = form.fields.find((f4) => f4.name === formFieldName);
-        if (isRequired && !formField?.required) {
-          throw new RegistryValidationError(
-            orgName,
-            resourceId,
-            `interface.form.fields.${formFieldName}`,
-            `ExecutionInterface field "${formFieldName}" should be required to match inputSchema field "${schemaFieldName}" in ${orgName}/${resourceId}`
-          );
-        }
-        break;
-      }
-    }
-    if (isRequired && !hasFormField) {
-      throw new RegistryValidationError(
-        orgName,
-        resourceId,
-        "interface.form.fields",
-        `ExecutionInterface missing required field "${schemaFieldName}" from inputSchema in ${orgName}/${resourceId}`
-      );
-    }
+  if (Array.isArray(value)) {
+    return value.map(truncateForLogging);
   }
-  for (const [formFieldName, schemaFieldName] of Array.from(formToSchemaMap.entries())) {
-    if (schemaFieldName.includes(".")) {
-      const topLevelField = schemaFieldName.split(".")[0];
-      throw new RegistryValidationError(
-        orgName,
-        resourceId,
-        `interface.form.fields.${formFieldName}`,
-        `ExecutionInterface field "${formFieldName}" uses nested notation. Flatten the inputSchema by moving nested fields to top-level (e.g., "${topLevelField}.x" \u2192 "x") in ${orgName}/${resourceId}`
-      );
-    }
-    if (!schemaFieldNames.includes(schemaFieldName)) {
-      throw new RegistryValidationError(
-        orgName,
-        resourceId,
-        `interface.form.fields.${formFieldName}`,
-        `ExecutionInterface field "${formFieldName}" maps to non-existent schema field "${schemaFieldName}" in ${orgName}/${resourceId}`
-      );
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k2, v2] of Object.entries(value)) {
+      result[k2] = truncateForLogging(v2);
     }
+    return result;
   }
+  return value;
 }
-function extractZodShape(schema) {
-  if ("shape" in schema && typeof schema.shape === "object") {
-    return schema.shape;
+function resolveNext(next, data) {
+  if (next === null) return null;
+  if (next.type === "linear") return next.target;
+  for (const route of next.routes) {
+    if (route.condition(data)) return route.target;
   }
-  if ("_def" in schema) {
-    const def = schema._def;
-    if (def.innerType) {
-      return extractZodShape(def.innerType);
-    }
-    if (def.schema) {
-      return extractZodShape(def.schema);
+  return next.default;
+}
+function safeZodToJsonSchema(schema) {
+  if (!schema || typeof schema !== "object" || !("parse" in schema)) return void 0;
+  try {
+    const result = zodToJsonSchema(schema, { $refStrategy: "none", errorMessages: true });
+    if (result && typeof result === "object" && Object.keys(result).some((k2) => k2 !== "$schema")) {
+      return result;
     }
+  } catch {
   }
-  return null;
+  return void 0;
 }
-function isZodOptional(schema) {
-  return schema.isOptional();
+function serializeNext(next) {
+  if (next === null) return null;
+  if (next.type === "linear") return { type: "linear", target: next.target };
+  return { type: "conditional", routes: next.routes.map((r2) => ({ target: r2.target })), default: next.default };
 }
-function validateRelationships(orgName, resources) {
-  if (!resources.relationships && !resources.triggers && !resources.externalResources && !resources.humanCheckpoints)
-    return;
-  const validAgentIds = new Set(resources.agents?.map((a3) => a3.config.resourceId) ?? []);
-  const validWorkflowIds = new Set(resources.workflows?.map((w2) => w2.config.resourceId) ?? []);
-  const validIntegrationIds = new Set(resources.integrations?.map((i) => i.resourceId) ?? []);
-  const validTriggerIds = new Set(resources.triggers?.map((t) => t.resourceId) ?? []);
-  const allInternalIds = /* @__PURE__ */ new Set([
-    ...Array.from(validAgentIds),
-    ...Array.from(validWorkflowIds),
-    ...Array.from(validTriggerIds),
-    ...Array.from(validIntegrationIds)
-  ]);
-  validateTriggers(orgName, resources.triggers ?? []);
-  validateResourceRelationships(
-    orgName,
-    resources.relationships ?? {},
-    validAgentIds,
-    validWorkflowIds,
-    validIntegrationIds,
-    validTriggerIds
-  );
-  validateExternalResources(
-    orgName,
-    resources.externalResources ?? [],
-    allInternalIds,
-    validAgentIds,
-    validWorkflowIds,
-    validIntegrationIds
-  );
-  validateHumanCheckpoints(orgName, resources.humanCheckpoints ?? [], allInternalIds, validAgentIds, validWorkflowIds);
+async function executeWorkflow(workflow, input, context) {
+  const logs = [];
+  const { restore, postLog } = captureConsole(context.executionId, logs);
+  try {
+    let currentData = workflow.contract.inputSchema ? workflow.contract.inputSchema.parse(input) : input;
+    let stepId = workflow.entryPoint;
+    while (stepId !== null) {
+      const step = workflow.steps[stepId];
+      if (!step) {
+        throw new Error(`Step '${stepId}' not found in workflow '${workflow.config.resourceId}'`);
+      }
+      const stepStartTime = Date.now();
+      const stepInput = step.inputSchema.parse(currentData);
+      postLog("info", `Step '${step.name}' started`, {
+        type: "workflow",
+        contextType: "step-started",
+        stepId: step.id,
+        stepStatus: "started",
+        input: truncateForLogging(stepInput),
+        startTime: stepStartTime
+      });
+      try {
+        const rawOutput = await step.handler(stepInput, {
+          executionId: context.executionId,
+          organizationId: context.organizationId,
+          organizationName: context.organizationName,
+          resourceId: workflow.config.resourceId,
+          sessionId: context.sessionId,
+          sessionTurnNumber: context.sessionTurnNumber,
+          parentExecutionId: context.parentExecutionId,
+          executionDepth: context.executionDepth,
+          adapters: context.adapters,
+          store: /* @__PURE__ */ new Map(),
+          logger: {
+            debug: (msg) => console.log(`[debug] ${msg}`),
+            info: (msg) => console.log(`[info] ${msg}`),
+            warn: (msg) => console.warn(`[warn] ${msg}`),
+            error: (msg) => console.error(`[error] ${msg}`)
+          }
+        });
+        currentData = step.outputSchema.parse(rawOutput);
+        const stepEndTime = Date.now();
+        const nextStepId = resolveNext(step.next, currentData);
+        postLog("info", `Step '${step.name}' completed (${stepEndTime - stepStartTime}ms)`, {
+          type: "workflow",
+          contextType: "step-completed",
+          stepId: step.id,
+          stepStatus: "completed",
+          output: truncateForLogging(currentData),
+          duration: stepEndTime - stepStartTime,
+          isTerminal: nextStepId === null,
+          startTime: stepStartTime,
+          endTime: stepEndTime
+        });
+        if (step.next?.type === "conditional" && nextStepId !== null) {
+          postLog("info", `Routing from '${step.name}' to '${nextStepId}'`, {
+            type: "workflow",
+            contextType: "conditional-route",
+            stepId: step.id,
+            target: nextStepId
+          });
+        }
+        stepId = nextStepId;
+      } catch (err) {
+        const stepEndTime = Date.now();
+        postLog("error", `Step '${step.name}' failed: ${String(err)}`, {
+          type: "workflow",
+          contextType: "step-failed",
+          stepId: step.id,
+          stepStatus: "failed",
+          error: String(err),
+          duration: stepEndTime - stepStartTime,
+          startTime: stepStartTime,
+          endTime: stepEndTime
+        });
+        throw err;
+      }
+    }
+    if (workflow.contract.outputSchema) {
+      currentData = workflow.contract.outputSchema.parse(currentData);
+    }
+    return { output: currentData, logs };
+  } finally {
+    restore();
+  }
 }
-function validateTriggers(_orgName, _triggers, _validAgentIds, _validWorkflowIds) {
+function buildWorkerExecutionContext(params) {
+  const { executionId } = params;
+  const postLog = (level, message) => {
+    parentPort.postMessage({
+      type: "log",
+      entry: { level, message, timestamp: (/* @__PURE__ */ new Date()).toISOString(), executionId }
+    });
+  };
+  return {
+    executionId: params.executionId,
+    organizationId: params.organizationId,
+    organizationName: params.organizationName,
+    resourceId: params.resourceId,
+    sessionId: params.sessionId,
+    sessionTurnNumber: params.sessionTurnNumber,
+    parentExecutionId: params.parentExecutionId,
+    executionDepth: params.executionDepth,
+    signal: params.signal,
+    store: /* @__PURE__ */ new Map(),
+    logger: {
+      debug: (msg) => {
+        console.log(`[debug] ${msg}`);
+        postLog("info", msg);
+      },
+      info: (msg) => {
+        console.log(`[info] ${msg}`);
+        postLog("info", msg);
+      },
+      warn: (msg) => {
+        console.warn(`[warn] ${msg}`);
+        postLog("warn", msg);
+      },
+      error: (msg) => {
+        console.error(`[error] ${msg}`);
+        postLog("error", msg);
+      }
+    },
+    onMessageEvent: async (event) => {
+      parentPort.postMessage({ type: "message-event", executionId, event });
+    }
+  };
 }
-function validateResourceRelationships(orgName, relationships, validAgentIds, validWorkflowIds, validIntegrationIds, validTriggerIds) {
-  for (const [resourceId, declaration] of Object.entries(relationships)) {
-    const resourceExists = validAgentIds.has(resourceId) || validWorkflowIds.has(resourceId) || validTriggerIds.has(resourceId);
-    if (!resourceExists) {
-      throw new RegistryValidationError(
-        orgName,
-        resourceId,
-        null,
-        `[${orgName}] Relationship declared for non-existent resource: ${resourceId}`
-      );
+function startWorker(org) {
+  const workflows = new Map((org.workflows ?? []).map((w2) => [w2.config.resourceId, w2]));
+  const agents = new Map((org.agents ?? []).map((a3) => [a3.config.resourceId, a3]));
+  let localAbortController = new AbortController();
+  console.log(`[SDK-WORKER] Worker started with ${workflows.size} workflow(s), ${agents.size} agent(s)`);
+  parentPort.on("message", async (msg) => {
+    if (msg.type === "manifest") {
+      parentPort.postMessage({
+        type: "manifest",
+        workflows: (org.workflows ?? []).map((w2) => ({
+          resourceId: w2.config.resourceId,
+          name: w2.config.name,
+          type: w2.config.type,
+          status: w2.config.status,
+          description: w2.config.description,
+          version: w2.config.version,
+          links: w2.config.links,
+          category: w2.config.category,
+          contract: {
+            inputSchema: safeZodToJsonSchema(w2.contract?.inputSchema),
+            outputSchema: safeZodToJsonSchema(w2.contract?.outputSchema)
+          },
+          steps: Object.values(w2.steps).map((step) => ({
+            id: step.id,
+            name: step.name,
+            description: step.description,
+            inputSchema: safeZodToJsonSchema(step.inputSchema),
+            outputSchema: safeZodToJsonSchema(step.outputSchema),
+            next: serializeNext(step.next)
+          })),
+          entryPoint: w2.entryPoint
+        })),
+        agents: (org.agents ?? []).map((a3) => ({
+          resourceId: a3.config.resourceId,
+          name: a3.config.name,
+          type: a3.config.type,
+          status: a3.config.status,
+          description: a3.config.description,
+          version: a3.config.version,
+          links: a3.config.links,
+          category: a3.config.category,
+          contract: {
+            inputSchema: safeZodToJsonSchema(a3.contract?.inputSchema),
+            outputSchema: safeZodToJsonSchema(a3.contract?.outputSchema)
+          }
+        })),
+        triggers: org.triggers ?? [],
+        integrations: org.integrations ?? [],
+        humanCheckpoints: org.humanCheckpoints ?? [],
+        relationships: org.relationships ?? void 0
+      });
+      return;
+    }
+    if (msg.type === "tool-result") {
+      handleToolResult(msg);
+      return;
+    }
+    if (msg.type === "credential-result") {
+      handleCredentialResult(msg);
+      return;
+    }
+    if (msg.type === "abort") {
+      console.log("[SDK-WORKER] Abort requested by parent");
+      localAbortController.abort();
+      return;
     }
-    declaration.triggers?.agents?.forEach((agentId) => {
-      if (!validAgentIds.has(agentId)) {
-        throw new RegistryValidationError(
-          orgName,
-          resourceId,
-          "triggers.agents",
-          `[${orgName}] Resource '${resourceId}' triggers non-existent agent: ${agentId}`
-        );
-      }
-    });
-    declaration.triggers?.workflows?.forEach((workflowId) => {
-      if (!validWorkflowIds.has(workflowId)) {
-        throw new RegistryValidationError(
-          orgName,
-          resourceId,
-          "triggers.workflows",
-          `[${orgName}] Resource '${resourceId}' triggers non-existent workflow: ${workflowId}`
-        );
+    if (msg.type === "execute") {
+      const {
+        resourceId,
+        executionId,
+        input,
+        organizationId,
+        organizationName,
+        sessionId,
+        sessionTurnNumber,
+        parentExecutionId,
+        executionDepth
+      } = msg;
+      console.log(`[SDK-WORKER] Execute request: resourceId=${resourceId}, executionId=${executionId}`);
+      localAbortController = new AbortController();
+      const workflow = workflows.get(resourceId);
+      if (workflow) {
+        const startTime = Date.now();
+        try {
+          console.log(`[SDK-WORKER] Running workflow '${resourceId}' (${Object.keys(workflow.steps).length} steps)`);
+          const { output, logs } = await executeWorkflow(workflow, input, {
+            executionId,
+            organizationId: organizationId ?? "",
+            organizationName: organizationName ?? "",
+            sessionId,
+            sessionTurnNumber,
+            parentExecutionId,
+            executionDepth: executionDepth ?? 0
+          });
+          const durationMs = Date.now() - startTime;
+          console.log(`[SDK-WORKER] Workflow '${resourceId}' completed (${durationMs}ms)`);
+          parentPort.postMessage({ type: "result", status: "completed", output, logs, metrics: { durationMs } });
+        } catch (err) {
+          const durationMs = Date.now() - startTime;
+          console.error(`[SDK-WORKER] Workflow '${resourceId}' failed (${durationMs}ms): ${String(err)}`);
+          parentPort.postMessage({
+            type: "result",
+            status: "failed",
+            error: String(err),
+            logs: [],
+            metrics: { durationMs }
+          });
+        }
+        return;
       }
-    });
-    declaration.uses?.integrations?.forEach((integrationId) => {
-      if (!validIntegrationIds.has(integrationId)) {
-        throw new RegistryValidationError(
-          orgName,
-          resourceId,
-          "uses.integrations",
-          `[${orgName}] Resource '${resourceId}' uses non-existent integration: ${integrationId}`
-        );
+      const agentDef = agents.get(resourceId);
+      if (agentDef) {
+        const logs = [];
+        const { restore } = captureConsole(executionId, logs);
+        const startTime = Date.now();
+        try {
+          console.log(`[SDK-WORKER] Running agent '${resourceId}' (${agentDef.tools.length} tools)`);
+          const adapterFactory = createPostMessageAdapterFactory();
+          const agentInstance = new Agent(agentDef, adapterFactory);
+          const context = buildWorkerExecutionContext({
+            executionId,
+            organizationId: organizationId ?? "",
+            organizationName: organizationName ?? "",
+            resourceId,
+            sessionId,
+            sessionTurnNumber,
+            parentExecutionId,
+            executionDepth: executionDepth ?? 0,
+            signal: localAbortController.signal
+          });
+          const output = await agentInstance.execute(input, context);
+          const durationMs = Date.now() - startTime;
+          console.log(`[SDK-WORKER] Agent '${resourceId}' completed (${durationMs}ms)`);
+          parentPort.postMessage({ type: "result", status: "completed", output, logs, metrics: { durationMs } });
+        } catch (err) {
+          const durationMs = Date.now() - startTime;
+          const errorMessage = err?.message ?? String(err);
+          err?.code ?? "unknown";
+          const errorName = err?.name ?? err?.constructor?.name ?? "Error";
+          console.error(`[SDK-WORKER] Agent '${resourceId}' failed (${durationMs}ms): [${errorName}] ${errorMessage}`);
+          parentPort.postMessage({
+            type: "result",
+            status: "failed",
+            error: `${errorName}: ${errorMessage}`,
+            logs,
+            metrics: { durationMs }
+          });
+        } finally {
+          restore();
+        }
+        return;
       }
-    });
-  }
-}
-function validateExternalResources(orgName, externalResources, allInternalIds, validAgentIds, validWorkflowIds, validIntegrationIds) {
-  externalResources.forEach((external) => {
-    if (allInternalIds.has(external.resourceId)) {
-      throw new RegistryValidationError(
-        orgName,
-        external.resourceId,
-        null,
-        `[${orgName}] External resource ID '${external.resourceId}' conflicts with internal resource ID`
-      );
+      console.error(`[SDK-WORKER] Resource not found: ${resourceId}`);
+      parentPort.postMessage({
+        type: "result",
+        status: "failed",
+        error: `Resource not found: ${resourceId}`,
+        logs: []
+      });
     }
-    external.triggers?.agents?.forEach((agentId) => {
-      if (!validAgentIds.has(agentId)) {
-        throw new RegistryValidationError(
-          orgName,
-          external.resourceId,
-          "triggers.agents",
-          `[${orgName}] External resource '${external.resourceId}' triggers non-existent agent: ${agentId}`
-        );
-      }
-    });
-    external.triggers?.workflows?.forEach((workflowId) => {
-      if (!validWorkflowIds.has(workflowId)) {
-        throw new RegistryValidationError(
-          orgName,
-          external.resourceId,
-          "triggers.workflows",
-          `[${orgName}] External resource '${external.resourceId}' triggers non-existent workflow: ${workflowId}`
-        );
-      }
-    });
-    external.uses?.integrations?.forEach((integrationId) => {
-      if (!validIntegrationIds.has(integrationId)) {
-        throw new RegistryValidationError(
-          orgName,
-          external.resourceId,
-          "uses.integrations",
-          `[${orgName}] External resource '${external.resourceId}' uses non-existent integration: ${integrationId}`
-        );
-      }
-    });
   });
 }
-function validateHumanCheckpoints(orgName, humanCheckpoints, allInternalIds, validAgentIds, validWorkflowIds) {
-  humanCheckpoints.forEach((humanCheckpoint) => {
-    if (allInternalIds.has(humanCheckpoint.resourceId)) {
-      throw new RegistryValidationError(
-        orgName,
-        humanCheckpoint.resourceId,
-        null,
-        `[${orgName}] Human checkpoint ID '${humanCheckpoint.resourceId}' conflicts with internal resource ID`
-      );
+if (workerData != null && workerData.kind === "static") {
+  const { modulePath } = workerData;
+  void (async () => {
+    const mod = await import(modulePath);
+    startWorker(mod.default);
+  })();
+}
+
+// src/test-utils/workflow.ts
+function extractStepEvents(logs) {
+  return logs.flatMap((log) => {
+    const context = log.context;
+    if (!context || context.type !== "workflow" || typeof context.contextType !== "string") {
+      return [];
     }
-    humanCheckpoint.requestedBy?.agents?.forEach((agentId) => {
-      if (!validAgentIds.has(agentId)) {
-        throw new RegistryValidationError(
-          orgName,
-          humanCheckpoint.resourceId,
-          "requestedBy.agents",
-          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent agent: ${agentId}`
-        );
-      }
-    });
-    humanCheckpoint.requestedBy?.workflows?.forEach((workflowId) => {
-      if (!validWorkflowIds.has(workflowId)) {
-        throw new RegistryValidationError(
-          orgName,
-          humanCheckpoint.resourceId,
-          "requestedBy.workflows",
-          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' requestedBy non-existent workflow: ${workflowId}`
-        );
-      }
-    });
-    humanCheckpoint.routesTo?.agents?.forEach((agentId) => {
-      if (!validAgentIds.has(agentId)) {
-        throw new RegistryValidationError(
-          orgName,
-          humanCheckpoint.resourceId,
-          "routesTo.agents",
-          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent agent: ${agentId}`
-        );
-      }
-    });
-    humanCheckpoint.routesTo?.workflows?.forEach((workflowId) => {
-      if (!validWorkflowIds.has(workflowId)) {
-        throw new RegistryValidationError(
-          orgName,
-          humanCheckpoint.resourceId,
-          "routesTo.workflows",
-          `[${orgName}] Human checkpoint '${humanCheckpoint.resourceId}' routesTo non-existent workflow: ${workflowId}`
-        );
+    return [
+      {
+        type: context.contextType,
+        stepId: typeof context.stepId === "string" ? context.stepId : void 0,
+        stepStatus: typeof context.stepStatus === "string" ? context.stepStatus : void 0,
+        input: context.input,
+        output: context.output,
+        error: context.error,
+        duration: typeof context.duration === "number" ? context.duration : void 0,
+        target: typeof context.target === "string" ? context.target : void 0,
+        raw: context
       }
-    });
+    ];
+  });
+}
+async function runWorkflow(definition, input, options = {}) {
+  const context = options.context ?? {};
+  const { output, logs } = await executeWorkflow(definition, input, {
+    executionId: context.executionId ?? `test-${Date.now()}`,
+    organizationId: context.organizationId ?? "test-org",
+    organizationName: context.organizationName ?? "Test Organization",
+    sessionId: context.sessionId,
+    sessionTurnNumber: context.sessionTurnNumber,
+    parentExecutionId: context.parentExecutionId,
+    executionDepth: context.executionDepth ?? 0,
+    adapters: options.adapters
   });
+  return {
+    output,
+    logs,
+    stepEvents: extractStepEvents(logs)
+  };
 }
 
 // src/test-utils/registry.ts
@@ -24328,7 +25526,14 @@ var mockCrm = (overrides) => createMockAdapter(
   overrides
 );
 var mockList = (overrides) => createMockAdapter(
-  ["getConfig", "recordExecution", "updateCompanyStage", "updateContactStage"],
+  [
+    "getConfig",
+    "recordExecution",
+    "updateCompanyStage",
+    "updateContactStage",
+    "listPendingCompanyIds",
+    "listPendingContactIds"
+  ],
   overrides
 );
 var mockPdf = (overrides) => createMockAdapter(["render", "renderToBuffer"], overrides);