@elitedcs/ghl-mcp 3.36.0 → 3.38.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.36.0",
+      version: "3.38.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",
@@ -6537,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" };
@@ -6576,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) {
@@ -6593,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) {
@@ -7417,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);
       }
@@ -10631,7 +10631,8 @@ var actionSchema = import_zod52.z.discriminatedUnion("type", [
   import_zod52.z.object({
     type: import_zod52.z.literal("goal_event"),
     goalCondition: import_zod52.z.string(),
-    action: import_zod52.z.string().optional()
+    // 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({
@@ -10793,6 +10794,18 @@ function validateBuildPlan(input) {
   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);
@@ -10818,6 +10831,685 @@ function validateBuildPlan(input) {
   };
 }
 
+// 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 STAFF_CALENDAR_TYPES = /* @__PURE__ */ new Set([
+  "round_robin",
+  "collective",
+  "class_booking",
+  "service_booking"
+]);
+function calendarNeedsStaff(cal) {
+  return cal.requiresStaff === true || STAFF_CALENDAR_TYPES.has(cal.calendarType);
+}
+function classifyCalendarBuild(cal, userCount) {
+  if (!calendarNeedsStaff(cal)) return { action: "build" };
+  if (userCount === 1) return { action: "build" };
+  if (userCount === void 0) {
+    return {
+      action: "manual",
+      reason: `Calendar "${cal.name}" (${cal.calendarType}) needs a team member, but Blueprint couldn't read this account's users to auto-assign one. Assign the booking staff to it in the GHL UI (or build it there), then re-run to bind it.`
+    };
+  }
+  if (userCount === 0) {
+    return {
+      action: "manual",
+      reason: `Calendar "${cal.name}" (${cal.calendarType}) needs a team member, but this account has no users yet. Add a user and assign them to it, then re-run to build it.`
+    };
+  }
+  return {
+    action: "manual",
+    reason: `Calendar "${cal.name}" (${cal.calendarType}) needs a team member, and this account has ${userCount} users \u2014 Blueprint won't guess which one books. Assign the booking staff to it in the GHL UI (or build it there), then re-run to bind it.`
+  };
+}
+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 existingCalNames = new Set((existing.calendars ?? []).map((c) => norm(c.name)));
+  const calendarsManual = [];
+  for (const cal of plan.calendars ?? []) {
+    if (existingCalNames.has(norm(cal.name))) continue;
+    const decision = classifyCalendarBuild(cal, existing.userCount);
+    if (decision.action === "manual") {
+      calendarsManual.push({ ref: cal.ref, name: cal.name, reason: decision.reason ?? "needs a team member" });
+    }
+  }
+  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 manualCalRefs = new Set(calendarsManual.map((c) => c.ref));
+  const summary = {
+    wouldCreate: items.filter((i) => i.status === "would_create" && !manualCalRefs.has(i.ref)).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, calendarsManual, 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("");
+  const manualCalRefs = new Set(result.calendarsManual.map((c) => c.ref));
+  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) {
+      if (manualCalRefs.has(it.ref)) continue;
+      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 c of result.calendarsManual) {
+    any = true;
+    L.push(`  \u2022 [calendar] ${c.reason}`);
+  }
+  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 manual = [];
+  const halt = (atRef, type, reason) => ({
+    ok: false,
+    idMap,
+    built,
+    manual,
+    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);
+  let cachedUserCount;
+  let cachedSoloUserId;
+  let usersRead = false;
+  for (const cal of plan.calendars ?? []) {
+    let calendars;
+    try {
+      calendars = await deps.listCalendars();
+    } catch (e) {
+      return halt(cal.ref, "calendar", `could not read existing calendars: ${msg(e)}`);
+    }
+    const matches = calendars.filter((c) => norm2(c.name) === norm2(cal.name));
+    if (matches.length > 1) {
+      return halt(cal.ref, "calendar", `${matches.length} existing calendars are named "${cal.name}" \u2014 ambiguous, cannot safely bind ${cal.ref}. Resolve the duplicate in GHL, then re-run.`);
+    }
+    if (matches.length === 1) {
+      idMap[cal.ref] = matches[0].id;
+      built.push({ ref: cal.ref, type: "calendar", name: cal.name, status: "existing", realId: matches[0].id });
+      continue;
+    }
+    let staffUserId;
+    if (calendarNeedsStaff(cal)) {
+      if (!usersRead) {
+        try {
+          const users = await deps.listUsers();
+          cachedUserCount = users.length;
+          cachedSoloUserId = users.length === 1 ? users[0].id : void 0;
+        } catch {
+          cachedUserCount = void 0;
+        }
+        usersRead = true;
+      }
+      const decision = classifyCalendarBuild(cal, cachedUserCount);
+      if (decision.action === "manual") {
+        manual.push({ ref: cal.ref, type: "calendar", name: cal.name, reason: decision.reason ?? "needs a team member" });
+        continue;
+      }
+      staffUserId = cachedSoloUserId;
+    }
+    const beforeIds = new Set(calendars.map((c) => c.id));
+    try {
+      await deps.createCalendar({
+        name: cal.name,
+        calendarType: cal.calendarType,
+        openHours: cal.openHours,
+        availabilityType: cal.availabilityType,
+        staffUserId
+      });
+    } catch (e) {
+      return halt(cal.ref, "calendar", `create failed: ${msg(e)}`);
+    }
+    const verified = await pollForNew(() => deps.listCalendars(), cal.name, beforeIds);
+    if (!verified) return halt(cal.ref, "calendar", "created but could not verify a single new calendar by read-back (none, or an ambiguous duplicate, appeared)");
+    idMap[cal.ref] = verified.id;
+    built.push({ ref: cal.ref, type: "calendar", name: cal.name, status: "created", realId: verified.id });
+  }
+  return { ok: true, idMap, built, manual, 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.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(),
@@ -10875,10 +11567,152 @@ function findRecordForQuestion(q, records) {
   const wantName = intakeFieldName(q.label).toLowerCase();
   return records.find((r) => r.name.toLowerCase() === wantName);
 }
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 function isFormNotYetPropagated(error) {
-  const msg = error instanceof Error ? error.message : String(error);
-  return /does not exist or is deleted/i.test(msg);
+  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");
+  try {
+    assets.userCount = pickObjects(await client.get("/users/", { params: { locationId: locationId2 } }), ["users"]).length;
+  } catch (e) {
+    warnings.push(`could not scan users (staff-requiring calendars will defer to a manual step): ${e instanceof Error ? e.message : String(e)}`);
+  }
+  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 });
+    },
+    listCalendars: async () => pickObjects(await client.get("/calendars/", { params: { locationId: locationId2 } }), ["calendars"]),
+    // Users: count + the lone id (when solo) drive auto-staff. The /users/
+    // endpoint 422s on a `limit` param under PIT auth, so pass only locationId.
+    listUsers: async () => pickObjects(await client.get("/users/", { params: { locationId: locationId2 } }), ["users"]),
+    createCalendar: async (cal) => {
+      const teamMembers = cal.staffUserId ? [{ userId: cal.staffUserId, priority: 1, isPrimary: true, selected: true, locationConfigurations: [{ kind: "custom", position: 0 }] }] : void 0;
+      const body = buildCreateCalendarBody(
+        { name: cal.name, calendarType: cal.calendarType, openHours: cal.openHours, availabilityType: cal.availabilityType, teamMembers },
+        locationId2
+      );
+      await client.post("/calendars/", { body, 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(
@@ -10922,6 +11756,148 @@ function registerIntakeToBuildTools(server2, client, builderClient) {
     },
     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) AND calendars: 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). Staff-requiring calendars (round_robin etc.) auto-build only when you are the sole account user (auto-assigns you as the team member); with 0 or 2+ users they're surfaced as a manual step, not auto-staffed to a guess. 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 calendarManualLines = exec.manual.map((m) => `[calendar] ${m.reason}`);
+          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,
+            manual: exec.manual,
+            idMap: exec.idMap,
+            deferred: exec.deferred,
+            deferredNote: "execute builds the CRM backbone (pipelines, custom fields, tags, custom values) and calendars live. Staff-requiring calendars (round_robin etc.) auto-build only when you are the sole user; otherwise they're listed under manual steps. Forms/funnels/workflows are planned but NOT auto-built yet \u2014 create them via the GHL UI or the dedicated tools, in this order: forms \u2192 funnels \u2192 workflows.",
+            nextManualSteps: [...calendarManualLines, ...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.manual.length ? ` ${exec.manual.length} calendar(s) need manual staff assignment.` : ""}${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)
+          })),
+          calendarsManual: result.calendarsManual,
+          handoffs: result.handoffs,
+          report,
+          next: 'Review the report. When it looks right, re-run with mode:"execute" to build the CRM backbone + calendars 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) {
@@ -10967,7 +11943,7 @@ function registerIntakeToBuildTools(server2, client, builderClient) {
           resolved.set(q.key, rec);
         }
         if (!missing) break;
