@elitedcs/ghl-mcp 3.35.0 → 3.37.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.37.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.",
@@ -6536,8 +6537,8 @@ async function validateLicense(email, licenseKey) {
       signal: AbortSignal.timeout(1e4)
     });
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: `Could not reach license server: ${msg}`, reason: "unreachable" };
+    const msg2 = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Could not reach license server: ${msg2}`, reason: "unreachable" };
   }
   if (res.status >= 500) {
     return { ok: false, error: `License server returned HTTP ${res.status}`, reason: "unreachable" };
@@ -6575,8 +6576,8 @@ async function validateGhl(apiKey2, locationId2) {
     const name = data?.location?.name || data?.name || "Unknown";
     return { ok: true, locationName: name };
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: `Could not reach GHL: ${msg}` };
+    const msg2 = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Could not reach GHL: ${msg2}` };
   }
 }
 async function validateFirebase(firebaseKey, refreshToken) {
@@ -6592,8 +6593,8 @@ async function validateFirebase(firebaseKey, refreshToken) {
     const claims = data.id_token ? decodeFirebaseClaims(data.id_token) : {};
     return { ok: true, companyId: claims.companyId, userId: claims.userId };
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: `Could not reach Firebase: ${msg}` };
+    const msg2 = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Could not reach Firebase: ${msg2}` };
   }
 }
 function registerSetupTool(server2) {
@@ -7416,8 +7417,8 @@ function registerBulkOperationTools(server2, client) {
           results.success++;
         } catch (error) {
           results.failed++;
-          const msg = error instanceof Error ? error.message : String(error);
-          results.errors.push(`${contactId}: ${msg}`);
+          const msg2 = error instanceof Error ? error.message : String(error);
+          results.errors.push(`${contactId}: ${msg2}`);
         }
         await delay(200);
       }
@@ -9617,6 +9618,2368 @@ 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(),
+    // GHL's GoalAction enum (extracted 2026-05-18): continue | wait | exit.
+    action: import_zod52.z.enum(["exit", "continue", "wait"]).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];
+  for (const p of plan.pipelines ?? []) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of p.stages) {
+      const key = s.name.trim().toLowerCase();
+      if (seen.has(key)) {
+        allErrors.push(
+          `pipeline "${p.ref}" has duplicate stage name "${s.name}" \u2014 stage names must be unique within a pipeline so each stage ref resolves to a single real id`
+        );
+      }
+      seen.add(key);
+    }
+  }
+  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/intake-to-build/executor.ts
+var EXECUTION_ORDER = [
+  "pipelines",
+  "customFields",
+  "tags",
+  "customValues",
+  "calendars",
+  "forms",
+  "funnels",
+  "emails",
+  "sms",
+  "workflows"
+];
+var WAIT_UNIT_MAP = {
+  minutes: "minutes",
+  hours: "hour",
+  days: "day"
+};
+var PENDING = (ref) => `__PENDING__:${ref}`;
+var isPending = (v) => v.startsWith("__PENDING__:");
+var norm = (s) => s.trim().toLowerCase();
+function buildRefIndex(plan) {
+  const idx = {
+    tagName: /* @__PURE__ */ new Map(),
+    fieldName: /* @__PURE__ */ new Map(),
+    fieldType: /* @__PURE__ */ new Map(),
+    email: /* @__PURE__ */ new Map(),
+    sms: /* @__PURE__ */ new Map(),
+    workflowName: /* @__PURE__ */ new Map(),
+    pipelineName: /* @__PURE__ */ new Map(),
+    stageName: /* @__PURE__ */ new Map()
+  };
+  for (const t of plan.tags ?? []) idx.tagName.set(t.ref, t.name);
+  for (const f of plan.customFields ?? []) {
+    idx.fieldName.set(f.ref, f.name);
+    idx.fieldType.set(f.ref, f.dataType);
+  }
+  for (const e of plan.emails ?? []) idx.email.set(e.ref, { subject: e.subject, body: e.body, bodyOutline: e.bodyOutline, name: e.name });
+  for (const s of plan.sms ?? []) idx.sms.set(s.ref, { body: s.body, bodyOutline: s.bodyOutline, name: s.name });
+  for (const w of plan.workflows ?? []) idx.workflowName.set(w.ref, w.name);
+  for (const p of plan.pipelines ?? []) {
+    idx.pipelineName.set(p.ref, p.name);
+    for (const st of p.stages) idx.stageName.set(st.ref, st.name);
+  }
+  return idx;
+}
+function htmlWrap(text) {
+  const t = text.trim();
+  if (/^\s*<[a-z]/i.test(t)) return t;
+  return `<p style="margin:0px;">${t}</p>`;
+}
+function resolveId(ref, idMap) {
+  const real = idMap.get(ref);
+  return real ?? PENDING(ref);
+}
+function expandAction(action, idx, idMap) {
+  switch (action.type) {
+    case "add_contact_tag":
+    case "remove_contact_tag": {
+      const name = idx.tagName.get(action.tagRef) ?? action.tagRef;
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: action.type,
+          name: action.type === "add_contact_tag" ? `Add tag: ${name}` : `Remove tag: ${name}`,
+          attributes: { tags: [name] }
+        }
+      };
+    }
+    case "send_email": {
+      const e = idx.email.get(action.emailRef);
+      if (!e) return { kind: "manual", logicalType: action.type, reason: `email ref ${action.emailRef} not found in plan` };
+      if (!e.body) {
+        return {
+          kind: "needs_content",
+          logicalType: action.type,
+          reason: `email "${action.emailRef}" has only an outline (no send-ready body) \u2014 supply copy before this email step can be built`
+        };
+      }
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "email",
+          name: `Email: ${e.name}`,
+          attributes: {
+            subject: e.subject ?? e.name,
+            html: htmlWrap(e.body),
+            trackingOptions: { hasTrackingLinks: false, hasUtmTracking: false, hasTags: false }
+          }
+        }
+      };
+    }
+    case "send_sms": {
+      const s = idx.sms.get(action.smsRef);
+      if (!s) return { kind: "manual", logicalType: action.type, reason: `sms ref ${action.smsRef} not found in plan` };
+      if (!s.body) {
+        return {
+          kind: "needs_content",
+          logicalType: action.type,
+          reason: `sms "${action.smsRef}" has only an outline (no send-ready body) \u2014 supply copy before this SMS step can be built`
+        };
+      }
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "sms",
+          name: `SMS: ${s.name}`,
+          attributes: { body: s.body, attachments: [] }
+        }
+      };
+    }
+    case "wait": {
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "wait",
+          name: "Wait",
+          attributes: {
+            type: "time",
+            startAfter: { type: WAIT_UNIT_MAP[action.unit], value: action.value, when: "after" },
+            name: "Wait",
+            isHybridAction: true,
+            hybridActionType: "wait",
+            convertToMultipath: false,
+            transitions: []
+          }
+        }
+      };
+    }
+    case "internal_notification": {
+      const looksLikeUserId = /^[A-Za-z0-9]{17,}$/.test(action.to);
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "internal_notification",
+          name: `Notify: ${action.title}`,
+          attributes: {
+            type: "notification",
+            notification: {
+              body: action.body,
+              title: action.title,
+              userType: "user",
+              redirectPage: "contact",
+              type: "send_notification",
+              selectedUser: looksLikeUserId ? action.to : ""
+            }
+          }
+        }
+      };
+    }
+    case "update_contact_field": {
+      const fieldId = resolveId(action.fieldRef, idMap);
+      const title = idx.fieldName.get(action.fieldRef) ?? action.fieldRef;
+      return {
+        kind: "expanded",
+        pendingRefs: isPending(fieldId) ? [action.fieldRef] : [],
+        native: {
+          type: "update_contact_field",
+          name: `Update field: ${title}`,
+          attributes: {
+            type: "update_contact_field",
+            actionType: "update_field_data",
+            fields: [{ field: fieldId, value: action.value, title, type: "text", date: "" }]
+          }
+        }
+      };
+    }
+    case "add_notes": {
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: { type: "add_notes", name: "Add note", attributes: { type: "add_notes", html: htmlWrap(action.body) } }
+      };
+    }
+    case "task_notification": {
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "task-notification",
+          name: `Task: ${action.title}`,
+          attributes: {
+            assignedTo: action.assignedTo ?? "",
+            title: action.title,
+            dueDate: action.dueDate ?? "1",
+            body: action.body ?? "",
+            type: "task-notification",
+            __customInputs__: {}
+          }
+        }
+      };
+    }
+    case "remove_from_workflow":
+    case "add_to_workflow": {
+      const wfId = resolveId(action.workflowRef, idMap);
+      const wfName = idx.workflowName.get(action.workflowRef) ?? action.workflowRef;
+      const pending = isPending(wfId) ? [action.workflowRef] : [];
+      if (action.type === "remove_from_workflow") {
+        return {
+          kind: "expanded",
+          pendingRefs: pending,
+          native: {
+            type: "remove_from_workflow",
+            name: `Remove from: ${wfName}`,
+            attributes: { workflowId: wfId, workflowName: wfName, type: "remove_from_workflow", workflow_id: [wfId] }
+          }
+        };
+      }
+      return {
+        kind: "expanded",
+        pendingRefs: pending,
+        native: {
+          type: "add_to_workflow",
+          name: `Add to: ${wfName}`,
+          attributes: { workflowId: wfId, workflowName: wfName, type: "add_to_workflow", workflow_id: [wfId] }
+        }
+      };
+    }
+    case "create_opportunity":
+    case "update_opportunity": {
+      const pName = idx.pipelineName.get(action.pipelineRef) ?? action.pipelineRef;
+      const sName = idx.stageName.get(action.stageRef) ?? action.stageRef;
+      const verb = action.type === "create_opportunity" ? "Create" : "Move";
+      return {
+        kind: "manual",
+        logicalType: action.type,
+        reason: `${verb} opportunity \u2192 "${pName}" / stage "${sName}": GHL rejects a synthesized opportunity node ("corrupted type") and silently kills the whole workflow save. Add this step by hand in the GHL workflow builder (Add action \u2192 Create/Update Opportunity), or round-trip an existing node.`
+      };
+    }
+    case "goal_event": {
+      return {
+        kind: "expanded",
+        pendingRefs: [],
+        native: {
+          type: "workflow_goal",
+          name: "Goal",
+          attributes: {
+            op: "or",
+            segments: [{ op: "or", conditions: [{ goal_condition: action.goalCondition, id: "" }] }],
+            type: "workflow_goal",
+            action: action.action ?? "exit"
+          }
+        }
+      };
+    }
+    default: {
+      const _exhaustive = action;
+      return { kind: "manual", logicalType: _exhaustive.type, reason: "unrecognized logical action type" };
+    }
+  }
+}
+var MAX_ACTIONS_PER_WORKFLOW = 40;
+function expandWorkflow(workflow, idx, idMap, gatedBy) {
+  const nativeActions = [];
+  const manual = [];
+  const needsContent = [];
+  const pendingRefs = /* @__PURE__ */ new Set();
+  workflow.actions.forEach((a, i) => {
+    const exp = expandAction(a, idx, idMap);
+    if (exp.kind === "expanded") {
+      nativeActions.push(exp.native);
+      exp.pendingRefs.forEach((r) => pendingRefs.add(r));
+    } else if (exp.kind === "manual") {
+      manual.push({ index: i, logicalType: exp.logicalType, reason: exp.reason });
+    } else {
+      needsContent.push({ index: i, logicalType: exp.logicalType, reason: exp.reason });
+    }
+  });
+  const splitInto = Math.max(1, Math.ceil(nativeActions.length / MAX_ACTIONS_PER_WORKFLOW));
+  return {
+    ref: workflow.ref,
+    name: workflow.name,
+    nativeActions,
+    manual,
+    needsContent,
+    pendingRefs: [...pendingRefs],
+    splitInto,
+    gatedBy
+  };
+}
+function scanSection(section2, planObjects, existing) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of existing ?? []) byName.set(norm(e.name), e);
+  return planObjects.map((o) => {
+    const hit = byName.get(norm(o.name));
+    return hit ? { ref: o.ref, type: section2, name: o.name, status: "existing", existingId: hit.id } : { ref: o.ref, type: section2, name: o.name, status: "would_create" };
+  });
+}
+function computeWorkflowGates(plan, metHandoffs) {
+  const gates = /* @__PURE__ */ new Map();
+  const addGate = (wfRef, handoffRef) => {
+    const cur = gates.get(wfRef) ?? [];
+    if (!cur.includes(handoffRef)) cur.push(handoffRef);
+    gates.set(wfRef, cur);
+  };
+  const workflowRefs = (plan.workflows ?? []).map((w) => w.ref);
+  for (const h of plan.handoffs ?? []) {
+    if (metHandoffs.has(h.ref)) continue;
+    for (const block of h.blocks ?? []) {
+      if (block.endsWith(".*")) {
+        if (block === "workflow.*") for (const wf of workflowRefs) addGate(wf, h.ref);
+      } else if (refNamespace(block) === "workflow") {
+        addGate(block, h.ref);
+      }
+    }
+  }
+  return gates;
+}
+var SECTION_OBJECTS = {
+  pipelines: (p) => (p.pipelines ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  customFields: (p) => (p.customFields ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  tags: (p) => (p.tags ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  customValues: (p) => (p.customValues ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  calendars: (p) => (p.calendars ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  forms: (p) => (p.forms ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  funnels: (p) => (p.funnels ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  emails: (p) => (p.emails ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  sms: (p) => (p.sms ?? []).map((x) => ({ ref: x.ref, name: x.name })),
+  workflows: (p) => (p.workflows ?? []).map((x) => ({ ref: x.ref, name: x.name }))
+};
+var SECTION_EXISTING = {
+  pipelines: "pipelines",
+  customFields: "customFields",
+  tags: "tags",
+  customValues: "customValues",
+  calendars: "calendars",
+  forms: "forms",
+  funnels: "funnels",
+  emails: null,
+  // emails/sms live inside workflows; no standalone clobber scan
+  sms: null,
+  workflows: "workflows"
+};
+function resolvePlan(plan, existing, opts = {}) {
+  const idx = buildRefIndex(plan);
+  const metHandoffs = new Set(opts.metHandoffs ?? []);
+  const seededIdMap = new Map(Object.entries(opts.idMap ?? {}));
+  const items = [];
+  const idMap = new Map(seededIdMap);
+  for (const section2 of EXECUTION_ORDER) {
+    const objs = SECTION_OBJECTS[section2](plan);
+    if (objs.length === 0) continue;
+    const existingKey = SECTION_EXISTING[section2];
+    const existingList = existingKey ? existing[existingKey] : void 0;
+    const scanned = scanSection(section2, objs, existingList);
+    for (const it of scanned) {
+      items.push(it);
+      if (it.status === "existing" && it.existingId) idMap.set(it.ref, it.existingId);
+      else if (!idMap.has(it.ref)) idMap.set(it.ref, PENDING(it.ref));
+    }
+    if (section2 === "pipelines") {
+      for (const p of plan.pipelines ?? []) {
+        for (const st of p.stages) if (!idMap.has(st.ref)) idMap.set(st.ref, PENDING(st.ref));
+      }
+    }
+  }
+  const gates = computeWorkflowGates(plan, metHandoffs);
+  const workflows = (plan.workflows ?? []).map((w) => expandWorkflow(w, idx, idMap, gates.get(w.ref) ?? []));
+  const handoffs = (plan.handoffs ?? []).map((h) => ({
+    ref: h.ref,
+    owner: h.owner,
+    title: h.title,
+    instruction: h.instruction,
+    successCheck: h.successCheck,
+    met: metHandoffs.has(h.ref),
+    blocks: h.blocks ?? []
+  }));
+  const summary = {
+    wouldCreate: items.filter((i) => i.status === "would_create").length,
+    existing: items.filter((i) => i.status === "existing").length,
+    workflowsTotal: workflows.length,
+    workflowsGated: workflows.filter((w) => w.gatedBy.length > 0).length,
+    actionsExpanded: workflows.reduce((n, w) => n + w.nativeActions.length, 0),
+    actionsManual: workflows.reduce((n, w) => n + w.manual.length, 0),
+    actionsNeedContent: workflows.reduce((n, w) => n + w.needsContent.length, 0)
+  };
+  return { items, idMap: Object.fromEntries(idMap), workflows, handoffs, summary };
+}
+function renderReport(plan, result, ctx) {
+  const L = [];
+  const { summary } = result;
+  L.push(`Blueprint build ${ctx.mode === "dry_run" ? "PREVIEW (dry run \u2014 no changes written)" : "REPORT"}`);
+  L.push(`Account: ${ctx.locationName} (${ctx.locationId})`);
+  L.push(`Plan: ${plan.planId}  \xB7  preset: ${plan.preset}`);
+  L.push("");
+  L.push(
+    `Objects: ${summary.wouldCreate} to create, ${summary.existing} already exist (skipped, never modified).`
+  );
+  L.push(
+    `Workflows: ${summary.workflowsTotal} (${summary.workflowsGated} gated DRAFT by an unmet handoff). Actions: ${summary.actionsExpanded} auto-built, ${summary.actionsManual} need a manual GHL-UI step, ${summary.actionsNeedContent} need send-ready copy.`
+  );
+  L.push("");
+  L.push("\u2500\u2500 Blueprint builds automatically \u2500\u2500");
+  for (const section2 of EXECUTION_ORDER) {
+    const secItems = result.items.filter((i) => i.type === section2);
+    if (secItems.length === 0) continue;
+    for (const it of secItems) {
+      const mark = it.status === "existing" ? "skip (exists)" : ctx.mode === "dry_run" ? "would create" : "create";
+      L.push(`  [${section2}] ${it.name} \u2014 ${mark}${it.existingId ? ` \u2192 ${it.existingId}` : ""}`);
+    }
+  }
+  for (const w of result.workflows) {
+    const gate = w.gatedBy.length ? ` \u2014 DRAFT, gated by ${w.gatedBy.join(", ")}` : ctx.publishWorkflows ? " \u2014 publish" : " \u2014 DRAFT";
+    const split = w.splitInto > 1 ? ` (splits into ${w.splitInto} chained workflows, >${MAX_ACTIONS_PER_WORKFLOW} actions)` : "";
+    L.push(`  [workflow] ${w.name}: ${w.nativeActions.length} actions${split}${gate}`);
+  }
+  L.push("");
+  L.push("\u2500\u2500 You must do these by hand (in order) \u2500\u2500");
+  let any = false;
+  for (const w of result.workflows) {
+    for (const m of w.manual) {
+      any = true;
+      L.push(`  \u2022 [${w.name}] ${m.reason}`);
+    }
+    for (const nc of w.needsContent) {
+      any = true;
+      L.push(`  \u2022 [${w.name}] ${nc.reason}`);
+    }
+  }
+  for (const h of result.handoffs) {
+    if (h.met) continue;
+    any = true;
+    L.push(`  \u2022 [${h.owner}] ${h.title}: ${h.instruction} (done when: ${h.successCheck})`);
+  }
+  if (!any) L.push("  (nothing \u2014 everything in this plan is auto-buildable)");
+  return L.join("\n");
+}
+
+// src/intake-to-build/execute.ts
+var norm2 = (s) => s.trim().toLowerCase();
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function executeBackbone(plan, deps, opts = {}) {
+  const retries = opts.verifyRetries ?? 4;
+  const backoff = opts.verifyBackoffMs ?? 500;
+  const idMap = {};
+  const built = [];
+  const halt = (atRef, type, reason) => ({
+    ok: false,
+    idMap,
+    built,
+    halted: { atRef, type, reason },
+    deferred: deferredSections(plan)
+  });
+  async function pollForNew(read, name, beforeIds) {
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      const fresh = (await read()).filter((o) => norm2(o.name) === norm2(name) && !beforeIds.has(o.id));
+      if (fresh.length === 1) return fresh[0];
+      if (fresh.length > 1) return void 0;
+      if (attempt < retries) await sleep(backoff * attempt);
+    }
+    return void 0;
+  }
+  for (const p of plan.pipelines ?? []) {
+    let pipelines;
+    try {
+      pipelines = await deps.listPipelines();
+    } catch (e) {
+      return halt(p.ref, "pipeline", `could not read existing pipelines: ${msg(e)}`);
+    }
+    const matches = pipelines.filter((x) => norm2(x.name) === norm2(p.name));
+    if (matches.length > 1) {
+      return halt(p.ref, "pipeline", `${matches.length} existing pipelines are named "${p.name}" \u2014 ambiguous, cannot safely bind ${p.ref}. Resolve the duplicate in GHL or rename, then re-run.`);
+    }
+    let pipeline;
+    let created;
+    if (matches.length === 1) {
+      pipeline = matches[0];
+      created = false;
+    } else {
+      const beforeIds = new Set(pipelines.map((x) => x.id));
+      try {
+        await deps.createPipeline(p.name, p.stages.map((s) => ({ name: s.name, position: s.position })));
+      } catch (e) {
+        return halt(p.ref, "pipeline", `create failed: ${msg(e)}`);
+      }
+      const verified = await pollForNew(() => deps.listPipelines(), p.name, beforeIds);
+      if (!verified) return halt(p.ref, "pipeline", "created but could not verify a single new pipeline by read-back (none, or an ambiguous duplicate, appeared)");
+      pipeline = verified;
+      created = true;
+    }
+    idMap[p.ref] = pipeline.id;
+    built.push({ ref: p.ref, type: "pipeline", name: p.name, status: created ? "created" : "existing", realId: pipeline.id });
+    for (const st of p.stages) {
+      const stageMatches = pipeline.stages.filter((es) => norm2(es.name) === norm2(st.name));
+      if (stageMatches.length === 0) {
+        return halt(st.ref, "stage", `pipeline "${p.name}" has no stage named "${st.name}" after build \u2014 cannot resolve ${st.ref}`);
+      }
+      if (stageMatches.length > 1) {
+        return halt(st.ref, "stage", `pipeline "${p.name}" has ${stageMatches.length} stages named "${st.name}" \u2014 cannot resolve ${st.ref} to a single id`);
+      }
+      idMap[st.ref] = stageMatches[0].id;
+      built.push({ ref: st.ref, type: "stage", name: st.name, status: created ? "created" : "existing", realId: stageMatches[0].id });
+    }
+  }
+  const fieldHalt = await buildSimple(
+    plan.customFields ?? [],
+    "field",
+    () => deps.listCustomFields(),
+    (f) => deps.createCustomField({ name: f.name, dataType: f.dataType, model: f.model, options: f.options }),
+    (f) => f.name,
+    pollForNew,
+    idMap,
+    built
+  );
+  if (fieldHalt) return halt(fieldHalt.ref, "field", fieldHalt.reason);
+  const tagHalt = await buildSimple(
+    plan.tags ?? [],
+    "tag",
+    () => deps.listTags(),
+    (t) => deps.createTag(t.name),
+    (t) => t.name,
+    pollForNew,
+    idMap,
+    built
+  );
+  if (tagHalt) return halt(tagHalt.ref, "tag", tagHalt.reason);
+  const cvHalt = await buildSimple(
+    plan.customValues ?? [],
+    "cv",
+    () => deps.listCustomValues(),
+    (cv) => deps.createCustomValue(cv.name, cv.value ?? ""),
+    (cv) => cv.name,
+    pollForNew,
+    idMap,
+    built
+  );
+  if (cvHalt) return halt(cvHalt.ref, "cv", cvHalt.reason);
+  return { ok: true, idMap, built, deferred: deferredSections(plan) };
+}
+async function buildSimple(objects, type, list, create, nameOf, pollForNew, idMap, built) {
+  if (objects.length === 0) return null;
+  for (const obj of objects) {
+    const name = nameOf(obj);
+    let existing;
+    try {
+      existing = await list();
+    } catch (e) {
+      return { ref: obj.ref, reason: `could not read existing ${type}s: ${msg(e)}` };
+    }
+    const matches = existing.filter((o) => norm2(o.name) === norm2(name));
+    if (matches.length > 1) {
+      return { ref: obj.ref, reason: `${matches.length} existing ${type}s are named "${name}" \u2014 ambiguous, cannot safely bind ${obj.ref}. Resolve the duplicate in GHL, then re-run.` };
+    }
+    if (matches.length === 1) {
+      idMap[obj.ref] = matches[0].id;
+      built.push({ ref: obj.ref, type, name, status: "existing", realId: matches[0].id });
+      continue;
+    }
+    const beforeIds = new Set(existing.map((o) => o.id));
+    try {
+      await create(obj);
+    } catch (e) {
+      return { ref: obj.ref, reason: `create failed: ${msg(e)}` };
+    }
+    const verified = await pollForNew(list, name, beforeIds);
+    if (!verified) return { ref: obj.ref, reason: `created but could not verify a single new ${type} by read-back (none, or an ambiguous duplicate, appeared)` };
+    idMap[obj.ref] = verified.id;
+    built.push({ ref: obj.ref, type, name, status: "created", realId: verified.id });
+  }
+  return null;
+}
+function deferredSections(plan) {
+  const out = [];
+  if (plan.calendars?.length) out.push({ section: "calendars", count: plan.calendars.length });
+  if (plan.forms?.length) out.push({ section: "forms", count: plan.forms.length });
+  if (plan.funnels?.length) out.push({ section: "funnels", count: plan.funnels.length });
+  if (plan.workflows?.length) out.push({ section: "workflows", count: plan.workflows.length });
+  return out;
+}
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// 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 sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function isFormNotYetPropagated(error) {
+  const msg2 = error instanceof Error ? error.message : String(error);
+  return /does not exist or is deleted/i.test(msg2);
+}
+function pickObjects(raw, keys) {
+  const root = raw && typeof raw === "object" ? raw : {};
+  let list = Array.isArray(raw) ? raw : void 0;
+  if (!list) {
+    for (const k of keys) {
+      if (Array.isArray(root[k])) {
+        list = root[k];
+        break;
+      }
+    }
+  }
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    const o = item;
+    const id = typeof o.id === "string" ? o.id : typeof o._id === "string" ? o._id : void 0;
+    const name = typeof o.name === "string" ? o.name : void 0;
+    if (id && name) out.push({ id, name });
+  }
+  return out;
+}
+async function scanExistingAssets(client, locationId2) {
+  const warnings = [];
+  const assets = {};
+  const read = async (label, fn, into) => {
+    try {
+      assets[into] = await fn();
+    } catch (e) {
+      warnings.push(`could not scan ${label}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  };
+  await read("pipelines", async () => pickObjects(await client.get("/opportunities/pipelines", { params: { locationId: locationId2 } }), ["pipelines"]), "pipelines");
+  await read("custom fields", async () => pickObjects(await client.get(`/locations/${locationId2}/customFields`), ["customFields"]), "customFields");
+  await read("tags", async () => pickObjects(await client.get(`/locations/${locationId2}/tags`), ["tags"]), "tags");
+  await read("custom values", async () => pickObjects(await client.get(`/locations/${locationId2}/customValues`), ["customValues"]), "customValues");
+  await read("calendars", async () => pickObjects(await client.get("/calendars/", { params: { locationId: locationId2 } }), ["calendars"]), "calendars");
+  await read("forms", async () => pickObjects(await client.get("/forms/", { params: { locationId: locationId2, limit: 100 } }), ["forms"]), "forms");
+  await read("funnels", async () => pickObjects(await client.get("/funnels/funnel/list", { params: { locationId: locationId2, limit: 100 } }), ["funnels"]), "funnels");
+  await read("workflows", async () => pickObjects(await client.get("/workflows/", { params: { locationId: locationId2 } }), ["workflows"]), "workflows");
+  return { assets, warnings };
+}
+function pickPipelines(raw) {
+  const root = raw && typeof raw === "object" ? raw : {};
+  const list = Array.isArray(root.pipelines) ? root.pipelines : Array.isArray(raw) ? raw : [];
+  const out = [];
+  for (const item of list) {
+    if (!item || typeof item !== "object") continue;
+    const p = item;
+    const id = typeof p.id === "string" ? p.id : typeof p._id === "string" ? p._id : void 0;
+    const name = typeof p.name === "string" ? p.name : void 0;
+    if (!id || !name) continue;
+    const stagesRaw = Array.isArray(p.stages) ? p.stages : [];
+    const stages = stagesRaw.filter((s) => !!s && typeof s === "object").map((s) => ({
+      id: typeof s.id === "string" ? s.id : typeof s._id === "string" ? s._id : "",
+      name: typeof s.name === "string" ? s.name : "",
+      position: typeof s.position === "number" ? s.position : void 0
+    })).filter((s) => s.id && s.name);
+    out.push({ id, name, stages });
+  }
+  return out;
+}
+function makeExecuteDeps(client, builderClient, locationId2) {
+  const pipelineApi = async (method, path7, body) => {
+    const headers = await builderClient.buildHeaders();
+    const url = `https://backend.leadconnectorhq.com/opportunities/pipelines${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(`Pipeline API ${response.status}: ${method} ${path7}
+${text2.slice(0, 300)}`);
+    }
+    const text = await response.text();
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch {
+      return JSON.parse(text.replace(/[\x00-\x1F\x7F]/g, ""));
+    }
+  };
+  return {
+    listPipelines: async () => pickPipelines(await pipelineApi("GET", `?locationId=${locationId2}`)),
+    createPipeline: async (name, stages) => {
+      await pipelineApi("POST", "", {
+        name,
+        stages: stages.map((s) => ({ name: s.name, position: s.position, showInFunnel: true, showInPieChart: true })),
+        locationId: locationId2,
+        showInFunnel: true,
+        showInPieChart: true
+      });
+    },
+    // noRetry on every CREATE: these POSTs are not idempotent, so an auto-retry
+    // after a lost response (429/5xx/network) would DUPLICATE the object in the
+    // live account. With noRetry, a failed create simply fails → the executor's
+    // verify-after catches it and halts; the idempotent re-run then binds the
+    // one real object instead of stacking a second.
+    listCustomFields: async () => pickObjects(await client.get(`/locations/${locationId2}/customFields`), ["customFields"]),
+    createCustomField: async (f) => {
+      const body = { name: f.name, dataType: f.dataType, model: f.model ?? "contact" };
+      if (f.options && f.options.length) body.options = f.options;
+      await client.post(`/locations/${locationId2}/customFields`, { body, noRetry: true });
+    },
+    listTags: async () => pickObjects(await client.get(`/locations/${locationId2}/tags`), ["tags"]),
+    createTag: async (name) => {
+      await client.post(`/locations/${locationId2}/tags`, { body: { name }, noRetry: true });
+    },
+    listCustomValues: async () => pickObjects(await client.get(`/locations/${locationId2}/customValues`), ["customValues"]),
+    createCustomValue: async (name, value) => {
+      await client.post(`/locations/${locationId2}/customValues`, { body: { name, value }, noRetry: true });
+    }
+  };
+}
+async function readLocationName(client, locationId2) {
+  try {
+    const raw = await client.get(`/locations/${locationId2}`);
+    const r = raw && typeof raw === "object" ? raw : {};
+    const loc = r.location && typeof r.location === "object" ? r.location : r;
+    const name = loc.name;
+    return typeof name === "string" && name ? name : locationId2;
+  } catch {
+    return locationId2;
+  }
+}
+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)
+  );
+  server2.tool(
+    "apply_build_plan",
+    `Take an APPROVED Blueprint \xA75 build plan + the CURRENT confirmed sub-account and build it. mode:"dry_run" (default) writes NOTHING \u2014 it resolves refs, expands each workflow's logical actions to native GHL JSON, runs the NEVER-CLOBBER existing-asset scan, and returns a two-part report. Run it FIRST. mode:"execute" performs LIVE writes for the CRM backbone (pipelines+stages, custom fields, tags, custom values): never clobbers (same-named objects are bound to their existing id, never modified), verifies each create by read-back before resolving its ref, halts on the first failure returning the partial idMap, and is idempotent (re-run = no-op). Calendars/forms/funnels/workflows are surfaced as manual next steps, not auto-built yet. Always confirms the active location and validates the plan before any write.`,
+    {
+      plan: import_zod53.z.record(import_zod53.z.unknown()).describe("The approved \xA75 Build Plan object."),
+      mode: import_zod53.z.enum(["dry_run", "execute"]).optional().describe("dry_run (default) = resolve/expand/scan/report, no writes. execute = live writes (not yet enabled)."),
+      locationId: import_zod53.z.string().optional().describe("Target sub-account. MUST match the active location; if it differs the tool refuses (confirm/switch first)."),
+      metHandoffs: import_zod53.z.array(import_zod53.z.string()).optional().describe('Handoff refs the operator has already satisfied (e.g. ["handoff.a2p"]) \u2014 lifts their gate so dependent workflows are not held DRAFT.'),
+      publishWorkflows: import_zod53.z.boolean().optional().describe("If true, ungated workflows would be published instead of left DRAFT. Default false (DRAFT)."),
+      onConflict: import_zod53.z.enum(["skip", "abort"]).optional().describe("skip (default) = bind same-named existing objects and continue. abort = report conflicts as a halt.")
+    },
+    async ({ plan, mode, locationId: locationId2, metHandoffs, publishWorkflows, onConflict }) => {
+      try {
+        const resolvedMode = mode ?? "dry_run";
+        const activeLocation = client.resolveLocationId();
+        if (locationId2 && locationId2 !== activeLocation) {
+          return jsonResponse({
+            ok: false,
+            error: `Location mismatch: active sub-account is ${activeLocation} but you passed ${locationId2}. Run switch_location to ${locationId2} and confirm with get_current_location first, then re-run. (Blueprint never switches accounts underneath you.)`
+          });
+        }
+        const validation = validateBuildPlan(plan);
+        if (!validation.valid || !validation.plan) {
+          return jsonResponse({
+            ok: false,
+            phase: "validate",
+            error: "Build plan failed \xA75 validation \u2014 fix these before building.",
+            errors: validation.errors,
+            warnings: validation.warnings
+          });
+        }
+        const typedPlan = validation.plan;
+        const locationName = await readLocationName(client, activeLocation);
+        const { assets, warnings: scanWarnings } = await scanExistingAssets(client, activeLocation);
+        const result = resolvePlan(typedPlan, assets, { metHandoffs });
+        if (resolvedMode === "execute") {
+          if (!builderClient) {
+            return jsonResponse({
+              ok: false,
+              phase: "execute",
+              error: "execute needs the workflow-builder (Firebase) client to create pipelines, and it is not configured on this install. Run the setup wizard to enable the builder, then retry. dry_run works without it."
+            });
+          }
+          if (builderClient.locationId && builderClient.locationId !== activeLocation) {
+            return jsonResponse({
+              ok: false,
+              phase: "execute",
+              error: `Location mismatch: the public API is on ${activeLocation} but the workflow-builder client is on ${builderClient.locationId}. Restart Claude or run switch_location so both point at the same sub-account before building (registry-staleness guard). No writes were made.`
+            });
+          }
+          try {
+            await builderClient.buildHeaders();
+          } catch (e) {
+            return jsonResponse({ ok: false, phase: "execute", error: `Could not authenticate the workflow-builder for ${activeLocation} (${e instanceof Error ? e.message : String(e)}). No writes were made.` });
+          }
+          const tokenCompany = builderClient.getTokenCompanyId();
+          const intendedCompany = builderClient.getIntendedCompanyId();
+          if (tokenCompany && intendedCompany && tokenCompany !== intendedCompany) {
+            return jsonResponse({
+              ok: false,
+              phase: "execute",
+              error: `Firebase binding mismatch: the workflow-builder authenticates as company ${tokenCompany} but the active location ${activeLocation} is owned by company ${intendedCompany}. Restart Claude or re-run switch_location to ${activeLocation} so the Firebase session rebinds before building. No writes were made.`
+            });
+          }
+          if (onConflict === "abort") {
+            const collisions2 = result.items.filter((i) => i.status === "existing");
+            if (collisions2.length > 0) {
+              return jsonResponse({
+                ok: false,
+                phase: "execute",
+                error: `onConflict=abort: ${collisions2.length} object(s) in the plan already exist in this account \u2014 aborting before any write. Re-run with onConflict:"skip" to bind to the existing ones, or resolve them first.`,
+                collisions: collisions2.map((c) => ({ ref: c.ref, name: c.name, existingId: c.existingId }))
+              });
+            }
+          }
+          const deps = makeExecuteDeps(client, builderClient, activeLocation);
+          const exec = await executeBackbone(typedPlan, deps);
+          const manualLines = result.workflows.flatMap((w) => [
+            ...w.manual.map((m) => `[${w.name}] ${m.reason}`),
+            ...w.needsContent.map((c) => `[${w.name}] ${c.reason}`)
+          ]);
+          const handoffLines = result.handoffs.filter((h) => !h.met).map((h) => `[${h.owner}] ${h.title}: ${h.instruction}`);
+          return jsonResponse({
+            ok: exec.ok,
+            mode: "execute",
+            locationId: activeLocation,
+            locationName,
+            planId: typedPlan.planId,
+            scanWarnings,
+            halted: exec.halted,
+            built: exec.built,
+            idMap: exec.idMap,
+            deferred: exec.deferred,
+            deferredNote: "v1 execute builds the CRM backbone (pipelines, custom fields, tags, custom values) live. These object types are planned but NOT auto-built yet \u2014 create them via the GHL UI or the dedicated tools, in this order: calendars \u2192 forms \u2192 funnels \u2192 workflows.",
+            nextManualSteps: [...manualLines, ...handoffLines],
+            summary: exec.ok ? `Built ${exec.built.filter((b) => b.status === "created").length} new object(s), bound ${exec.built.filter((b) => b.status === "existing").length} existing. ${exec.deferred.length ? "Deferred: " + exec.deferred.map((d) => `${d.count} ${d.section}`).join(", ") + " (manual)." : ""}` : `HALTED at ${exec.halted?.atRef} (${exec.halted?.reason}). ${exec.built.length} object(s) were created before the halt \u2014 see idMap to resume or clean up. NEVER-CLOBBER means a re-run will bind those, not duplicate them.`
+          });
+        }
+        const collisions = result.items.filter((i) => i.status === "existing");
+        const aborted = onConflict === "abort" && collisions.length > 0;
+        const report = renderReport(typedPlan, result, {
+          mode: "dry_run",
+          locationName,
+          locationId: activeLocation,
+          publishWorkflows: publishWorkflows ?? false
+        });
+        return jsonResponse({
+          ok: true,
+          mode: "dry_run",
+          locationId: activeLocation,
+          locationName,
+          planId: typedPlan.planId,
+          validation: { valid: true, warnings: validation.warnings, referencesScanned: validation.referencesScanned },
+          scanWarnings,
+          onConflict: onConflict ?? "skip",
+          aborted: aborted ? { reason: `${collisions.length} same-named object(s) already exist and onConflict=abort`, collisions: collisions.map((c) => c.ref) } : void 0,
+          summary: result.summary,
+          items: result.items,
+          idMap: result.idMap,
+          workflows: result.workflows.map((w) => ({
+            ref: w.ref,
+            name: w.name,
+            autoActions: w.nativeActions.length,
+            manualSteps: w.manual,
+            needsContent: w.needsContent,
+            pendingRefs: w.pendingRefs,
+            splitInto: w.splitInto,
+            gatedBy: w.gatedBy,
+            draft: w.gatedBy.length > 0 || !(publishWorkflows ?? false)
+          })),
+          handoffs: result.handoffs,
+          report,
+          next: 'Review the report. When it looks right, re-run with mode:"execute" to build the CRM backbone live (pipelines, fields, tags, custom values). Calendars/forms/funnels/workflows are listed as manual next steps.'
+        });
+      } catch (error) {
+        return errorResponse(error);
+      }
+    }
+  );
+  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 sleep2(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 sleep2(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 sleep2(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 +12031,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 +12055,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),
@@ -9856,8 +12222,8 @@ Subcommands:
 
 Exit codes: 0 ok, 2 usage, 3 validation failed, 4 filesystem write failed.
 Seed while the MCP server is stopped, or restart it afterwards.`;
-function errLine(msg) {
-  process.stderr.write(msg + "\n");
+function errLine(msg2) {
+  process.stderr.write(msg2 + "\n");
 }
 function preflightWritable() {
   try {