@elitedcs/ghl-mcp 3.35.0 → 3.36.0

package/dist/index.js

@@ -31,7 +31,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@elitedcs/ghl-mcp",
-      version: "3.35.0",
+      version: "3.36.0",
       mcpName: "io.github.drjerryrelth/ghl-command",
       description: "GoHighLevel MCP Server for Claude. 218 tools \u2014 full CRM, automation, marketing control, account-wide workflow audit, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
       main: "dist/index.js",
@@ -6106,30 +6106,31 @@ function buildUpdateFormPath(formId, locationId2) {
 function buildUpdateFormBody(name, formData) {
   return { name, formData };
 }
+async function formApiRequest(client, method, path7, body) {
+  const headers = await client.buildHeaders();
+  const url = `https://backend.leadconnectorhq.com/forms${path7}`;
+  const options = { method, headers };
+  if (body && (method === "POST" || method === "PUT")) {
+    options.body = JSON.stringify(body);
+  }
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    const text2 = await response.text();
+    throw new Error(`Form API Error ${response.status}: ${method} ${path7}
+${text2}`);
+  }
+  const text = await response.text();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return JSON.parse(text.replace(/[\x00-\x1F\x7F]/g, ""));
+  }
+}
 function registerFormBuilderTools(server2, builderClient, publicClient) {
   const client = builderClient;
   if (!client) return;
-  async function formRequest(method, path7, body) {
-    const headers = await client.buildHeaders();
-    const url = `https://backend.leadconnectorhq.com/forms${path7}`;
-    const options = { method, headers };
-    if (body && (method === "POST" || method === "PUT")) {
-      options.body = JSON.stringify(body);
-    }
-    const response = await fetch(url, options);
-    if (!response.ok) {
-      const text2 = await response.text();
-      throw new Error(`Form API Error ${response.status}: ${method} ${path7}
-${text2}`);
-    }
-    const text = await response.text();
-    if (!text) return {};
-    try {
-      return JSON.parse(text);
-    } catch {
-      return JSON.parse(text.replace(/[\x00-\x1F\x7F]/g, ""));
-    }
-  }
+  const formRequest = (method, path7, body) => formApiRequest(client, method, path7, body);
   server2.tool(
     "get_form_full",
     "Get a form with full builder data: all fields (labels, types, IDs, validation), conditional logic, auto-responder config, email notification settings, styling, and version history. This is the internal API \u2014 it returns everything the form builder UI shows.",
@@ -9617,6 +9618,1513 @@ function registerAccountHealthTools(server2, client) {
   );
 }
 
+// src/tools/intake-to-build.ts
+var import_zod53 = require("zod");
+
+// src/intake-to-build/question-set.ts
+var QUESTION_SET_VERSION = "0.1";
+var INTAKE_FIELD_NAME_PREFIX = "Intake: ";
+function deriveFieldKey(fieldName) {
+  const slug2 = fieldName.toLowerCase().replace(/[^a-z0-9 ]+/g, "").replace(/ /g, "_");
+  return `contact.${slug2}`;
+}
+function intakeFieldName(label) {
+  return `${INTAKE_FIELD_NAME_PREFIX}${label}`;
+}
+function expectedFieldKey(q) {
+  return deriveFieldKey(intakeFieldName(q.label));
+}
+var YES_NO = ["Yes", "No"];
+var BUSINESS_TYPES = [
+  "Med spa",
+  "Clinic / practice",
+  "Coach / consultant",
+  "Ecommerce",
+  "Local service",
+  "Agency",
+  "Other"
+];
+var TEAM_SIZES = ["Just me", "2-5", "6+"];
+var MONTHLY_LEAD_VOLUMES = ["Under 100", "100-500", "500-1000", "1000+"];
+var PRIMARY_GOALS = [
+  "Book appointments",
+  "Capture + nurture leads",
+  "Direct sales",
+  "Re-engage past clients",
+  "Other"
+];
+var FOLLOW_UP_STYLES = ["High-touch / multi-step", "Light", "Single confirmation"];
+var A2P_STATUSES = ["Not started", "In progress", "Approved", "Not needed"];
+var PAYMENT_PROCESSORS = [
+  "Stripe connected",
+  "Stripe not connected",
+  "Other",
+  "None"
+];
+var SOCIAL_CHANNELS = [
+  "Instagram",
+  "Facebook",
+  "TikTok",
+  "LinkedIn",
+  "YouTube",
+  "Google Business",
+  "Other"
+];
+var INTAKE_QUESTIONS = [
+  // ── Submitter identity (standard contact fields; not in the Brief) ──
+  {
+    key: "first_name",
+    label: "First Name",
+    section: "contact",
+    sectionLabel: "Your contact info",
+    required: true,
+    field: { kind: "standard", tag: "first_name" },
+    placeholder: "First name",
+    briefKind: "identity"
+  },
+  {
+    key: "last_name",
+    label: "Last Name",
+    section: "contact",
+    sectionLabel: "Your contact info",
+    required: false,
+    field: { kind: "standard", tag: "last_name" },
+    placeholder: "Last name",
+    briefKind: "identity"
+  },
+  {
+    key: "email",
+    label: "Email",
+    section: "contact",
+    sectionLabel: "Your contact info",
+    required: true,
+    field: { kind: "standard", tag: "email" },
+    placeholder: "you@business.com",
+    briefKind: "identity"
+  },
+  {
+    key: "phone",
+    label: "Phone",
+    section: "contact",
+    sectionLabel: "Your contact info",
+    required: false,
+    field: { kind: "standard", tag: "phone" },
+    placeholder: "Phone",
+    briefKind: "identity"
+  },
+  // ── Section A: Business basics ──
+  {
+    key: "business_name",
+    label: "Business Name",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: true,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "Your business name",
+    briefPath: "business.name",
+    briefKind: "string"
+  },
+  {
+    key: "business_type",
+    label: "Business Type",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: true,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: BUSINESS_TYPES,
+    briefPath: "business.type",
+    briefKind: "string"
+  },
+  {
+    key: "website",
+    label: "Website",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "https://",
+    briefPath: "business.website",
+    briefKind: "string"
+  },
+  {
+    key: "primary_location",
+    label: "Primary Location",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "City, State / Country",
+    briefPath: "business.location",
+    briefKind: "string"
+  },
+  {
+    key: "timezone",
+    label: "Timezone",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "e.g. America/Phoenix",
+    briefPath: "business.timezone",
+    briefKind: "string"
+  },
+  // A6–A8: ratified additions (atlas 2026-06-15, Jerry decision #1). All optional,
+  // additive under business.* (schemaVersion stays 0.1). fieldKeys live-captured on
+  // FXaoz 2026-06-16: contact.intake_team_size / _monthly_lead_volume / _business_hours.
+  {
+    key: "team_size",
+    label: "Team Size",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: TEAM_SIZES,
+    briefPath: "business.teamSize",
+    briefKind: "string"
+  },
+  {
+    key: "monthly_lead_volume",
+    label: "Monthly Lead Volume",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: MONTHLY_LEAD_VOLUMES,
+    briefPath: "business.monthlyLeadVolume",
+    briefKind: "string"
+  },
+  {
+    key: "business_hours",
+    label: "Business Hours",
+    section: "business",
+    sectionLabel: "Business basics",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "e.g. Mon-Fri 9-5; Sat 10-1",
+    briefPath: "business.hours",
+    briefKind: "string"
+  },
+  // ── Section B: Offer and pricing ──
+  {
+    key: "core_offer",
+    label: "Core Offer",
+    section: "offer",
+    sectionLabel: "Offer and pricing",
+    required: true,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "What you sell, in one or two sentences",
+    briefPath: "offer.summary",
+    briefKind: "string"
+  },
+  {
+    key: "price_points",
+    label: "Price Points",
+    section: "offer",
+    sectionLabel: "Offer and pricing",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Main offers + prices (one per line, e.g. Consult - $19)",
+    briefPath: "offer.pricePoints",
+    briefKind: "pricePoints"
+  },
+  {
+    key: "lead_magnet",
+    label: "Lead Magnet",
+    section: "offer",
+    sectionLabel: "Offer and pricing",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "Free thing you give to capture leads, if any",
+    briefPath: "offer.leadMagnet",
+    briefKind: "string"
+  },
+  {
+    key: "avg_deal_value",
+    label: "Average Deal Value",
+    section: "offer",
+    sectionLabel: "Offer and pricing",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "e.g. $350",
+    briefPath: "offer.avgDealValue",
+    briefKind: "string"
+  },
+  // ── Section C: Audience ──
+  {
+    key: "ideal_customer",
+    label: "Ideal Customer",
+    section: "audience",
+    sectionLabel: "Audience",
+    required: true,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Who you serve",
+    briefPath: "audience.ideal",
+    briefKind: "string"
+  },
+  {
+    key: "top_pain_points",
+    label: "Top Pain Points",
+    section: "audience",
+    sectionLabel: "Audience",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "The problems they come to you with (one per line)",
+    briefPath: "audience.painPoints",
+    briefKind: "list"
+  },
+  {
+    key: "objections",
+    label: "Objections",
+    section: "audience",
+    sectionLabel: "Audience",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Why prospects hesitate (one per line)",
+    briefPath: "audience.objections",
+    briefKind: "list"
+  },
+  // ── Section D: Goal and sales process ──
+  {
+    key: "primary_goal",
+    label: "Primary Goal",
+    section: "goal",
+    sectionLabel: "Goal and sales process",
+    required: true,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: PRIMARY_GOALS,
+    briefPath: "goal.primary",
+    briefKind: "string"
+  },
+  {
+    key: "sales_stages",
+    label: "Sales Stages",
+    section: "goal",
+    sectionLabel: "Goal and sales process",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Steps a lead moves through from new to won (one per line)",
+    briefPath: "goal.salesStages",
+    briefKind: "list"
+  },
+  {
+    key: "booking_needed",
+    label: "Do you need appointment booking?",
+    section: "goal",
+    sectionLabel: "Goal and sales process",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: YES_NO,
+    briefPath: "goal.bookingNeeded",
+    briefKind: "boolean"
+  },
+  {
+    key: "follow_up_style",
+    label: "Follow-up Style",
+    section: "goal",
+    sectionLabel: "Goal and sales process",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: FOLLOW_UP_STYLES,
+    briefPath: "goal.followUpStyle",
+    briefKind: "string"
+  },
+  // ── Section E: Channels and tech ──
+  {
+    key: "email_ready",
+    label: "Is your sending email / domain set up?",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: YES_NO,
+    briefPath: "channels.email",
+    briefKind: "boolean"
+  },
+  {
+    key: "sms_desired",
+    label: "Do you want to send SMS?",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: YES_NO,
+    briefPath: "channels.sms",
+    briefKind: "boolean"
+  },
+  {
+    key: "a2p_status",
+    label: "A2P registration status",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: A2P_STATUSES,
+    briefPath: "channels.a2pStatus",
+    briefKind: "string"
+  },
+  {
+    key: "payment_processor",
+    label: "Payment processor",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: PAYMENT_PROCESSORS,
+    briefPath: "channels.payment",
+    briefKind: "string"
+  },
+  {
+    key: "calendar_connected",
+    label: "Is a booking calendar already connected?",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "SINGLE_OPTIONS" },
+    options: YES_NO,
+    briefPath: "channels.calendarConnected",
+    briefKind: "boolean"
+  },
+  {
+    key: "social_channels",
+    label: "Which social platforms do you use?",
+    section: "channels",
+    sectionLabel: "Channels and tech",
+    required: false,
+    field: { kind: "custom", dataType: "MULTIPLE_OPTIONS" },
+    options: SOCIAL_CHANNELS,
+    briefPath: "channels.social",
+    briefKind: "multiselect"
+  },
+  // ── Section F: Assets on hand ──
+  {
+    key: "existing_pipeline",
+    label: "Existing pipeline?",
+    section: "assets",
+    sectionLabel: "Assets on hand",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Yes/No + describe",
+    briefPath: "assets.existingPipeline",
+    briefKind: "string"
+  },
+  {
+    key: "existing_workflows",
+    label: "Existing workflows (do not clobber)",
+    section: "assets",
+    sectionLabel: "Assets on hand",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Anything already built we should leave alone",
+    briefPath: "assets.existingWorkflows",
+    briefKind: "string"
+  },
+  {
+    key: "brand_assets",
+    label: "Brand Assets",
+    section: "assets",
+    sectionLabel: "Assets on hand",
+    required: false,
+    field: { kind: "custom", dataType: "TEXT" },
+    placeholder: "Logo / colors / domain available",
+    briefPath: "assets.brand",
+    briefKind: "string"
+  },
+  {
+    key: "anything_else",
+    label: "Anything else?",
+    section: "assets",
+    sectionLabel: "Assets on hand",
+    required: false,
+    field: { kind: "custom", dataType: "LARGE_TEXT" },
+    placeholder: "Anything else we should know",
+    briefPath: "assets.notes",
+    briefKind: "string"
+  }
+];
+var INTAKE_FORM_NAME = "GHL Command Blueprint \u2014 Client Intake";
+function customQuestions() {
+  return INTAKE_QUESTIONS.filter((q) => q.field.kind === "custom");
+}
+
+// src/intake-to-build/form-template.ts
+function slug(s) {
+  return s.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean).join("_");
+}
+function formFieldType(dataType) {
+  switch (dataType) {
+    case "TEXT":
+      return "text";
+    case "LARGE_TEXT":
+      return "large_text";
+    case "NUMERICAL":
+      return "numerical";
+    case "PHONE":
+      return "phone";
+    case "MONETORY":
+      return "monetary";
+    case "CHECKBOX":
+      return "checkbox";
+    case "SINGLE_OPTIONS":
+      return "single_options";
+    case "MULTIPLE_OPTIONS":
+      return "multiple_options";
+    case "DATE":
+      return "date";
+    case "FLOAT":
+      return "float";
+    default:
+      return "text";
+  }
+}
+var NO_BORDER = { border: 0, color: "FFFFFF", radius: 0, type: "none" };
+var NO_SHADOW = { blur: 0, color: "FFFFFF", horizontal: 0, spread: 0, vertical: 0 };
+function buildHeaderField(title, index) {
+  return {
+    active: false,
+    align: "left",
+    bgColor: "FFFFFF00",
+    border: { ...NO_BORDER },
+    hiddenFieldQueryKey: `header_${index}`,
+    label: `<h1 style="line-height: 1;padding-left: 0px!important;margin: 0;color: #000000;font-family: Roboto;font-weight: 400;"><span style="font-size: 18px; color: rgb(0, 0, 0)">${title}</span></h1>`,
+    padding: { bottom: 0, left: 0, right: 0, top: 0 },
+    placeholder: "header",
+    shadow: { ...NO_SHADOW },
+    standard: true,
+    tag: "header",
+    type: "h1",
+    typeLabel: "Text",
+    weight: 400
+  };
+}
+function buildStandardFormField(q) {
+  if (q.field.kind !== "standard") throw new Error(`buildStandardFormField: ${q.key} is not standard`);
+  const tag = q.field.tag;
+  const isEmail = tag === "email";
+  const isPhone = tag === "phone";
+  const base = {
+    fieldWidthPercentage: 100,
+    hiddenFieldQueryKey: tag,
+    label: q.label,
+    placeholder: q.placeholder ?? q.label,
+    required: q.required,
+    standard: true,
+    tag,
+    type: isEmail ? "email" : "text",
+    typeLabel: isEmail ? "Email" : isPhone ? "Phone" : "Text"
+  };
+  if (isPhone) base.enableCountryPicker = false;
+  return base;
+}
+function buildCustomFormField(q, record, locationId2, position) {
+  const type = formFieldType(record.dataType);
+  const field = {
+    Id: record.id,
+    id: record.id,
+    tag: record.id,
+    active: false,
+    allowCustomOption: false,
+    customFieldLabel: q.label,
+    dataType: record.dataType,
+    dateAdded: record.dateAdded ?? "",
+    description: "",
+    documentType: "field",
+    edit: false,
+    fieldKey: record.fieldKey,
+    fieldWidthPercentage: 100,
+    fieldsCount: 0,
+    hiddenFieldQueryKey: slug(record.name),
+    label: q.label,
+    locationId: locationId2,
+    model: record.model ?? "contact",
+    name: record.name,
+    parentId: record.parentId ?? "",
+    placeholder: q.placeholder ?? "",
+    position,
+    required: q.required,
+    showInForms: true,
+    standard: false,
+    type
+  };
+  const options = record.picklistOptions ?? q.options ?? void 0;
+  if (type === "single_options" || type === "multiple_options" || type === "checkbox") {
+    field.picklistOptions = options ? [...options] : [];
+  }
+  if (type === "multiple_options") {
+    field.calculatedOptions = (options ?? []).map((label) => ({ calculatedValue: "", label }));
+    field.category = "choiceElements";
+    field.typeLabel = "Multi Dropdown";
+  }
+  if (type === "phone") field.enableCountryPicker = false;
+  return field;
+}
+function buildSubmitButton(label = "Submit") {
+  return {
+    active: false,
+    align: "center",
+    bgColor: "101828FF",
+    border: 0,
+    borderColor: "101828FF",
+    borderRadius: 8,
+    borderType: "none",
+    color: "FFFFFFFF",
+    fieldWidthPercentage: 100,
+    fontFamily: "Inter",
+    fontSize: 14,
+    fullwidth: true,
+    hiddenFieldQueryKey: "button",
+    label: `<p style="padding-left: 0px!important;"><strong>${label}</strong></p>`,
+    padding: { bottom: 12, left: 20, right: 20, top: 12 },
+    placeholder: "Button",
+    radius: 8,
+    shadow: { blur: 2, color: "00000014", horizontal: 0, spread: 0, vertical: 1 },
+    standard: true,
+    subTextColor: "FFFFFFFF",
+    subTextFontFamily: "Inter",
+    subTextFontSize: 12,
+    subTextWeight: 400,
+    submitSubText: "",
+    tag: "button",
+    type: "submit",
+    weight: 500
+  };
+}
+function buildIntakeFormData(opts) {
+  const questions = opts.questions ?? INTAKE_QUESTIONS;
+  const fields = [];
+  let lastSection = "";
+  let headerIndex = 0;
+  let position = 0;
+  for (const q of questions) {
+    if (q.section !== lastSection) {
+      fields.push(buildHeaderField(q.sectionLabel, headerIndex++));
+      lastSection = q.section;
+    }
+    if (q.field.kind === "standard") {
+      fields.push(buildStandardFormField(q));
+    } else {
+      const record = opts.resolved.get(q.key);
+      if (!record) continue;
+      fields.push(buildCustomFormField(q, record, opts.locationId, position += 50));
+    }
+  }
+  fields.push(buildSubmitButton("Submit"));
+  return {
+    autoResponder: false,
+    emailNotifications: false,
+    form: {
+      fields,
+      formLabelVisible: true,
+      formAction: {
+        actionType: "2",
+        headerImageSrc: "",
+        mobileHeaderImageSrc: "",
+        redirectUrl: "",
+        thankyouText: "<p style='text-align:center;margin:0;'>Thanks! Your intake has been received.</p>"
+      }
+    }
+  };
+}
+
+// src/intake-to-build/brief.ts
+var import_zod51 = require("zod");
+var BRIEF_SCHEMA_VERSION = "0.1";
+var PRESETS = [
+  "generic",
+  "med_spa",
+  "clinic_launch_a2p",
+  "coach",
+  "ecom",
+  "agency"
+];
+var presetSchema = import_zod51.z.enum(PRESETS);
+var BRIEF_SOURCES = ["agency_os", "business_os", "intake_form", "hybrid"];
+var briefSourceSchema = import_zod51.z.enum(BRIEF_SOURCES);
+var pricePointSchema = import_zod51.z.object({
+  name: import_zod51.z.string(),
+  price: import_zod51.z.string()
+});
+var briefSchema = import_zod51.z.object({
+  schemaVersion: import_zod51.z.string(),
+  briefId: import_zod51.z.string(),
+  preset: presetSchema,
+  briefSource: briefSourceSchema,
+  /** Partner-OS deep structures (ICA / offer / brand-DNA), carried verbatim. */
+  extended: import_zod51.z.record(import_zod51.z.unknown()).optional(),
+  business: import_zod51.z.object({
+    name: import_zod51.z.string(),
+    type: import_zod51.z.string().optional(),
+    website: import_zod51.z.string().optional(),
+    location: import_zod51.z.string().optional(),
+    timezone: import_zod51.z.string().optional(),
+    // Ratified additions (atlas 2026-06-15). Enum-ish but kept as strings for
+    // the same tolerance reason as business.type (don't reject valid briefs).
+    teamSize: import_zod51.z.string().optional(),
+    monthlyLeadVolume: import_zod51.z.string().optional(),
+    hours: import_zod51.z.string().optional()
+  }).passthrough(),
+  offer: import_zod51.z.object({
+    summary: import_zod51.z.string().optional(),
+    // Parsed best-effort; tolerate a raw string when parsing was not possible.
+    pricePoints: import_zod51.z.union([import_zod51.z.array(pricePointSchema), import_zod51.z.string()]).optional(),
+    leadMagnet: import_zod51.z.string().optional(),
+    avgDealValue: import_zod51.z.string().optional()
+  }).passthrough().optional(),
+  audience: import_zod51.z.object({
+    ideal: import_zod51.z.string().optional(),
+    painPoints: import_zod51.z.array(import_zod51.z.string()).optional(),
+    objections: import_zod51.z.array(import_zod51.z.string()).optional()
+  }).passthrough().optional(),
+  goal: import_zod51.z.object({
+    // Kept as string: the form option labels are the canonical values, but
+    // the contract sample shortens some (e.g. "high-touch"). See §7 note.
+    primary: import_zod51.z.string(),
+    salesStages: import_zod51.z.array(import_zod51.z.string()).optional(),
+    bookingNeeded: import_zod51.z.boolean().optional(),
+    followUpStyle: import_zod51.z.string().optional()
+  }).passthrough(),
+  channels: import_zod51.z.object({
+    email: import_zod51.z.boolean().optional(),
+    sms: import_zod51.z.boolean().optional(),
+    a2pStatus: import_zod51.z.string().optional(),
+    payment: import_zod51.z.string().optional(),
+    calendarConnected: import_zod51.z.boolean().optional(),
+    social: import_zod51.z.array(import_zod51.z.string()).optional()
+  }).passthrough().optional(),
+  assets: import_zod51.z.object({
+    existingPipeline: import_zod51.z.string().optional(),
+    existingWorkflows: import_zod51.z.string().optional(),
+    brand: import_zod51.z.string().optional(),
+    notes: import_zod51.z.string().optional()
+  }).passthrough().optional(),
+  flags: import_zod51.z.array(import_zod51.z.string()).optional()
+}).strict();
+function validateBrief(input) {
+  const parsed = briefSchema.safeParse(input);
+  if (parsed.success) {
+    return { valid: true, errors: [], brief: parsed.data };
+  }
+  return {
+    valid: false,
+    errors: parsed.error.issues.map(
+      (i) => `${i.path.join(".") || "(root)"}: ${i.message}`
+    )
+  };
+}
+
+// src/intake-to-build/normalizer.ts
+function firstString(v) {
+  if (Array.isArray(v)) return v.length ? String(v[0]).trim() : void 0;
+  if (typeof v === "string") {
+    const t = v.trim();
+    return t.length ? t : void 0;
+  }
+  return void 0;
+}
+function splitList(text) {
+  return text.split(/\r?\n|;|•/).flatMap((line) => line.includes(",") && !/\d,\d/.test(line) ? line.split(",") : [line]).map((s) => s.replace(/^[\s\-*\d.)]+/, "").trim()).filter(Boolean);
+}
+function parsePricePoints(text) {
+  const out = [];
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    const m = t.match(/^(.*?)[\s]*[-—:|]\s*\$?\s*([\d,]+(?:\.\d+)?)/);
+    if (m) {
+      out.push({ name: m[1].trim(), price: m[2].replace(/,/g, "") });
+    } else {
+      const priceOnly = t.match(/\$?\s*([\d,]+(?:\.\d+)?)\s*$/);
+      out.push({
+        name: priceOnly ? t.slice(0, priceOnly.index).trim() || t : t,
+        price: priceOnly ? priceOnly[1].replace(/,/g, "") : ""
+      });
+    }
+  }
+  return out;
+}
+function coerceBoolean(v) {
+  const s = firstString(v);
+  if (s === void 0) return void 0;
+  if (/^(yes|true|y|1)$/i.test(s)) return true;
+  if (/^(no|false|n|0)$/i.test(s)) return false;
+  return void 0;
+}
+function coerceValue(raw, kind) {
+  switch (kind) {
+    case "string":
+      return firstString(raw);
+    case "boolean":
+      return coerceBoolean(raw);
+    case "list": {
+      const s = firstString(raw);
+      return s ? splitList(s) : void 0;
+    }
+    case "pricePoints": {
+      const s = firstString(raw);
+      return s ? parsePricePoints(s) : void 0;
+    }
+    case "multiselect": {
+      if (Array.isArray(raw)) {
+        const arr = raw.map((x) => String(x).trim()).filter(Boolean);
+        return arr.length ? arr : void 0;
+      }
+      const s = firstString(raw);
+      return s ? [s] : void 0;
+    }
+    case "identity":
+      return void 0;
+  }
+}
+function presetForBusinessType(type) {
+  switch ((type ?? "").toLowerCase()) {
+    case "med spa":
+      return "med_spa";
+    case "coach / consultant":
+      return "coach";
+    case "ecommerce":
+      return "ecom";
+    case "agency":
+      return "agency";
+    default:
+      return "generic";
+  }
+}
+function setPath(target, path7, value) {
+  if (value === void 0) return;
+  const parts = path7.split(".");
+  let node = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const k = parts[i];
+    if (typeof node[k] !== "object" || node[k] === null) node[k] = {};
+    node = node[k];
+  }
+  node[parts[parts.length - 1]] = value;
+}
+function deriveFlags(brief) {
+  const flags = [];
+  const channels = brief.channels ?? {};
+  const goal = brief.goal ?? {};
+  const a2p = typeof channels.a2pStatus === "string" ? channels.a2pStatus.toLowerCase() : "";
+  if (channels.sms === true && a2p !== "approved" && a2p !== "not needed") {
+    flags.push("needs_a2p");
+  }
+  if (channels.payment === "Stripe not connected") flags.push("stripe_not_connected");
+  if (goal.bookingNeeded === true && channels.calendarConnected !== true) {
+    flags.push("calendar_oauth_needed");
+  }
+  if (channels.email === false) flags.push("email_not_ready");
+  return flags;
+}
+function buildFieldMapFromFormFields(fields, questions = INTAKE_QUESTIONS) {
+  const byFieldKey = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    const fieldKey = typeof f.fieldKey === "string" ? f.fieldKey : void 0;
+    const id = typeof f.id === "string" ? f.id : typeof f.tag === "string" ? f.tag : void 0;
+    if (fieldKey && id) byFieldKey.set(fieldKey.toLowerCase(), id);
+  }
+  const map = {};
+  for (const q of questions) {
+    if (q.field.kind !== "custom") continue;
+    const id = byFieldKey.get(expectedFieldKey(q).toLowerCase());
+    if (id) map[q.key] = id;
+  }
+  return map;
+}
+function normalizeSubmissionToBrief(opts) {
+  const questions = opts.questions ?? INTAKE_QUESTIONS;
+  const brief = {
+    schemaVersion: BRIEF_SCHEMA_VERSION,
+    briefId: opts.briefId,
+    briefSource: "intake_form",
+    business: {},
+    goal: {}
+  };
+  for (const q of questions) {
+    if (!q.briefPath || q.briefKind === "identity") continue;
+    const rawKey = q.field.kind === "standard" ? q.field.tag : opts.fieldMap[q.key];
+    const raw = rawKey ? opts.others[rawKey] : void 0;
+    const value = coerceValue(raw, q.briefKind);
+    setPath(brief, q.briefPath, value);
+  }
+  const businessType = typeof brief.business?.type === "string" ? brief.business.type : void 0;
+  brief.preset = opts.preset ?? presetForBusinessType(businessType);
+  brief.flags = deriveFlags(brief);
+  return brief;
+}
+
+// src/intake-to-build/plan.ts
+var import_zod52 = require("zod");
+var REF_NAMESPACES = [
+  "pipeline",
+  "stage",
+  "field",
+  "tag",
+  "workflow",
+  "form",
+  "funnel",
+  "page",
+  "calendar",
+  "email",
+  "sms",
+  "cv",
+  "handoff"
+];
+var REF_RE = new RegExp(`^(${REF_NAMESPACES.join("|")})\\.[a-z0-9]+(_[a-z0-9]+)*$`);
+var refSchema = import_zod52.z.string().regex(REF_RE, "must be a <namespace>.<snake_case_slug> ref (no real GHL IDs)");
+function nsRef(ns) {
+  return import_zod52.z.string().regex(new RegExp(`^${ns}\\.[a-z0-9]+(_[a-z0-9]+)*$`), `must be a ${ns}.* ref`);
+}
+function refNamespace(ref) {
+  return ref.split(".")[0];
+}
+var stageSchema = import_zod52.z.object({
+  ref: nsRef("stage"),
+  name: import_zod52.z.string(),
+  position: import_zod52.z.number().int().nonnegative()
+});
+var pipelineSchema = import_zod52.z.object({
+  ref: nsRef("pipeline"),
+  name: import_zod52.z.string(),
+  stages: import_zod52.z.array(stageSchema).min(1)
+});
+var GHL_FIELD_DATATYPES = [
+  "TEXT",
+  "LARGE_TEXT",
+  "NUMERICAL",
+  "PHONE",
+  "MONETORY",
+  "CHECKBOX",
+  "SINGLE_OPTIONS",
+  "MULTIPLE_OPTIONS",
+  "FLOAT",
+  "DATE",
+  "TEXTBOX_LIST",
+  "FILE_UPLOAD",
+  "SIGNATURE"
+];
+var customFieldSchema = import_zod52.z.object({
+  ref: nsRef("field"),
+  name: import_zod52.z.string(),
+  dataType: import_zod52.z.enum(GHL_FIELD_DATATYPES),
+  model: import_zod52.z.enum(["contact", "opportunity"]).optional(),
+  options: import_zod52.z.array(import_zod52.z.string()).optional()
+});
+var tagSchema = import_zod52.z.object({
+  ref: nsRef("tag"),
+  name: import_zod52.z.string()
+});
+var customValueSchema = import_zod52.z.object({
+  ref: nsRef("cv"),
+  name: import_zod52.z.string(),
+  value: import_zod52.z.string().optional(),
+  filledBy: refSchema.optional()
+});
+var CALENDAR_TYPES = [
+  "round_robin",
+  "event",
+  "class_booking",
+  "collective",
+  "service_booking"
+];
+var openHoursBlockSchema = import_zod52.z.object({
+  daysOfTheWeek: import_zod52.z.array(import_zod52.z.number().int().min(0).max(6)),
+  hours: import_zod52.z.array(
+    import_zod52.z.object({
+      openHour: import_zod52.z.number().int().min(0).max(23),
+      openMinute: import_zod52.z.number().int().min(0).max(59),
+      closeHour: import_zod52.z.number().int().min(0).max(23),
+      closeMinute: import_zod52.z.number().int().min(0).max(59)
+    })
+  )
+});
+var calendarSchema = import_zod52.z.object({
+  ref: nsRef("calendar"),
+  name: import_zod52.z.string(),
+  calendarType: import_zod52.z.enum(CALENDAR_TYPES),
+  openHours: import_zod52.z.array(openHoursBlockSchema).optional(),
+  availabilityType: import_zod52.z.number().int().optional(),
+  requiresStaff: import_zod52.z.boolean().optional()
+});
+var formFieldSchema = import_zod52.z.discriminatedUnion("type", [
+  import_zod52.z.object({
+    type: import_zod52.z.literal("standard"),
+    key: import_zod52.z.string(),
+    required: import_zod52.z.boolean().optional()
+  }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("custom"),
+    fieldRef: nsRef("field"),
+    required: import_zod52.z.boolean().optional()
+  })
+]);
+var formSchema = import_zod52.z.object({
+  ref: nsRef("form"),
+  name: import_zod52.z.string(),
+  fields: import_zod52.z.array(formFieldSchema)
+});
+var pageSchema = import_zod52.z.object({
+  ref: nsRef("page"),
+  name: import_zod52.z.string(),
+  role: import_zod52.z.string().optional(),
+  outline: import_zod52.z.string().optional(),
+  formRef: nsRef("form").optional(),
+  calendarRef: nsRef("calendar").optional()
+});
+var funnelSchema = import_zod52.z.object({
+  ref: nsRef("funnel"),
+  name: import_zod52.z.string(),
+  pages: import_zod52.z.array(pageSchema)
+});
+var emailAssetSchema = import_zod52.z.object({
+  ref: nsRef("email"),
+  name: import_zod52.z.string(),
+  subject: import_zod52.z.string().optional(),
+  bodyOutline: import_zod52.z.string().optional(),
+  body: import_zod52.z.string().optional(),
+  mergeTags: import_zod52.z.array(import_zod52.z.string()).optional()
+});
+var smsAssetSchema = import_zod52.z.object({
+  ref: nsRef("sms"),
+  name: import_zod52.z.string(),
+  bodyOutline: import_zod52.z.string().optional(),
+  body: import_zod52.z.string().optional(),
+  mergeTags: import_zod52.z.array(import_zod52.z.string()).optional()
+});
+var waitUnit = import_zod52.z.enum(["minutes", "hours", "days"]);
+var actionSchema = import_zod52.z.discriminatedUnion("type", [
+  import_zod52.z.object({ type: import_zod52.z.literal("add_contact_tag"), tagRef: nsRef("tag") }),
+  import_zod52.z.object({ type: import_zod52.z.literal("remove_contact_tag"), tagRef: nsRef("tag") }),
+  import_zod52.z.object({ type: import_zod52.z.literal("send_email"), emailRef: nsRef("email") }),
+  import_zod52.z.object({ type: import_zod52.z.literal("send_sms"), smsRef: nsRef("sms") }),
+  import_zod52.z.object({ type: import_zod52.z.literal("wait"), value: import_zod52.z.number().positive(), unit: waitUnit }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("internal_notification"),
+    to: import_zod52.z.string(),
+    title: import_zod52.z.string(),
+    body: import_zod52.z.string()
+  }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("update_contact_field"),
+    fieldRef: nsRef("field"),
+    value: import_zod52.z.string()
+  }),
+  import_zod52.z.object({ type: import_zod52.z.literal("add_notes"), body: import_zod52.z.string() }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("task_notification"),
+    title: import_zod52.z.string(),
+    body: import_zod52.z.string().optional(),
+    dueDate: import_zod52.z.string().optional(),
+    assignedTo: import_zod52.z.string().optional()
+  }),
+  import_zod52.z.object({ type: import_zod52.z.literal("remove_from_workflow"), workflowRef: nsRef("workflow") }),
+  import_zod52.z.object({ type: import_zod52.z.literal("add_to_workflow"), workflowRef: nsRef("workflow") }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("create_opportunity"),
+    pipelineRef: nsRef("pipeline"),
+    stageRef: nsRef("stage"),
+    status: import_zod52.z.string().optional()
+  }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("update_opportunity"),
+    pipelineRef: nsRef("pipeline"),
+    stageRef: nsRef("stage")
+  }),
+  import_zod52.z.object({
+    type: import_zod52.z.literal("goal_event"),
+    goalCondition: import_zod52.z.string(),
+    action: import_zod52.z.string().optional()
+  })
+]);
+var triggerSchema = import_zod52.z.object({
+  type: import_zod52.z.string(),
+  formRef: nsRef("form").optional(),
+  tagRef: nsRef("tag").optional(),
+  calendarRef: nsRef("calendar").optional(),
+  pipelineRef: nsRef("pipeline").optional(),
+  stageRef: nsRef("stage").optional()
+});
+var workflowSchema = import_zod52.z.object({
+  ref: nsRef("workflow"),
+  name: import_zod52.z.string(),
+  trigger: triggerSchema.optional(),
+  stopOnResponse: import_zod52.z.boolean().optional(),
+  actions: import_zod52.z.array(actionSchema).max(40)
+  // house rule: <=40 actions/workflow
+});
+var handoffSchema = import_zod52.z.object({
+  ref: nsRef("handoff"),
+  owner: import_zod52.z.enum(["JERRY-UI", "JERRY-EXT", "SASHA"]),
+  title: import_zod52.z.string(),
+  trigger: import_zod52.z.string().optional(),
+  instruction: import_zod52.z.string(),
+  produces: refSchema.nullable().optional(),
+  successCheck: import_zod52.z.string(),
+  blocks: import_zod52.z.array(import_zod52.z.string()).optional()
+});
+var buildPlanSchema = import_zod52.z.object({
+  schemaVersion: import_zod52.z.string(),
+  planId: import_zod52.z.string(),
+  briefId: import_zod52.z.string(),
+  preset: import_zod52.z.string(),
+  summary: import_zod52.z.string().optional(),
+  pipelines: import_zod52.z.array(pipelineSchema).optional(),
+  customFields: import_zod52.z.array(customFieldSchema).optional(),
+  tags: import_zod52.z.array(tagSchema).optional(),
+  customValues: import_zod52.z.array(customValueSchema).optional(),
+  calendars: import_zod52.z.array(calendarSchema).optional(),
+  forms: import_zod52.z.array(formSchema).optional(),
+  funnels: import_zod52.z.array(funnelSchema).optional(),
+  emails: import_zod52.z.array(emailAssetSchema).optional(),
+  sms: import_zod52.z.array(smsAssetSchema).optional(),
+  workflows: import_zod52.z.array(workflowSchema).optional(),
+  handoffs: import_zod52.z.array(handoffSchema).optional(),
+  buildOrder: import_zod52.z.array(import_zod52.z.string()).optional(),
+  idMap: import_zod52.z.record(import_zod52.z.string()).optional()
+}).strict();
+function collectDefinedRefs(plan) {
+  const refs = /* @__PURE__ */ new Map();
+  const duplicates = [];
+  const add = (ref) => {
+    if (refs.has(ref)) duplicates.push(ref);
+    else refs.set(ref, refNamespace(ref));
+  };
+  for (const p of plan.pipelines ?? []) {
+    add(p.ref);
+    for (const s of p.stages) add(s.ref);
+  }
+  for (const f of plan.customFields ?? []) add(f.ref);
+  for (const t of plan.tags ?? []) add(t.ref);
+  for (const cv of plan.customValues ?? []) add(cv.ref);
+  for (const c of plan.calendars ?? []) add(c.ref);
+  for (const fm of plan.forms ?? []) add(fm.ref);
+  for (const fn of plan.funnels ?? []) {
+    add(fn.ref);
+    for (const pg of fn.pages) add(pg.ref);
+  }
+  for (const e of plan.emails ?? []) add(e.ref);
+  for (const s of plan.sms ?? []) add(s.ref);
+  for (const w of plan.workflows ?? []) add(w.ref);
+  for (const h of plan.handoffs ?? []) add(h.ref);
+  return { refs, duplicates };
+}
+function checkRefIntegrity(plan, defined) {
+  const errors = [];
+  let scanned = 0;
+  const check = (ref, expectNs, where) => {
+    if (ref === null || ref === void 0) return;
+    scanned++;
+    if (!defined.has(ref)) {
+      errors.push(`${where}: ref "${ref}" does not resolve to any defined ${expectNs}`);
+      return;
+    }
+    const ns = defined.get(ref);
+    if (expectNs !== "any" && ns !== expectNs) {
+      errors.push(`${where}: ref "${ref}" is a ${ns}, expected a ${expectNs}`);
+    }
+  };
+  const checkMaybeWildcard = (ref, where) => {
+    scanned++;
+    if (ref.endsWith(".*")) {
+      const ns = ref.slice(0, -2);
+      const known = REF_NAMESPACES;
+      if (!known.includes(ns)) {
+        errors.push(`${where}: "${ref}" is not a valid <namespace>.* wildcard`);
+      }
+      return;
+    }
+    if (!defined.has(ref)) {
+      errors.push(`${where}: ref "${ref}" does not resolve to any defined object`);
+    }
+  };
+  for (const cv of plan.customValues ?? []) {
+    if (cv.filledBy) check(cv.filledBy, "any", `customValues[${cv.ref}].filledBy`);
+  }
+  for (const fm of plan.forms ?? []) {
+    for (const fl of fm.fields) {
+      if (fl.type === "custom") check(fl.fieldRef, "field", `forms[${fm.ref}].fields`);
+    }
+  }
+  for (const fn of plan.funnels ?? []) {
+    for (const pg of fn.pages) {
+      check(pg.formRef, "form", `funnels[${fn.ref}].pages[${pg.ref}].formRef`);
+      check(pg.calendarRef, "calendar", `funnels[${fn.ref}].pages[${pg.ref}].calendarRef`);
+    }
+  }
+  for (const w of plan.workflows ?? []) {
+    if (w.trigger) {
+      const t = w.trigger;
+      check(t.formRef, "form", `workflows[${w.ref}].trigger.formRef`);
+      check(t.tagRef, "tag", `workflows[${w.ref}].trigger.tagRef`);
+      check(t.calendarRef, "calendar", `workflows[${w.ref}].trigger.calendarRef`);
+      check(t.pipelineRef, "pipeline", `workflows[${w.ref}].trigger.pipelineRef`);
+      check(t.stageRef, "stage", `workflows[${w.ref}].trigger.stageRef`);
+    }
+    w.actions.forEach((a, i) => {
+      const where = `workflows[${w.ref}].actions[${i}](${a.type})`;
+      if ("tagRef" in a) check(a.tagRef, "tag", where);
+      if ("emailRef" in a) check(a.emailRef, "email", where);
+      if ("smsRef" in a) check(a.smsRef, "sms", where);
+      if ("fieldRef" in a) check(a.fieldRef, "field", where);
+      if ("pipelineRef" in a) check(a.pipelineRef, "pipeline", where);
+      if ("stageRef" in a) check(a.stageRef, "stage", where);
+      if ("workflowRef" in a) check(a.workflowRef, "workflow", where);
+    });
+  }
+  for (const h of plan.handoffs ?? []) {
+    if (h.produces) check(h.produces, "any", `handoffs[${h.ref}].produces`);
+    for (const b of h.blocks ?? []) checkMaybeWildcard(b, `handoffs[${h.ref}].blocks`);
+  }
+  for (const b of plan.buildOrder ?? []) checkMaybeWildcard(b, "buildOrder");
+  return { errors, scanned };
+}
+function validateBuildPlan(input) {
+  const parsed = buildPlanSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      valid: false,
+      errors: parsed.error.issues.map(
+        (i) => `${i.path.join(".") || "(root)"}: ${i.message}`
+      ),
+      warnings: [],
+      referencesScanned: 0
+    };
+  }
+  const plan = parsed.data;
+  const { refs, duplicates } = collectDefinedRefs(plan);
+  const { errors, scanned } = checkRefIntegrity(plan, refs);
+  const dupErrors = duplicates.map((d) => `duplicate ref "${d}" \u2014 refs must be unique`);
+  const allErrors = [...dupErrors, ...errors];
+  const warnings = [];
+  for (const p of plan.pipelines ?? []) {
+    const positions = p.stages.map((s) => s.position).sort((a, b) => a - b);
+    const expected = positions.every((pos, idx) => pos === idx);
+    if (!expected) {
+      warnings.push(`pipeline "${p.ref}" stage positions are not a clean 0..${p.stages.length - 1} sequence`);
+    }
+  }
+  const CHOICE_DATATYPES = /* @__PURE__ */ new Set(["SINGLE_OPTIONS", "MULTIPLE_OPTIONS", "CHECKBOX"]);
+  for (const f of plan.customFields ?? []) {
+    if (CHOICE_DATATYPES.has(f.dataType) && !(f.options && f.options.length > 0)) {
+      warnings.push(
+        `customFields "${f.ref}" is a ${f.dataType} but declares no options \u2014 the executor cannot create a usable choice field without them`
+      );
+    }
+  }
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors,
+    warnings,
+    plan,
+    referencesScanned: scanned
+  };
+}
+
+// src/tools/intake-to-build.ts
+var customFieldItemSchema = import_zod53.z.object({
+  id: import_zod53.z.string(),
+  name: import_zod53.z.string(),
+  fieldKey: import_zod53.z.string(),
+  dataType: import_zod53.z.string(),
+  model: import_zod53.z.string().optional(),
+  parentId: import_zod53.z.string().optional(),
+  position: import_zod53.z.number().optional(),
+  dateAdded: import_zod53.z.string().optional(),
+  picklistOptions: import_zod53.z.array(import_zod53.z.string()).optional()
+}).passthrough();
+function parseCustomFields(raw) {
+  const obj = raw && typeof raw === "object" ? raw : {};
+  const list = Array.isArray(obj.customFields) ? obj.customFields : [];
+  const out = [];
+  for (const item of list) {
+    const parsed = customFieldItemSchema.safeParse(item);
+    if (parsed.success) out.push(parsed.data);
+  }
+  return out;
+}
+function extractFormId(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const r = result;
+  if (typeof r.id === "string") return r.id;
+  if (typeof r._id === "string") return r._id;
+  const form = r.form;
+  if (form && typeof form === "object") {
+    const f = form;
+    if (typeof f._id === "string") return f._id;
+    if (typeof f.id === "string") return f.id;
+  }
+  return void 0;
+}
+function countFormFields(formFull) {
+  const r = formFull && typeof formFull === "object" ? formFull : {};
+  const form = r.form && typeof r.form === "object" ? r.form : {};
+  const fd = form.formData && typeof form.formData === "object" ? form.formData : {};
+  const inner = fd.form && typeof fd.form === "object" ? fd.form : {};
+  return Array.isArray(inner.fields) ? inner.fields.length : 0;
+}
+function extractFormFields(formFull) {
+  const r = formFull && typeof formFull === "object" ? formFull : {};
+  const form = r.form && typeof r.form === "object" ? r.form : {};
+  const fd = form.formData && typeof form.formData === "object" ? form.formData : {};
+  const inner = fd.form && typeof fd.form === "object" ? fd.form : {};
+  const fields = Array.isArray(inner.fields) ? inner.fields : [];
+  return fields.filter((f) => !!f && typeof f === "object");
+}
+function findRecordForQuestion(q, records) {
+  const wantKey = expectedFieldKey(q).toLowerCase();
+  const byKey = records.find((r) => r.fieldKey.toLowerCase() === wantKey);
+  if (byKey) return byKey;
+  const wantName = intakeFieldName(q.label).toLowerCase();
+  return records.find((r) => r.name.toLowerCase() === wantName);
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function isFormNotYetPropagated(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  return /does not exist or is deleted/i.test(msg);
+}
+function registerIntakeToBuildTools(server2, client, builderClient) {
+  safeTool(
+    server2,
+    "get_intake_question_set",
+    "Return the canonical Intake-to-Build question set (the questions the installed intake form asks) plus each question's GHL field mapping and the Brief field it feeds. Read-only. Use this to review or render the intake before installing it.",
+    {},
+    async () => ({
+      questionSetVersion: QUESTION_SET_VERSION,
+      formName: INTAKE_FORM_NAME,
+      count: INTAKE_QUESTIONS.length,
+      questions: INTAKE_QUESTIONS.map((q) => ({
+        key: q.key,
+        label: q.label,
+        section: q.sectionLabel,
+        required: q.required,
+        fieldKind: q.field.kind,
+        dataType: q.field.kind === "custom" ? q.field.dataType : void 0,
+        standardTag: q.field.kind === "standard" ? q.field.tag : void 0,
+        expectedFieldKey: q.field.kind === "custom" ? expectedFieldKey(q) : void 0,
+        options: q.options,
+        briefPath: q.briefPath
+      }))
+    })
+  );
+  safeTool(
+    server2,
+    "validate_brief",
+    "Validate an Intake-to-Build Brief object against the \xA74 schema. Returns {valid, errors}. Use to check a normalized brief before handing it to the plan-generation skill.",
+    {
+      brief: import_zod53.z.record(import_zod53.z.unknown()).describe("The Brief object to validate.")
+    },
+    async ({ brief }) => validateBrief(brief)
+  );
+  safeTool(
+    server2,
+    "validate_build_plan",
+    "Validate an Intake-to-Build Build Plan against the \xA75 schema AND check ref-integrity: every symbolic ref (pipeline.*, stage.*, tag.*, ...) must resolve to a defined object of the right type, and refs must be unique. Dead references are reported as errors here, before any build runs \u2014 the structural guard against 'an invalid ID silently kills downstream actions'. Returns {valid, errors, warnings, referencesScanned}.",
+    {
+      plan: import_zod53.z.record(import_zod53.z.unknown()).describe("The Build Plan object to validate.")
+    },
+    async ({ plan }) => validateBuildPlan(plan)
+  );
+  if (!builderClient) return;
+  const bc = builderClient;
+  async function resolveCustomFields(locationId2, dryRun) {
+    const cqs = customQuestions();
+    const existing = parseCustomFields(await client.get(`/locations/${locationId2}/customFields`));
+    const created = [];
+    const reused = [];
+    for (const q of cqs) {
+      const found = findRecordForQuestion(q, existing);
+      if (found) {
+        reused.push(q.label);
+      } else {
+        created.push(q.label);
+        if (!dryRun) {
+          const body = {
+            name: intakeFieldName(q.label),
+            dataType: q.field.kind === "custom" ? q.field.dataType : "TEXT",
+            model: "contact"
+          };
+          if (q.options && q.field.kind === "custom") {
+            const dt = q.field.dataType;
+            if (dt === "SINGLE_OPTIONS" || dt === "MULTIPLE_OPTIONS" || dt === "CHECKBOX") {
+              body.options = [...q.options];
+            }
+          }
+          await client.post(`/locations/${locationId2}/customFields`, { body });
+        }
+      }
+    }
+    const resolved = /* @__PURE__ */ new Map();
+    if (!dryRun) {
+      let missing;
+      for (let attempt = 1; attempt <= 6; attempt++) {
+        const after = parseCustomFields(await client.get(`/locations/${locationId2}/customFields`));
+        resolved.clear();
+        missing = void 0;
+        for (const q of cqs) {
+          const rec = findRecordForQuestion(q, after);
+          if (!rec) {
+            missing = q;
+            break;
+          }
+          resolved.set(q.key, rec);
+        }
+        if (!missing) break;
+        if (attempt < 6) await sleep(700 * attempt);
+      }
+      if (missing) {
+        throw new Error(
+          `Could not resolve custom field for question "${missing.key}" after creation (expected fieldKey ${expectedFieldKey(missing)}). Aborting before building the form.`
+        );
+      }
+    }
+    return { resolved, created, reused };
+  }
+  server2.tool(
+    "install_intake_form",
+    "Install the canonical Intake-to-Build client-intake form into the CURRENT GHL location (whatever get_current_location returns). Account-agnostic, zero hardcoded IDs. Creates any missing intake custom fields (idempotent \u2014 reused on re-run), then builds the form with the proven GHL form-builder field shapes and verifies it. Returns {formId, fieldMap} \u2014 keep fieldMap; normalize_submission_to_brief uses it. Pass dryRun:true to preview what would be created without writing. Pass formId to update an existing intake form in place instead of creating a new one.",
+    {
+      dryRun: import_zod53.z.boolean().optional().describe("Preview the fields/form that would be created without writing anything."),
+      formId: import_zod53.z.string().optional().describe("Update this existing form in place instead of creating a new one."),
+      formName: import_zod53.z.string().optional().describe(`Form name. Defaults to "${INTAKE_FORM_NAME}".`)
+    },
+    async ({ dryRun, formId, formName }) => {
+      try {
+        const locationId2 = client.resolveLocationId();
+        if (bc.locationId && bc.locationId !== locationId2) {
+          throw new Error(
+            `Location mismatch: the public API is on ${locationId2} but the form-builder client is on ${bc.locationId}. Restart Claude or run switch_location so both point at the same sub-account before installing (registry-staleness guard).`
+          );
+        }
+        const name = formName ?? INTAKE_FORM_NAME;
+        const { resolved, created, reused } = await resolveCustomFields(locationId2, dryRun ?? false);
+        if (dryRun) {
+          return jsonResponse({
+            dryRun: true,
+            locationId: locationId2,
+            formName: name,
+            questionSetVersion: QUESTION_SET_VERSION,
+            standardFields: INTAKE_QUESTIONS.filter((q) => q.field.kind === "standard").map((q) => q.label),
+            customFieldsToCreate: created,
+            customFieldsToReuse: reused,
+            note: "No changes written. Re-run without dryRun to install."
+          });
+        }
+        const formData = buildIntakeFormData({ resolved, locationId: locationId2 });
+        let resolvedFormId = formId;
+        const justCreated = !resolvedFormId;
+        if (!resolvedFormId) {
+          const createResult = await formApiRequest(bc, "POST", `/?locationId=${locationId2}`, {
+            name,
+            locationId: locationId2,
+            formData: { form: { fields: [], formLabelVisible: true } }
+          });
+          resolvedFormId = extractFormId(createResult);
+          if (!resolvedFormId) {
+            throw new Error(
+              `create_form succeeded but no form id was found in the response: ${JSON.stringify(createResult).slice(0, 300)}`
+            );
+          }
+        }
+        const maxSaveAttempts = justCreated ? 6 : 1;
+        for (let attempt = 1; ; attempt++) {
+          try {
+            await formApiRequest(bc, "POST", `/${resolvedFormId}?locationId=${locationId2}`, {
+              name,
+              formData
+            });
+            break;
+          } catch (saveErr) {
+            if (justCreated && isFormNotYetPropagated(saveErr) && attempt < maxSaveAttempts) {
+              await sleep(700 * attempt);
+              continue;
+            }
+            throw saveErr;
+          }
+        }
+        const expectedCount = INTAKE_QUESTIONS.length + 1 + 7;
+        let persistedCount = 0;
+        for (let attempt = 1; attempt <= 6; attempt++) {
+          const verify = await formApiRequest(bc, "GET", `/${resolvedFormId}?locationId=${locationId2}`);
+          persistedCount = countFormFields(verify);
+          if (persistedCount > 0) break;
+          if (attempt < 6) await sleep(700 * attempt);
+        }
+        const fieldMap = {};
+        for (const [key, rec] of resolved) fieldMap[key] = rec.id;
+        return jsonResponse({
+          ok: true,
+          locationId: locationId2,
+          formId: resolvedFormId,
+          formName: name,
+          questionSetVersion: QUESTION_SET_VERSION,
+          customFieldsCreated: created,
+          customFieldsReused: reused,
+          fieldsPersisted: persistedCount,
+          fieldsExpectedApprox: expectedCount,
+          fieldMap,
+          next: "Drive traffic to the form, then run normalize_submission_to_brief with this formId (and fieldMap) once a submission lands."
+        });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    }
+  );
+  server2.tool(
+    "normalize_submission_to_brief",
+    'Read an intake form submission and normalize it into a \xA74 Brief (briefSource:"intake_form"). Pass the formId; by default the most recent submission is used (or pass submissionId). The intakeKey->customFieldId map is taken from fieldMap if provided (the install_intake_form output, most robust), otherwise reconstructed from the live form. Returns {brief, validation, submissionId} \u2014 validation flags any missing required fields (e.g. an incomplete submission).',
+    {
+      formId: import_zod53.z.string().describe("The intake form ID (from install_intake_form)."),
+      submissionId: import_zod53.z.string().optional().describe("Specific submission to normalize. Defaults to the most recent."),
+      fieldMap: import_zod53.z.record(import_zod53.z.string()).optional().describe("intakeKey -> customFieldId map from install_intake_form. Reconstructed from the form if omitted."),
+      preset: import_zod53.z.string().optional().describe("Override the preset. Defaults to one derived from business_type.")
+    },
+    async ({ formId, submissionId, fieldMap, preset }) => {
+      try {
+        const locationId2 = client.resolveLocationId();
+        const subsRaw = await formApiRequest(
+          bc,
+          "GET",
+          `/submissions?locationId=${locationId2}&formId=${formId}&limit=20`
+        );
+        const subsObj = subsRaw && typeof subsRaw === "object" ? subsRaw : {};
+        const submissions = Array.isArray(subsObj.submissions) ? subsObj.submissions : [];
+        if (submissions.length === 0) {
+          throw new Error(`No submissions found for form ${formId}.`);
+        }
+        const pick = submissionId ? submissions.find(
+          (s) => s && typeof s === "object" && s.id === submissionId
+        ) : submissions[0];
+        if (!pick || typeof pick !== "object") {
+          throw new Error(`Submission ${submissionId ?? "(latest)"} not found for form ${formId}.`);
+        }
+        const sub = pick;
+        const others = sub.others && typeof sub.others === "object" ? sub.others : {};
+        const briefId = typeof sub.id === "string" && sub.id || typeof sub.contactId === "string" && sub.contactId || formId;
+        let resolvedMap = fieldMap;
+        if (!resolvedMap) {
+          const formFull = await formApiRequest(bc, "GET", `/${formId}?locationId=${locationId2}`);
+          resolvedMap = buildFieldMapFromFormFields(extractFormFields(formFull));
+        }
+        const presetSchema2 = import_zod53.z.enum(["generic", "med_spa", "clinic_launch_a2p", "coach", "ecom", "agency"]).optional();
+        const presetParsed = presetSchema2.safeParse(preset);
+        const brief = normalizeSubmissionToBrief({
+          others,
+          fieldMap: resolvedMap,
+          briefId,
+          preset: presetParsed.success ? presetParsed.data : void 0
+        });
+        const validation = validateBrief(brief);
+        return jsonResponse({
+          submissionId: typeof sub.id === "string" ? sub.id : void 0,
+          fieldMapKeys: Object.keys(resolvedMap).length,
+          brief,
+          validation
+        });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    }
+  );
+}
+
 // src/tools/index.ts
 var publicApiTools = [
   [registerContactTools, "contacts"],
@@ -9668,10 +11176,12 @@ var DIAGNOSTICS_MODULE = "diagnostics";
 var LOCATION_SWITCHER_MODULE = "location-switcher";
 var SNAPSHOTS_MODULE = "snapshots";
 var FORM_BUILDER_MODULE = "form-builder";
+var INTAKE_TO_BUILD_MODULE = "intake-to-build";
 var KNOWN_MODULES = /* @__PURE__ */ new Set([
   ...publicApiTools.map(([, label]) => label),
   ...internalApiTools.map(([, label]) => label),
   FORM_BUILDER_MODULE,
+  INTAKE_TO_BUILD_MODULE,
   VALIDATORS_MODULE,
   DIAGNOSTICS_MODULE,
   LOCATION_SWITCHER_MODULE,
@@ -9690,6 +11200,7 @@ function registerAllTools(server2, client, registry2, mcpVersion, env = process.
     register(wrap(moduleName), builderClient);
   }
   registerFormBuilderTools(wrap(FORM_BUILDER_MODULE), builderClient, client);
+  registerIntakeToBuildTools(wrap(INTAKE_TO_BUILD_MODULE), client, builderClient);
   registerValidatorTools(wrap(VALIDATORS_MODULE), client, builderClient);
   registerDiagnosticTools(
     wrap(DIAGNOSTICS_MODULE),