-        if (attempt < 6) await sleep(700 * attempt);
+        if (attempt < 6) await sleep2(700 * attempt);
       }
       if (missing) {
         throw new Error(
@@ -11033,7 +12009,7 @@ function registerIntakeToBuildTools(server2, client, builderClient) {
             break;
           } catch (saveErr) {
             if (justCreated && isFormNotYetPropagated(saveErr) && attempt < maxSaveAttempts) {
-              await sleep(700 * attempt);
+              await sleep2(700 * attempt);
               continue;
             }
             throw saveErr;
@@ -11045,7 +12021,7 @@ function registerIntakeToBuildTools(server2, client, builderClient) {
           const verify = await formApiRequest(bc, "GET", `/${resolvedFormId}?locationId=${locationId2}`);
           persistedCount = countFormFields(verify);
           if (persistedCount > 0) break;
-          if (attempt < 6) await sleep(700 * attempt);
+          if (attempt < 6) await sleep2(700 * attempt);
         }
         const fieldMap = {};
         for (const [key, rec] of resolved) fieldMap[key] = rec.id;
@@ -11367,8 +12343,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elitedcs/ghl-mcp",
-  "version": "3.36.0",
+  "version": "3.38.0",
   "mcpName": "io.github.drjerryrelth/ghl-command",
   "description": "GoHighLevel MCP Server for Claude. 218 tools — 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",