@elitedcs/ghl-mcp 3.75.0 → 3.76.0

package/dist/index.js

@@ -918,6 +918,129 @@ var init_id_shape = __esm({
   }
 });
 
+// src/parked-guard.ts
+function stable(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stable(value[k])}`).join(",")}}`;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function referencedStepIds(action) {
+  const out = [];
+  const attrs = isRecord(action.attributes) ? action.attributes : void 0;
+  const extras = attrs && isRecord(attrs.extras) ? attrs.extras : void 0;
+  if (!extras) return out;
+  const list2 = extras.stepIds;
+  if (Array.isArray(list2)) {
+    for (const id of list2) if (typeof id === "string" && id) out.push(id);
+  }
+  const invoice = extras.invoiceStepId;
+  if (typeof invoice === "string" && invoice) out.push(invoice);
+  return out;
+}
+function branchTargetStepIds(action) {
+  const out = [];
+  const attrs = isRecord(action.attributes) ? action.attributes : void 0;
+  if (!attrs) return out;
+  const quick = isRecord(attrs.quickReplies) ? attrs.quickReplies.transitions : void 0;
+  for (const table of [attrs.transitions, attrs.nonBranchingTransitions, quick]) {
+    if (!Array.isArray(table)) continue;
+    for (const entry of table) {
+      if (isRecord(entry) && typeof entry.id === "string" && entry.id) out.push(entry.id);
+    }
+  }
+  return out;
+}
+function protectedClosure(parkedIds, byId2) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...parkedIds];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const node = byId2.get(id);
+    if (!node) continue;
+    for (const ref of referencedStepIds(node)) if (!seen.has(ref)) queue.push(ref);
+  }
+  return seen;
+}
+function disturbedStepIds(current, next) {
+  const nextById = new Map(next.filter(hasId).map((a) => [a.id, a]));
+  const out = /* @__PURE__ */ new Set();
+  for (const before of current.filter(hasId)) {
+    const after = nextById.get(before.id);
+    if (!after || stable(before) !== stable(after)) out.add(before.id);
+  }
+  return out;
+}
+function parkedRefusal(current, next, parked) {
+  const occupied = parked.filter((p) => p.total > 0 && typeof p.currentStepId === "string" && p.currentStepId);
+  if (occupied.length === 0) return null;
+  const currentById = new Map(current.filter(hasId).map((a) => [a.id, a]));
+  const nextById = new Map(next.filter(hasId).map((a) => [a.id, a]));
+  const contactsByStep = new Map(occupied.map((p) => [p.currentStepId, p.total]));
+  const guarded = protectedClosure([...contactsByStep.keys()], currentById);
+  const deleted = [];
+  const altered = [];
+  for (const id of guarded) {
+    const before = currentById.get(id);
+    if (!before) continue;
+    const after = nextById.get(id);
+    if (!after) {
+      deleted.push(id);
+      continue;
+    }
+    if (stable(before) !== stable(after)) altered.push(id);
+  }
+  for (const id of guarded) {
+    const head2 = currentById.get(id);
+    if (!head2) continue;
+    for (const target of branchTargetStepIds(head2)) {
+      if (guarded.has(target) || deleted.includes(target)) continue;
+      if (currentById.has(target) && !nextById.has(target)) deleted.push(target);
+    }
+  }
+  if (deleted.length === 0 && altered.length === 0) return null;
+  const touched = /* @__PURE__ */ new Set([...deleted, ...altered]);
+  let contacts = 0;
+  for (const [stepId, total] of contactsByStep) {
+    const own = protectedClosure([stepId], currentById);
+    let affected = false;
+    for (const id of own) {
+      if (touched.has(id)) {
+        affected = true;
+        break;
+      }
+      const node = currentById.get(id);
+      if (node && branchTargetStepIds(node).some((t) => touched.has(t))) {
+        affected = true;
+        break;
+      }
+    }
+    if (affected) contacts += total;
+  }
+  if (contacts === 0) for (const total of contactsByStep.values()) contacts += total;
+  const parts = [];
+  if (deleted.length > 0) parts.push(`${deleted.length} would be removed (${deleted.join(", ")})`);
+  if (altered.length > 0) parts.push(`${altered.length} would be changed (${altered.join(", ")})`);
+  return {
+    deleted,
+    altered,
+    contacts,
+    message: `Refused: ${contacts} contact(s) are part-way through this workflow, and this change would disturb the step they are waiting on \u2014 ${parts.join(", and ")}. They would be dropped from the sequence with no way to put them back, so nothing was written. Every other step in this workflow can still be edited. Wait until nobody is mid-sequence, or move those contacts on deliberately first.`
+  };
+}
+var hasId;
+var init_parked_guard = __esm({
+  "src/parked-guard.ts"() {
+    "use strict";
+    hasId = (a) => typeof a.id === "string" && a.id.length > 0;
+  }
+});
+
 // src/trigger-schemas.ts
 function describe(status, knownFields) {
   switch (status) {
@@ -1328,6 +1451,64 @@ var init_trigger_schemas = __esm({
 });
 
 // src/workflow-builder-client.ts
+function isParkedContactsError(e) {
+  return typeof e === "object" && e !== null && e.code === "PARKED_CONTACTS";
+}
+function rewriteActionIdRefs(action, remap) {
+  const a = action;
+  const swap = (v) => typeof v === "string" && remap.has(v) ? remap.get(v) : v;
+  if (typeof a.id === "string" && remap.has(a.id)) a.id = remap.get(a.id);
+  for (const key of ["parent", "parentKey"]) if (typeof a[key] === "string") a[key] = swap(a[key]);
+  if (typeof a.next === "string") a.next = swap(a.next);
+  else if (Array.isArray(a.next)) a.next = a.next.map(swap);
+  if (Array.isArray(a.sibling)) a.sibling = a.sibling.map(swap);
+  const attrs = a.attributes;
+  if (typeof attrs !== "object" || attrs === null || Array.isArray(attrs)) return;
+  const at = attrs;
+  if (Array.isArray(at.branches)) {
+    for (const b of at.branches) {
+      if (!isRecord2(b)) continue;
+      if (typeof b.id === "string") b.id = swap(b.id);
+      if (!Array.isArray(b.segments)) continue;
+      for (const seg of b.segments) {
+        if (!isRecord2(seg) || !Array.isArray(seg.conditions)) continue;
+        for (const cond of seg.conditions) {
+          if (isRecord2(cond) && typeof cond.ifElseNodeId === "string") cond.ifElseNodeId = swap(cond.ifElseNodeId);
+        }
+      }
+    }
+  }
+  if (typeof at.targetNodeId === "string") at.targetNodeId = swap(at.targetNodeId);
+  const quick = isRecord2(at.quickReplies) ? at.quickReplies.transitions : void 0;
+  for (const table of [at.transitions, at.nonBranchingTransitions, quick]) {
+    if (!Array.isArray(table)) continue;
+    for (const entry of table) {
+      if (isRecord2(entry) && typeof entry.id === "string") entry.id = swap(entry.id);
+    }
+  }
+  const extras = at.extras;
+  if (typeof extras === "object" && extras !== null && !Array.isArray(extras)) {
+    const ex = extras;
+    if (Array.isArray(ex.stepIds)) ex.stepIds = ex.stepIds.map(swap);
+    if (typeof ex.invoiceStepId === "string") ex.invoiceStepId = swap(ex.invoiceStepId);
+  }
+}
+function coerceLegacyWriteShapes(action) {
+  const attrs = action.attributes;
+  if (typeof attrs !== "object" || attrs === null || Array.isArray(attrs)) return action;
+  const a = attrs;
+  const startAfter = a.startAfter;
+  if (typeof startAfter === "object" && startAfter !== null && !Array.isArray(startAfter)) {
+    const sa = startAfter;
+    if (sa.type === "day") {
+      return { ...action, attributes: { ...a, startAfter: { ...sa, type: "days" } } };
+    }
+  }
+  if (action.type === "internal_notification" && a.type === "inapp") {
+    return { ...action, attributes: { ...a, type: "notification" } };
+  }
+  return action;
+}
 function normalizeRemoveFromWorkflowAction(action) {
   if (action.type !== "remove_from_workflow") return action;
   const attrs = action.attributes;
@@ -1399,13 +1580,13 @@ function normalizeInternalUpdateOpportunityAction(action) {
   delete attributes.workflowsActionType;
   return { ...action, workflowsActionType: "INTERNAL", attributes };
 }
-function hasId(action) {
+function hasId2(action) {
   return typeof action.id === "string" && action.id.length > 0;
 }
 function hasTriggerId(trigger) {
   return typeof trigger.id === "string" && trigger.id.length > 0;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function getStringArray(value) {
@@ -1415,9 +1596,20 @@ function getStringArray(value) {
   return value;
 }
 function validateActionChain(actions, existingIds) {
-  const byId2 = new Map(actions.filter(hasId).map((action) => [action.id, action]));
+  const duplicates = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const action of actions.filter(hasId2)) {
+    if (seenIds.has(action.id)) duplicates.add(action.id);
+    seenIds.add(action.id);
+  }
+  if (duplicates.size > 0) {
+    throw new Error(
+      `Two or more steps share the same id: ${[...duplicates].join(", ")}. Ids identify a step to GoHighLevel and to any contact waiting on it, so they must be unique. Give each step its own id, or omit the id and one will be generated.`
+    );
+  }
+  const byId2 = new Map(actions.filter(hasId2).map((action) => [action.id, action]));
   for (const action of actions) {
-    const attr = isRecord(action.attributes) ? action.attributes : void 0;
+    const attr = isRecord2(action.attributes) ? action.attributes : void 0;
     if (!attr) continue;
     switch (action.type) {
       case "sms":
@@ -1438,7 +1630,7 @@ function validateActionChain(actions, existingIds) {
         }
         break;
       case "internal_update_opportunity": {
-        const isRoundTripped = hasId(action) && (existingIds ? existingIds.has(action.id) : true);
+        const isRoundTripped = hasId2(action) && (existingIds ? existingIds.has(action.id) : true);
         if (!isRoundTripped) {
           const cif = Array.isArray(attr.__customInputFields__) ? attr.__customInputFields__ : null;
           if (!cif) {
@@ -1459,7 +1651,7 @@ function validateActionChain(actions, existingIds) {
         break;
       }
       case "internal_create_opportunity": {
-        const isRoundTripped = hasId(action) && (existingIds ? existingIds.has(action.id) : true);
+        const isRoundTripped = hasId2(action) && (existingIds ? existingIds.has(action.id) : true);
         if (!isRoundTripped) {
           const cif = Array.isArray(attr.__customInputFields__) ? attr.__customInputFields__ : [];
           const listed = (ff) => cif.find((f) => f && f.filterField === ff);
@@ -1505,8 +1697,8 @@ function validateActionChain(actions, existingIds) {
             throw new Error(`Webhook action "${action.name}" needs '${field}' to be an array of {key, value} pairs.`);
           }
           for (const entry of entries) {
-            const key = isRecord(entry) ? entry.key : void 0;
-            const value = isRecord(entry) ? entry.value : void 0;
+            const key = isRecord2(entry) ? entry.key : void 0;
+            const value = isRecord2(entry) ? entry.value : void 0;
             if (typeof key !== "string" || !key.trim() || value === void 0 || value === null) {
               throw new Error(
                 `Webhook action "${action.name}" has an empty '${field}' pair. Every entry needs a non-empty key and a value.`
@@ -1543,7 +1735,7 @@ function validateActionChain(actions, existingIds) {
   }
   for (const action of actions) {
     if (action.type !== "find_opportunity") continue;
-    if (existingIds && hasId(action) && existingIds.has(action.id)) continue;
+    if (existingIds && hasId2(action) && existingIds.has(action.id)) continue;
     if (!action.id) throw new Error(`find_opportunity "${action.name}" missing id.`);
     const next = getStringArray(action.next);
     if (!next || next.length !== 2) {
@@ -1567,7 +1759,7 @@ function validateActionChain(actions, existingIds) {
     }
   }
 }
-var fs4, path4, dotenv, import_zod4, BACKEND_BASE, FIREBASE_TOKEN_URL, MAX_RETRIES2, BASE_DELAY_MS2, FirebaseTokenSchema, WorkflowActionSchema, WorkflowFullSchema, CreateWorkflowResponseSchema, WorkflowBuilderClient;
+var fs4, path4, dotenv, import_zod4, BACKEND_BASE, FIREBASE_TOKEN_URL, MAX_RETRIES2, BASE_DELAY_MS2, FirebaseTokenSchema, WorkflowActionSchema, WorkflowFullSchema, CreateWorkflowResponseSchema, ParkedContactsError, UUID_V4, WorkflowBuilderClient;
 var init_workflow_builder_client = __esm({
   "src/workflow-builder-client.ts"() {
     "use strict";
@@ -1580,6 +1772,7 @@ var init_workflow_builder_client = __esm({
     init_retry();
     init_firebase_claims();
     init_id_shape();
+    init_parked_guard();
     init_trigger_schemas();
     BACKEND_BASE = "https://backend.leadconnectorhq.com/workflow";
     FIREBASE_TOKEN_URL = "https://securetoken.googleapis.com/v1/token";
@@ -1625,6 +1818,16 @@ var init_workflow_builder_client = __esm({
         version: typeof data.version === "number" ? data.version : 1
       });
     });
+    ParkedContactsError = class extends Error {
+      constructor(message, contacts) {
+        super(message);
+        this.contacts = contacts;
+        this.name = "ParkedContactsError";
+      }
+      contacts;
+      code = "PARKED_CONTACTS";
+    };
+    UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
     WorkflowBuilderClient = class _WorkflowBuilderClient {
       // Active Firebase auth — swapped when operating in another company's GHL.
       firebaseApiKey;
@@ -1946,6 +2149,56 @@ var init_workflow_builder_client = __esm({
           Version: "2021-07-28"
         };
       }
+      /**
+       * Who is part-way through this workflow, and which step they are sitting on.
+       *
+       * This is the read the parked-contact guard is built on. It is the endpoint
+       * GoHighLevel's own Automation UI uses for its Enrolment view — found by
+       * reading that module's public JS bundle, because the UI runs in a
+       * cross-origin iframe and neither a network log nor a page-level interceptor
+       * can see its calls (2026-09-01).
+       *
+       *   GET {backend}/workflows/status/search/count-per-step
+       *       ?workflowId={wf}&locationId={loc}
+       *   → [{ "total": 1, "currentStepId": "f065696d-…" }]
+       *
+       * Verified live, read-only, on two accounts. Two behaviours worth keeping:
+       *   - `workflowId` is SINGULAR and a string. Passing `workflowIds` returns 422
+       *     "property workflowIds should not exist" — which only appears AFTER auth
+       *     passes, so it doubles as the quickest auth check.
+       *   - `[]` means nobody is MID-SEQUENCE. A workflow can show enrolments in the
+       *     UI and still return `[]`; those are finished, and they must not block a
+       *     write.
+       *
+       * FAILS CLOSED. If this read cannot be completed we do not know whether anyone
+       * is parked, and a guard that assumes "probably nobody" is not a guard.
+       */
+      async parkedContacts(workflowId) {
+        const url = `https://backend.leadconnectorhq.com/workflows/status/search/count-per-step?workflowId=${encodeURIComponent(workflowId)}&locationId=${encodeURIComponent(this.locationId)}`;
+        const res = await fetch(url, { headers: await this.buildHeaders() });
+        if (!res.ok) {
+          throw new Error(
+            `Could not check whether anyone is part-way through this workflow (HTTP ${res.status}). Nothing was written. This check has to succeed before a step can be changed, because changing a step somebody is waiting on drops them from the sequence permanently.`
+          );
+        }
+        const body = await res.json();
+        if (!Array.isArray(body)) {
+          throw new Error(
+            `The check for contacts part-way through this workflow returned something unexpected, so it is not possible to tell whether anyone would be dropped. Nothing was written.`
+          );
+        }
+        return body.map((row) => {
+          const r = typeof row === "object" && row !== null && !Array.isArray(row) ? row : null;
+          const total = r && typeof r.total === "number" ? r.total : null;
+          const currentStepId = r && typeof r.currentStepId === "string" && r.currentStepId ? r.currentStepId : null;
+          if (total === null || currentStepId === null) {
+            throw new Error(
+              `The check for contacts part-way through this workflow returned a row that could not be read, so it is not possible to tell whether anyone would be dropped. Nothing was written.`
+            );
+          }
+          return { total, currentStepId };
+        });
+      }
       /**
        * Make a request to the internal workflow API.
        * Retries on 429, 5xx, and transient network errors with exponential backoff.
@@ -2027,9 +2280,9 @@ ${errorBody}`
        */
       async getWorkflow(workflowId) {
         const raw = await this.request("GET", `/${this.locationId}/${workflowId}?includeTriggers=true`);
-        const flat = isRecord(raw) && isRecord(raw.workflowData) ? {
+        const flat = isRecord2(raw) && isRecord2(raw.workflowData) ? {
           ...raw.workflowData,
-          workflowData: isRecord(raw.workflowData.workflowData) ? raw.workflowData.workflowData : { templates: [] },
+          workflowData: isRecord2(raw.workflowData.workflowData) ? raw.workflowData.workflowData : { templates: [] },
           triggers: raw.triggers
         } : raw;
         const parsed = WorkflowFullSchema.parse(flat);
@@ -2065,17 +2318,22 @@ ${errorBody}`
       async updateWorkflow(workflowId, updates) {
         const current = await this.getWorkflow(workflowId);
         const effectiveStatus = updates.status ?? current.status;
-        if (updates.triggers !== void 0) {
-          await this.syncTriggers(workflowId, current.triggers || [], updates.triggers, effectiveStatus);
-        }
         const currentActions = current.workflowData?.templates || [];
         const newActions = updates.actions ?? currentActions;
-        const existingActionIds = new Set(currentActions.filter(hasId).map((a) => a.id));
+        const existingActionIds = new Set(currentActions.filter(hasId2).map((a) => a.id));
         const linkedActions = this.buildActionChain(newActions, existingActionIds);
-        const currentIds = new Set(currentActions.filter(hasId).map((a) => a.id));
-        const newIds = new Set(linkedActions.filter(hasId).map((a) => a.id));
-        const createdSteps = linkedActions.filter(hasId).filter((a) => !currentIds.has(a.id)).map((a) => a.id);
-        const deletedSteps = currentActions.filter(hasId).filter((a) => !newIds.has(a.id)).map((a) => a.id);
+        if (currentActions.length > 0 && disturbedStepIds(currentActions, linkedActions).size > 0) {
+          const parked = await this.parkedContacts(workflowId);
+          const refusal = parkedRefusal(currentActions, linkedActions, parked);
+          if (refusal) throw new Error(refusal.message);
+        }
+        if (updates.triggers !== void 0) {
+          await this.syncTriggers(workflowId, current.triggers || [], updates.triggers, effectiveStatus);
+        }
+        const currentIds = new Set(currentActions.filter(hasId2).map((a) => a.id));
+        const newIds = new Set(linkedActions.filter(hasId2).map((a) => a.id));
+        const createdSteps = linkedActions.filter(hasId2).filter((a) => !currentIds.has(a.id)).map((a) => a.id);
+        const deletedSteps = currentActions.filter(hasId2).filter((a) => !newIds.has(a.id)).map((a) => a.id);
         const body = {
           name: updates.name ?? current.name,
           isRestoreRequest: true,
@@ -2111,7 +2369,15 @@ ${errorBody}`
       /**
        * Delete a workflow
        */
-      async deleteWorkflow(workflowId) {
+      async deleteWorkflow(workflowId, opts) {
+        const parked = await this.parkedContacts(workflowId);
+        const contacts = parked.reduce((sum, p) => sum + p.total, 0);
+        if (contacts > 0 && opts?.acknowledgeContacts !== contacts) {
+          throw new ParkedContactsError(
+            `Refused: ${contacts} contact(s) are part-way through this workflow right now. Deleting it drops every one of them out of the sequence, and there is no way to put them back. Nothing was deleted. If that is what you intend, re-run it acknowledging ${contacts} contact(s).`,
+            contacts
+          );
+        }
         return this.request("DELETE", `/${this.locationId}/${workflowId}`);
       }
       /**
@@ -2142,7 +2408,7 @@ ${errorBody}`
           returned = typeof after.status === "string" ? after.status : null;
         } catch (e) {
           readBackFailed = e instanceof Error ? e.message : String(e);
-          returned = isRecord(result) && typeof result.status === "string" ? result.status : null;
+          returned = isRecord2(result) && typeof result.status === "string" ? result.status : null;
         }
         const publish_check = {
           published: returned === "published",
@@ -2160,7 +2426,7 @@ ${errorBody}`
         if (triggers.length === 0) {
           publish_check.note = "This workflow has NO TRIGGER, so nothing starts it on its own. That is only correct if another workflow adds contacts to it; otherwise its trigger did not save.";
         }
-        return isRecord(result) ? { ...result, publish_check } : { result, publish_check };
+        return isRecord2(result) ? { ...result, publish_check } : { result, publish_check };
       }
       /**
        * Create a workflow trigger. GHL generates the Firestore id and returns it.
@@ -2170,7 +2436,7 @@ ${errorBody}`
       async createTrigger(workflowId, trigger, workflowStatus) {
         const payload = this.buildTriggerPayload(workflowId, trigger, workflowStatus);
         const raw = await this.request("POST", `/${this.locationId}/trigger`, payload);
-        if (isRecord(raw) && typeof raw.id === "string") {
+        if (isRecord2(raw) && typeof raw.id === "string") {
           return raw.id;
         }
         throw new Error(`Trigger creation did not return an id. Response: ${JSON.stringify(raw)}`);
@@ -2251,7 +2517,7 @@ ${errorBody}`
        */
       buildActionChain(actions, existingIds) {
         validateActionChain(actions, existingIds);
-        const linked = actions.map(normalizeRemoveFromWorkflowAction).map(normalizeInternalUpdateOpportunityAction).map(normalizeInternalCreateOpportunityAction).map((action, i) => {
+        const linked = actions.map(coerceLegacyWriteShapes).map(normalizeRemoveFromWorkflowAction).map(normalizeInternalUpdateOpportunityAction).map(normalizeInternalCreateOpportunityAction).map((action, i) => {
           const copy = { ...action };
           if (!copy.id) {
             copy.id = crypto.randomUUID();
@@ -2261,6 +2527,17 @@ ${errorBody}`
           }
           return copy;
         });
+        const remap = /* @__PURE__ */ new Map();
+        for (const action of linked) {
+          const id = action.id;
+          if (typeof id !== "string" || !id) continue;
+          if (existingIds?.has(id)) continue;
+          if (UUID_V4.test(id)) continue;
+          remap.set(id, crypto.randomUUID());
+        }
+        if (remap.size > 0) {
+          for (const action of linked) rewriteActionIdRefs(action, remap);
+        }
         for (let i = 0; i < linked.length; i++) {
           const action = linked[i];
           if (action.parent || action.nodeType) continue;
@@ -3553,8 +3830,8 @@ function registerContactTools(server2, client) {
       taskId: import_zod9.z.string().min(1).describe("The ID of the task (from get_contact_tasks or create_contact_task)."),
       completed: import_zod9.z.boolean().optional().describe("true (default) marks the task completed; false reopens a completed task.")
     },
-    async ({ contactId, taskId, completed }) => {
-      return client.put(`/contacts/${contactId}/tasks/${taskId}/completed`, {
+    async ({ contactId, taskId: taskId2, completed }) => {
+      return client.put(`/contacts/${contactId}/tasks/${taskId2}/completed`, {
         body: { completed: completed ?? true }
       });
     }
@@ -3572,7 +3849,7 @@ function registerContactTools(server2, client) {
       completed: import_zod9.z.boolean().optional().describe("Set the completed state of the task."),
       assignedTo: import_zod9.z.string().optional().describe("User ID to reassign the task to.")
     },
-    async ({ contactId, taskId, title: title2, body: taskBody, dueDate, completed, assignedTo }) => {
+    async ({ contactId, taskId: taskId2, title: title2, body: taskBody, dueDate, completed, assignedTo }) => {
       if (dueDate !== void 0 && !isDateOnly(dueDate) && !hasTimezoneOffset(dueDate)) {
         throw new Error(
           `dueDate "${dueDate}" carries no timezone offset, so it does not say which 9am it means. GHL reads it as UTC and stores a different local hour \u2014 a task set for 9am in US/Arizona lands at 2am. Add the offset, e.g. "2026-09-15T09:00:00-07:00", or "...Z" for UTC. Nothing was changed.`
@@ -3584,7 +3861,7 @@ function registerContactTools(server2, client) {
           "Nothing to update: pass at least one of title, body, dueDate, completed, assignedTo."
         );
       }
-      return client.put(`/contacts/${contactId}/tasks/${taskId}`, { body: reqBody });
+      return client.put(`/contacts/${contactId}/tasks/${taskId2}`, { body: reqBody });
     }
   );
   safeTool(
@@ -3596,8 +3873,8 @@ function registerContactTools(server2, client) {
       taskId: import_zod9.z.string().min(1).describe("The ID of the task to delete (from get_contact_tasks)."),
       confirm: import_zod9.z.literal("DELETE").describe("Must pass 'DELETE' to confirm this destructive action.")
     },
-    async ({ contactId, taskId }) => {
-      return client.delete(`/contacts/${contactId}/tasks/${taskId}`);
+    async ({ contactId, taskId: taskId2 }) => {
+      return client.delete(`/contacts/${contactId}/tasks/${taskId2}`);
     }
   );
   safeTool(
@@ -3784,7 +4061,7 @@ function registerConversationTools(server2, client) {
       if (emailBcc !== void 0) body.emailBcc = emailBcc;
       if (attachments !== void 0) body.attachments = attachments;
       const result = await client.post("/conversations/messages", { body });
-      const messageId = isRecord2(result) && typeof result.messageId === "string" ? result.messageId : null;
+      const messageId = isRecord3(result) && typeof result.messageId === "string" ? result.messageId : null;
       if (!messageId) return result;
       const TERMINAL = /* @__PURE__ */ new Set(["delivered", "sent", "failed", "undelivered", "rejected", "opted_out"]);
       let status = null;
@@ -3794,7 +4071,7 @@ function registerConversationTools(server2, client) {
         if (attempt > 0) await new Promise((r) => setTimeout(r, 1200 * attempt));
         try {
           const raw = await client.get(`/conversations/messages/${messageId}`);
-          const msg3 = isRecord2(raw) && isRecord2(raw.message) ? raw.message : isRecord2(raw) ? raw : null;
+          const msg3 = isRecord3(raw) && isRecord3(raw.message) ? raw.message : isRecord3(raw) ? raw : null;
           status = typeof msg3?.status === "string" ? msg3.status : null;
           from = typeof msg3?.from === "string" ? msg3.from : from;
           readError = null;
@@ -3815,7 +4092,7 @@ function registerConversationTools(server2, client) {
       } else if (!delivered) {
         delivery_check.warning = `NOT DELIVERED. GHL reports status "${status ?? "(none)"}" for this message. Do not report it as sent.`;
       }
-      return isRecord2(result) ? { ...result, delivery_check } : { result, delivery_check };
+      return isRecord3(result) ? { ...result, delivery_check } : { result, delivery_check };
     }
   );
   safeTool(
@@ -3861,13 +4138,13 @@ function registerConversationTools(server2, client) {
     }
   );
 }
-var import_zod10, isRecord2;
+var import_zod10, isRecord3;
 var init_conversations = __esm({
   "src/tools/conversations.ts"() {
     "use strict";
     import_zod10 = require("zod");
     init_tool_helpers();
-    isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    isRecord3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   }
 });
 
@@ -7577,9 +7854,10 @@ function registerWebhookTools(server2, builderClient) {
     {
       webhookId: import_zod34.z.string().describe("The webhook ID (its workflow ID)."),
       confirm: import_zod34.z.literal("DELETE").describe("Must be 'DELETE' to confirm this destructive action."),
-      force: import_zod34.z.boolean().optional().describe("Delete even when the workflow contains other actions that would go with it.")
+      force: import_zod34.z.boolean().optional().describe("Delete even when the workflow contains other actions that would go with it."),
+      acknowledgeContacts: import_zod34.z.number().optional().describe("Only needed if contacts are part-way through this workflow. Deleting drops them permanently and they cannot be put back. The first attempt tells you the number; pass it here to proceed.")
     },
-    async ({ webhookId, confirm: confirm2, force }) => {
+    async ({ webhookId, confirm: confirm2, force, acknowledgeContacts }) => {
       try {
         const client = requireClient();
         if (confirm2 !== "DELETE") throw new Error("Pass confirm: 'DELETE' to delete a webhook.");
@@ -7594,7 +7872,7 @@ function registerWebhookTools(server2, builderClient) {
             `Workflow "${summary.name}" does more than fire a webhook \u2014 deleting it would delete those steps too. Pass force: true if that is what you want, or use update_webhook with status 'draft' to just stop it firing.`
           );
         }
-        await client.deleteWorkflow(webhookId);
+        await client.deleteWorkflow(webhookId, { acknowledgeContacts });
         return jsonResponse({ deleted: true, webhookId, name: summary.name });
       } catch (error) {
         return errorResponse(error);
@@ -8190,14 +8468,15 @@ function registerWorkflowBuilderTools(server2, client) {
   );
   server2.tool(
     "delete_workflow_full",
-    "Permanently delete a workflow. IRREVERSIBLE.",
+    "Permanently delete a workflow. IRREVERSIBLE. If contacts are part-way through it, the first attempt refuses and tells you how many would be dropped \u2014 deleting removes them from the sequence permanently and they cannot be restored.",
     {
       workflowId: import_zod36.z.string().describe("The workflow ID to delete."),
-      confirm: import_zod36.z.literal("DELETE").describe("Must pass 'DELETE' to confirm this destructive action.")
+      confirm: import_zod36.z.literal("DELETE").describe("Must pass 'DELETE' to confirm this destructive action."),
+      acknowledgeContacts: import_zod36.z.number().optional().describe("Only needed if contacts are part-way through this workflow. Deleting drops them out of the sequence permanently and they cannot be put back. The first attempt tells you the number; pass it here to proceed.")
     },
-    async ({ workflowId }) => {
+    async ({ workflowId, acknowledgeContacts }) => {
       try {
-        const result = await client.deleteWorkflow(workflowId);
+        const result = await client.deleteWorkflow(workflowId, { acknowledgeContacts });
         return jsonResponse(result);
       } catch (error) {
         return errorResponse(error);
@@ -10964,7 +11243,31 @@ var init_attestation = __esm({
 });
 
 // src/setup-tool.ts
-function deviceFingerprint2() {
+function stableFallbackId() {
+  let user;
+  try {
+    user = os2.userInfo().username;
+  } catch {
+    user = process.env.USER || process.env.USERNAME || process.env.LOGNAME || "no-user";
+  }
+  const raw = `${user}:${os2.platform()}:${os2.arch()}`;
+  return crypto4.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function warnNoDurableId() {
+  if (warnedNoDurableId) return;
+  warnedNoDurableId = true;
+  let where = "the config folder";
+  try {
+    const store = (init_credentials_store(), __toCommonJS(credentials_store_exports));
+    where = store.appDataDir();
+  } catch {
+  }
+  process.stderr.write(
+    `[ghl-mcp] Warning: this machine's identity could not be stored in ${where}, so a derived one is being used. Your licence still works and no extra install slot is consumed. If this keeps appearing, that folder is not writable \u2014 set GHL_MCP_CONFIG_DIR to a folder you own.
+`
+  );
+}
+function licenseDeviceId() {
   try {
     const store = (init_credentials_store(), __toCommonJS(credentials_store_exports));
     const creds = store.readCredentials();
@@ -10974,7 +11277,14 @@ function deviceFingerprint2() {
       const att = (init_attestation(), __toCommonJS(attestation_exports));
       adopted = att.parseAttestationPayload(creds.signed_attestation)?.device_fingerprint;
     }
-    const id = adopted || telemetryDeviceId() || crypto4.randomBytes(8).toString("hex");
+    let id = adopted;
+    if (!id) {
+      id = telemetryDeviceId() ?? void 0;
+      if (!id) {
+        warnNoDurableId();
+        id = stableFallbackId();
+      }
+    }
     if (creds) {
       try {
         store.writeCredentials({ ...creds, device_id: id });
@@ -10983,8 +11293,7 @@ function deviceFingerprint2() {
     }
     return id;
   } catch {
-    const raw = `${os2.userInfo().username}:${os2.platform()}:${os2.arch()}`;
-    return crypto4.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+    return stableFallbackId();
   }
 }
 async function validateLicense(email, licenseKey) {
@@ -10996,7 +11305,7 @@ async function validateLicense(email, licenseKey) {
       body: JSON.stringify({
         email: email.trim(),
         license_key: licenseKey.trim(),
-        device_fingerprint: deviceFingerprint2()
+        device_fingerprint: licenseDeviceId()
       }),
       signal: AbortSignal.timeout(1e4)
     });
@@ -11553,7 +11862,7 @@ function registerLeadCaptureTool(server2) {
     }
   );
 }
-var os2, crypto4, import_zod43, LICENSE_API, CAPTURE_API, GHL_API, FIREBASE_TOKEN_API, LICENSE_REASON_MAP, setupPkgVersion;
+var os2, crypto4, import_zod43, LICENSE_API, CAPTURE_API, GHL_API, FIREBASE_TOKEN_API, warnedNoDurableId, LICENSE_REASON_MAP, setupPkgVersion;
 var init_setup_tool = __esm({
   "src/setup-tool.ts"() {
     "use strict";
@@ -11571,6 +11880,7 @@ var init_setup_tool = __esm({
     CAPTURE_API = "https://elitedcs.com/api/capture-lead";
     GHL_API = "https://services.leadconnectorhq.com";
     FIREBASE_TOKEN_API = "https://securetoken.googleapis.com/v1/token";
+    warnedNoDurableId = false;
     LICENSE_REASON_MAP = {
       unreachable: "license_unreachable",
       install_limit: "license_install_limit",
@@ -14587,6 +14897,12 @@ function traceOpportunityContext(node, byId2) {
   }
   return "dangling";
 }
+function isRecord4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isUuidV4(id) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+}
 function checkActionShapes(workflow) {
   const findings = [];
   const actions = Array.isArray(workflow.workflowData?.templates) ? workflow.workflowData.templates : [];
@@ -14659,9 +14975,79 @@ function checkActionShapes(workflow) {
   }
   return findings;
 }
+function checkSaveBlockers(workflow) {
+  const findings = [];
+  const actions = Array.isArray(workflow.workflowData?.templates) ? workflow.workflowData.templates : [];
+  for (const a of actions) {
+    const type = typeof a.type === "string" ? a.type : "unknown";
+    const name = typeof a.name === "string" ? a.name : "unnamed action";
+    const id = typeof a.id === "string" ? a.id : name;
+    const where = `action "${name}" (${type})`;
+    if (typeof a.id === "string" && a.id && !isUuidV4(a.id)) {
+      findings.push({
+        severity: "warning",
+        category: "legacy_step_id",
+        id,
+        where,
+        message: `${where} carries a step id GoHighLevel's validator now rejects when the workflow is saved ("${a.id}"). The workflow RUNS normally \u2014 it cannot be EDITED until the id is re-minted. Re-minting drops anyone currently waiting on that step, so it is refused while somebody is part-way through.`
+      });
+    }
+    {
+      const attrs = isRecord4(a.attributes) ? a.attributes : void 0;
+      const startAfter = attrs && isRecord4(attrs.startAfter) ? attrs.startAfter : void 0;
+      if (startAfter && (startAfter.type === "day" || startAfter.type === "minute")) {
+        findings.push({
+          severity: "warning",
+          category: "legacy_wait_unit",
+          id,
+          where,
+          message: `${where} uses the singular wait unit "${String(startAfter.type)}"; GoHighLevel requires the plural on save. It runs fine and blocks saves. This one is corrected automatically on the next write \u2014 no ids change and nobody is ejected.`
+        });
+      }
+    }
+    if (type === "internal_notification") {
+      const attrs = isRecord4(a.attributes) ? a.attributes : void 0;
+      const notif = attrs && isRecord4(attrs.notification) ? attrs.notification : void 0;
+      const selected = notif?.selectedUser;
+      const blank = selected === void 0 || selected === null || typeof selected === "string" && selected.trim() === "";
+      if (notif?.userType === "user" && blank) {
+        findings.push({
+          severity: "warning",
+          category: "missing_required_attribute",
+          id,
+          where,
+          message: `${where} is set to notify a specific person but nobody is selected, so it sends nothing. The workflow saves, publishes and runs \u2014 this step just never notifies anyone. Pick a user, or set it to notify everyone.`
+        });
+      }
+    }
+  }
+  return findings;
+}
+function checkMissingIntegrations(workflow, connectedPlatforms) {
+  const findings = [];
+  const actions = Array.isArray(workflow.workflowData?.templates) ? workflow.workflowData.templates : [];
+  for (const a of actions) {
+    const type = typeof a.type === "string" ? a.type : "";
+    const needs = SOCIAL_STEP_PLATFORMS.get(type);
+    if (!needs) continue;
+    if (needs.some((p) => connectedPlatforms.has(p))) continue;
+    const name = typeof a.name === "string" ? a.name : "unnamed action";
+    const id = typeof a.id === "string" ? a.id : name;
+    const label = needs.length > 1 ? needs.join(" or ") : needs[0];
+    findings.push({
+      severity: "warning",
+      category: "missing_integration",
+      id,
+      where: `action "${name}" (${type})`,
+      message: `action "${name}" needs a connected ${label} account and this location has none. The workflow saves, publishes and runs \u2014 this step just does nothing when it is reached. Connect the account in Settings \u2192 Integrations. (This check only sees a MISSING account: if the account is connected but its messaging permission was never granted, the step fails the same way and nothing here can tell you.)`
+    });
+  }
+  return findings;
+}
 function summarizeFindings(findings) {
   const issues = findings.filter((f) => f.severity === "error").length;
-  const warnings = findings.filter((f) => f.severity === "warning" && (f.category === "custom_field" || f.category === "action_shape")).length;
+  const WARNING_CATEGORIES = /* @__PURE__ */ new Set(["custom_field", "action_shape", "legacy_step_id", "legacy_wait_unit", "missing_required_attribute", "missing_integration"]);
+  const warnings = findings.filter((f) => f.severity === "warning" && WARNING_CATEGORIES.has(f.category)).length;
   return { status: issues > 0 ? "issues_found" : "ok", issues_count: issues, warnings_count: warnings };
 }
 function collectMergeTagKeys(value, out) {
@@ -15089,6 +15475,26 @@ function incompleteCatalogNote(stopReason, enumerated, reportedTotal) {
       return "";
   }
 }
+async function connectedSocialPlatforms(client, locationId2) {
+  try {
+    const raw = await client.get(`/social-media-posting/${locationId2}/accounts`);
+    const rec = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+    const root = rec(raw);
+    const results = root && rec(root.results);
+    const list2 = results?.accounts ?? root?.accounts;
+    if (!Array.isArray(list2)) return null;
+    const out = /* @__PURE__ */ new Set();
+    for (const row of list2) {
+      const r = rec(row);
+      if (!r) continue;
+      if (r.isExpired === true || r.deleted === true) continue;
+      if (typeof r.platform === "string") out.add(r.platform.toLowerCase());
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
 function registerValidatorTools(server2, client, builderClient) {
   if (!builderClient) {
     const finishInstallStub = (asked) => ({
@@ -15128,7 +15534,12 @@ function registerValidatorTools(server2, client, builderClient) {
         const workflow = await builderClient.getWorkflow(workflowId);
         if (!workflow) return errorResponse(new Error(`Workflow ${workflowId} not found`));
         const refs = [];
-        const shape = checkActionShapes(workflow);
+        const socialPlatforms = await connectedSocialPlatforms(client, client.defaultLocationId);
+        const shape = [
+          ...checkActionShapes(workflow),
+          ...checkSaveBlockers(workflow),
+          ...socialPlatforms ? checkMissingIntegrations(workflow, socialPlatforms) : []
+        ];
         const actionsChecked = Array.isArray(workflow.workflowData?.templates) ? workflow.workflowData.templates.length : 0;
         for (const t of Array.isArray(workflow.triggers) ? workflow.triggers : []) extractFromTrigger(t, refs);
         for (const a of Array.isArray(workflow.workflowData?.templates) ? workflow.workflowData.templates : []) extractFromAction(a, refs);
@@ -15190,6 +15601,7 @@ function registerValidatorTools(server2, client, builderClient) {
             notes: catalog.complete ? [] : [incompleteCatalogNote(catalog.stopReason, 0, catalog.reportedTotal)]
           });
         const lookups = await fetchAndBuildLookups(client, builderClient, locationId2, { ids: catalog.ids, complete: catalog.complete });
+        const auditSocialPlatforms = await connectedSocialPlatforms(client, locationId2);
         const SCAN_CAP = 300;
         const toScan = catalog.rows.slice(0, SCAN_CAP);
         const CONCURRENCY = 6;
@@ -15203,7 +15615,12 @@ function registerValidatorTools(server2, client, builderClient) {
               const wf = await builderClient.getWorkflow(row.id);
               const refs = auditOneWorkflow(wf, row.id, lookups);
               if (refs.length === 0) zeroRefCount++;
-              const findings = [...checkActionShapes(wf), ...checkRefs(refs, row.id, lookups)];
+              const findings = [
+                ...checkActionShapes(wf),
+                ...checkSaveBlockers(wf),
+                ...auditSocialPlatforms ? checkMissingIntegrations(wf, auditSocialPlatforms) : [],
+                ...checkRefs(refs, row.id, lookups)
+              ];
               results.push({ id: row.id, name: wf.name ?? row.name, status: wf.status, refs: refs.length, findings });
             } catch (e) {
               unscannable.push({ id: row.id, name: row.name, reason: e instanceof Error ? e.message : String(e) });
@@ -15262,7 +15679,7 @@ function registerValidatorTools(server2, client, builderClient) {
     }
   );
 }
-var import_zod53, ALL_CATEGORIES, OPPORTUNITY_CONTEXT_TRIGGERS, OPPORTUNITY_CREATING_TYPES, KNOWN_UPDATE_OPP_FIELDS, MAX_TRACE_HOPS, STANDARD_CONTACT_FIELDS, MERGE_TAG_RE;
+var import_zod53, ALL_CATEGORIES, OPPORTUNITY_CONTEXT_TRIGGERS, OPPORTUNITY_CREATING_TYPES, KNOWN_UPDATE_OPP_FIELDS, MAX_TRACE_HOPS, SOCIAL_STEP_PLATFORMS, STANDARD_CONTACT_FIELDS, MERGE_TAG_RE;
 var init_validators = __esm({
   "src/tools/validators.ts"() {
     "use strict";
@@ -15281,6 +15698,12 @@ var init_validators = __esm({
     OPPORTUNITY_CREATING_TYPES = /* @__PURE__ */ new Set(["internal_create_opportunity", "create_opportunity"]);
     KNOWN_UPDATE_OPP_FIELDS = /* @__PURE__ */ new Set(["pipelineId", "pipelineStageId", "name", "status", "source", "monetaryValue"]);
     MAX_TRACE_HOPS = 200;
+    SOCIAL_STEP_PLATFORMS = /* @__PURE__ */ new Map([
+      ["instagram-dm", ["instagram"]],
+      ["fb_interactive_messenger", ["facebook"]],
+      // A comment reply can be on either network; one connected account is enough.
+      ["respond_on_comment", ["facebook", "instagram"]]
+    ]);
     STANDARD_CONTACT_FIELDS = /* @__PURE__ */ new Set([
       "first_name",
       "firstname",
@@ -23802,6 +24225,142 @@ var init_plain_outcome = __esm({
   }
 });
 
+// src/manual-tasks.ts
+function taskId(text) {
+  const normalised = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim().slice(0, 160);
+  let h = 0;
+  for (let i = 0; i < normalised.length; i++) {
+    h = h * 31 + normalised.charCodeAt(i) | 0;
+  }
+  return `t${(h >>> 0).toString(36)}`;
+}
+function findingsFor(outcome) {
+  if (!outcome) return [];
+  const list2 = outcome.plain?.issues?.length ? outcome.plain.issues : outcome.issues;
+  return (list2 ?? []).map((s) => String(s).trim()).filter(Boolean);
+}
+function mergeTasks(previous, findings, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const before = new Map(previous.map((t) => [t.id, t]));
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const text of findings) {
+    const id = taskId(text);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const prior = before.get(id);
+    if (prior?.claimed) {
+      out.push({ id, text, reappeared: true });
+    } else {
+      out.push({ id, text, ...prior?.reappeared ? { reappeared: true } : {} });
+    }
+  }
+  void now;
+  return out;
+}
+function setTaskClaimed(tasks2, id, claimed, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return tasks2.map(
+    (t) => t.id !== id ? t : claimed ? { ...t, claimed: true, claimedAt: now, reappeared: false } : { id: t.id, text: t.text, ...t.reappeared ? { reappeared: true } : {} }
+  );
+}
+function manualProgress(tasks2, verifyHasRun) {
+  const total = tasks2.length;
+  const claimed = tasks2.filter((t) => t.claimed).length;
+  const reappeared = tasks2.filter((t) => t.reappeared).length;
+  const clear = verifyHasRun && total === 0;
+  let line2;
+  if (!verifyHasRun) {
+    line2 = "Run the check first. It writes this list for you.";
+  } else if (clear) {
+    line2 = "Nothing left to do by hand. The check came back clean.";
+  } else if (reappeared) {
+    line2 = `${reappeared} of these ${reappeared === 1 ? "was" : "were"} ticked off, but the last check still found ${reappeared === 1 ? "it" : "them"} in the account. Worth a second look before signing off.`;
+  } else if (claimed === total) {
+    line2 = "All ticked. Run the check again to confirm the account agrees.";
+  } else {
+    line2 = `${total - claimed} of ${total} still to do. These are the jobs only you can do in the account.`;
+  }
+  return { total, claimed, reappeared, clear, line: line2 };
+}
+function manualSignOffRefusal(tasks2, verifyHasRun) {
+  if (!verifyHasRun) {
+    return "Run the check first. It is what writes the list of manual jobs, so there is nothing to sign off yet.";
+  }
+  const p = manualProgress(tasks2, verifyHasRun);
+  if (p.clear) return null;
+  const left = p.total - p.claimed;
+  if (p.reappeared) {
+    return `The last check still found ${p.reappeared} ${p.reappeared === 1 ? "thing" : "things"} that ${p.reappeared === 1 ? "was" : "were"} ticked off. Fix it in the account, then run the check again \u2014 signing off now would record something the account disagrees with.`;
+  }
+  if (left > 0) {
+    return `${left} manual ${left === 1 ? "job is" : "jobs are"} still open. Do them in the account, tick them here, then run the check again.`;
+  }
+  return "Everything is ticked, but the check has not confirmed it yet. Run the check again and this will clear on its own.";
+}
+var init_manual_tasks = __esm({
+  "src/manual-tasks.ts"() {
+    "use strict";
+  }
+});
+
+// src/go-live.ts
+function parse3(t) {
+  const n = t ? Date.parse(t) : NaN;
+  return Number.isFinite(n) ? n : NaN;
+}
+function goLiveRefusal(e) {
+  if (!e.verify) {
+    return "This account has not been checked yet. Run the check, deal with anything it finds, then sign off.";
+  }
+  const manual = manualSignOffRefusal(e.manualTasks, true);
+  if (manual) return manual;
+  const findings = e.verify.plain?.issues?.length ? e.verify.plain.issues : e.verify.issues;
+  if (findings && findings.length) {
+    return `The last check found ${findings.length} ${findings.length === 1 ? "thing" : "things"} still wrong. Signing off now would tell your client an account works that we have just been told does not.`;
+  }
+  const v = parse3(e.verify.at);
+  const b = parse3(e.build?.at);
+  if (!Number.isFinite(b)) {
+    return "There is no dated record of the last build for this account, so we cannot tell whether the clean check came before or after it. Run the build step and the check again, in that order, then sign off.";
+  }
+  if (!Number.isFinite(v)) {
+    return "The last check has no usable date on it, so it cannot be shown to describe the account as it stands now. Run the check again, then sign off.";
+  }
+  if (b > v) {
+    return "The account was built into again after the last check, so the clean result is out of date. Run the check once more, then sign off on what it says.";
+  }
+  if (!e.by || !e.by.trim()) {
+    return "Put your name to it. A go-live signed by nobody is exactly the word-of-mouth 'done' this replaces.";
+  }
+  return null;
+}
+function signOff(e, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return { by: (e.by ?? "").trim(), at: now, verifiedAt: e.verify?.at ?? "" };
+}
+function liveClaim(stageIsDone, sig, lastBuildAt) {
+  if (!stageIsDone) return { live: false };
+  if (!sig || !sig.by || !sig.by.trim() || !Number.isFinite(parse3(sig.at))) {
+    return {
+      live: false,
+      warning: "This client is ticked as live but there is no signed record of it, so it cannot be shown as live. That happens when the board was restored from a backup or edited by hand. Run the check and sign it off properly."
+    };
+  }
+  const built = lastBuildAt ? Date.parse(lastBuildAt) : NaN;
+  const verified = sig.verifiedAt ? Date.parse(sig.verifiedAt) : NaN;
+  if (Number.isFinite(built) && Number.isFinite(verified) && built > verified) {
+    return {
+      live: true,
+      note: "Signed off, but the account has been built into since then, so that sign-off no longer describes what is in there now. Run the check again if you need to stand behind it."
+    };
+  }
+  return { live: true };
+}
+var init_go_live = __esm({
+  "src/go-live.ts"() {
+    "use strict";
+    init_manual_tasks();
+  }
+});
+
 // src/work-queue.ts
 function markKey(locationId2, stageIndex) {
   return `${locationId2}:${stageIndex}`;
@@ -23919,10 +24478,11 @@ function deriveQueue(input) {
     const updatedAt = state.clients[locationId2]?.updated_at || void 0;
     if (stages.every((s) => s === "done")) {
       const proof2 = lastProof(state, locationId2, QUEUE_STEPS.length);
+      const claim = liveClaim(true, state.goLive?.[locationId2]);
       finished.push({
         locationId: locationId2,
         clientName: name,
-        title: `${name} is live`,
+        title: claim.live ? `${name} is live` : `${name} is ticked live with no signed record`,
         ...updatedAt ? { finishedAt: updatedAt } : {},
         ...proof2 ? { proof: proof2 } : {}
       });
@@ -24047,6 +24607,7 @@ var init_work_queue = __esm({
     "use strict";
     init_stage_runner();
     init_plain_outcome();
+    init_go_live();
     QUEUE_STEPS = [
       { label: "Intake", todo: "Set up the intake questions for {client}", why: "Command OS puts the questionnaire into their account." },
       { label: "Brief", todo: "Write the build brief for {client}", why: "Command OS turns their answers into the plan." },
@@ -26779,9 +27340,10 @@ async function executeRevert(plan, deps) {
       attempted.push(item);
     } catch (e) {
       const detail = errText(e);
+      const parked = isParkedContactsError(e);
       refused.push({
         object: item.object,
-        reason: `GoHighLevel refused to remove ${SINGULAR[item.object.type].toLowerCase()} "${item.object.name}". This is usually because something else in the account still uses it. Remove it by hand in ${WHERE[item.object.type]}, or remove whatever still points at it and undo again.`,
+        reason: parked ? `Left alone: contacts are part-way through workflow "${item.object.name}", and removing it would drop them out of the sequence permanently. Everything else in this undo carried on. If you do want it gone, remove that one with delete_workflow_full \u2014 it will tell you how many people are affected and ask you to confirm that number.` : `GoHighLevel refused to remove ${SINGULAR[item.object.type].toLowerCase()} "${item.object.name}". This is usually because something else in the account still uses it. Remove it by hand in ${WHERE[item.object.type]}, or remove whatever still points at it and undo again.`,
         detail
       });
     }
@@ -26964,6 +27526,7 @@ var BUILD_ORDER, REVERT_ORDER, ORDER_INDEX, PLURAL, SINGULAR, WHERE, BOUND_REASO
 var init_revert = __esm({
   "src/intake-to-build/revert.ts"() {
     "use strict";
+    init_workflow_builder_client();
     BUILD_ORDER = [
       "user",
       "pipeline",
@@ -29097,6 +29660,12 @@ function makeExecuteDeps(client, builderClient, locationId2, registry2) {
       const full = await builderClient.getWorkflow(workflowId);
       return pickCalendarPins(full);
     },
+    // No acknowledgement threaded, deliberately. This is only used to roll back
+    // an UNSAVED workflow shell — one created moments earlier that never had its
+    // actions written. A shell has no steps, so nobody can be parked in it and
+    // the guard returns "nobody" and proceeds. If the parked read itself fails,
+    // the delete fails and `rollbackUnsavedShells` surfaces it in the halt message
+    // rather than swallowing it, which is the behaviour we want anyway.
     deleteWorkflow: async (workflowId) => {
       await builderClient.deleteWorkflow(workflowId);
     },
@@ -29113,6 +29682,17 @@ function makeRevertDeps(client, builderClient, locationId2) {
   return {
     remove: {
       // Reverse build order is enforced by revert.ts; this map is just routes.
+      // No acknowledgement is threaded here, and that is deliberate rather than
+      // an omission (Codex review, 2026-09-01 — my first fix passed
+      // `o.acknowledgeContacts`, which is always undefined because `o` is a
+      // ledger row and never carried one; it looked like a fix and did nothing).
+      //
+      // A revert can remove several workflows at once with different numbers of
+      // contacts parked in each, so a single acknowledgement number cannot
+      // honestly cover them. Rather than invent one, a workflow with somebody
+      // part-way through is REFUSED and reported, the rest of the revert
+      // continues, and the operator removes that one deliberately with
+      // `delete_workflow_full`, which asks for the count for that workflow alone.
       workflow: async (o) => {
         await builderClient.deleteWorkflow(o.ghlId);
       },
@@ -30608,7 +31188,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@elitedcs/ghl-mcp",
-      version: "3.75.0",
+      version: "3.76.0",
       mcpName: "io.github.drjerryrelth/ghl-command",
       description: "GoHighLevel MCP Server for Claude. 248 tools \u2014 full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
       main: "dist/index.js",
@@ -32504,6 +33084,13 @@ function startRun(locationId2, stage, onDone, meta = {}) {
       run.lines.push(`Could not write this run to the cost record: ${e instanceof Error ? e.message : String(e)}. The step itself is unaffected.`);
     }
     for (const line2 of costLines(outcome)) run.lines.push(line2);
+    if (stage === 3 && !outcome.summary && !outcome.issues?.length) {
+      try {
+        const st = readCockpitState();
+        writeCockpitState({ ...st, outcomes: { ...st.outcomes ?? {}, [`${locationId2}:3`]: { at: (/* @__PURE__ */ new Date()).toISOString() } } });
+      } catch {
+      }
+    }
     if (outcome.summary || outcome.issues?.length) {
       const at = (/* @__PURE__ */ new Date()).toISOString();
       const save = (plain) => {
@@ -32517,6 +33104,17 @@ function startRun(locationId2, stage, onDone, meta = {}) {
         save(plain);
       }
     }
+    if (stage === 4) {
+      try {
+        const st = readCockpitState();
+        const fresh = findingsFor(st.outcomes?.[`${locationId2}:4`] ?? { issues: outcome.issues, plain: outcome.plain });
+        const merged = mergeTasks(st.manualTasks?.[locationId2] ?? [], fresh);
+        writeCockpitState({ ...st, manualTasks: { ...st.manualTasks ?? {}, [locationId2]: merged } });
+        const back = merged.filter((t) => t.reappeared).length;
+        if (back) run.lines.push(`${back} job${back === 1 ? "" : "s"} you had ticked off came back in this check. Worth a second look.`);
+      } catch {
+      }
+    }
     run.ok = outcome.ok;
     const before = readCockpitState().clients[locationId2]?.stages;
     onDone(outcome.ok);
@@ -33270,6 +33868,47 @@ function card(c,state,run){const st=(state.clients[c.locationId]||{stages:STAGES
     if(!r.ok)alert(r.error);load()};
    ab.appendChild(w);ab.appendChild(btn);ab.appendChild(protectBtn(c))}
   div.appendChild(ab)}
+ // A "live" claim is re-derived from the signature, never trusted from the
+ // stage array: the gate runs on the write path, and this file can be restored
+ // or hand-edited (Codex round 2).
+ // The server decides whether a client is live; this only draws the answer.
+ {const _claim=(lastState.liveClaims||{})[c.locationId]||{live:false};
+  const _sig=(lastState.goLive||{})[c.locationId];
+  if(_claim.warning){const wb=document.createElement("div");
+   wb.style.cssText="margin-top:.5rem;padding:.5rem .6rem;border-radius:8px;font-size:.75rem;background:var(--warn-soft);color:var(--warn)";
+   wb.textContent=_claim.warning;div.appendChild(wb)}
+  else if(_claim.live&&_sig){const lb=document.createElement("div");
+   lb.style.cssText="margin-top:.5rem;font-size:.75rem";
+   lb.textContent="Live. Signed off by "+_sig.by+" on "+String(_sig.at).slice(0,10)+(_sig.verifiedAt?", on a check that came back clean "+String(_sig.verifiedAt).slice(0,10):"")+".";
+   div.appendChild(lb);
+   if(_claim.note){const sb=document.createElement("div");sb.style.cssText="margin-top:.3rem;font-size:.74rem;color:var(--warn)";
+    sb.textContent=_claim.note;div.appendChild(sb)}}}
+ // Stage 5: the jobs only a person can do, written by Verify itself. Shown as
+ // soon as Verify has run, because that is the moment the list exists.
+ {const mt=(lastState.manualTasks||{})[c.locationId]||[];
+  const ranVerify=Boolean((lastState.outcomes||{})[c.locationId+":4"]);
+  if(ranVerify){
+   const box=document.createElement("div");box.style.cssText="margin-top:.6rem;padding:.6rem .7rem;border:1px solid var(--line);border-radius:8px;background:var(--card-soft,transparent)";
+   const h=document.createElement("div");h.style.cssText="font-size:.78rem;font-weight:700;margin-bottom:.35rem";
+   h.textContent=mt.length?"Your jobs in the account ("+mt.filter(t=>!t.claimed).length+" to do)":"Your jobs in the account";
+   box.appendChild(h);
+   const note=document.createElement("div");note.className="muted";note.style.cssText="font-size:.74rem;margin-bottom:.45rem";
+   note.textContent=mt.length===0
+    ?"Nothing left to do by hand. The last check came back clean."
+    :(mt.some(t=>t.reappeared)
+      ?"Some of these were ticked off, but the last check still found them in the account. Worth a second look."
+      :"Ticking a box records that you did it. The check is what proves it, so run the check again when you are done.");
+   box.appendChild(note);
+   mt.forEach(t=>{
+    const row=document.createElement("label");
+    row.style.cssText="display:flex;gap:.5rem;align-items:flex-start;font-size:.76rem;padding:.22rem 0;cursor:pointer"+(t.reappeared?";color:var(--warn)":"");
+    const cb=document.createElement("input");cb.type="checkbox";cb.checked=Boolean(t.claimed);cb.style.marginTop=".15rem";
+    cb.onchange=async(ev)=>{ev.stopPropagation();
+     await postJSON("/api/manual-task",{locationId:c.locationId,id:t.id,claimed:cb.checked});load()};
+    const txt=document.createElement("span");
+    txt.textContent=(t.reappeared?"Came back after you ticked it: ":"")+t.text;
+    row.appendChild(cb);row.appendChild(txt);box.appendChild(row)});
+   div.appendChild(box)}}
  const _intakeIn=(iData[c.locationId]&&iData[c.locationId].status==="received");
  const _writing=reviewBusy(c.locationId,run);
  if(_intakeIn||_writing||st[1]==="done"||st[2]==="done"||(rData[c.locationId]&&rData[c.locationId].ok)){
@@ -33304,7 +33943,15 @@ function whereItStands(c,state,run){
  if(c.pending)return {pill:"Needs connecting",cls:"state warn",text:"One 2-minute step left"};
  if(run&&run.running&&run.locationId===c.locationId)return {pill:"Building now",cls:"state live",text:LABELS[run.stage]||""};
  const st=(state.clients[c.locationId]||{stages:[]}).stages||[];
- if(st.length===STAGES.length&&st.every(s=>s==="done"))return {pill:"Live",cls:"state ok",text:"All 7 steps done"};
+ // "Live" comes from the SIGNATURE, never from the stage array \u2014 the same rule
+ // the card uses, through the same server-computed answer. This row used to say
+ // "Live" from the checkboxes alone, so a restored or hand-edited board showed a
+ // client live in the roster while the card said there was no signed record
+ // (Codex, round 5 \u2014 and I had told it this renderer did not exist).
+ if(st.length===STAGES.length&&st.every(s=>s==="done")){
+  const _cl=(state.liveClaims||{})[c.locationId]||{};
+  if(_cl.live)return {pill:"Live",cls:"state ok",text:_cl.note?"Signed off, but the account changed since":"All 7 steps done"};
+  return {pill:"Needs sign-off",cls:"state warn",text:"Ticked live with no signed record"}}
  if(!st.some(s=>s!=="pending"))return {pill:"Not started",cls:"chip",text:""};
  let i=0;while(i<st.length&&st[i]==="done")i++;
  return {pill:"Step "+Math.min(i+1,STAGES.length)+" of "+STAGES.length,cls:"chip space",text:(LABELS[Math.min(i,STAGES.length-1)]||"")+" is next"}}
@@ -33692,7 +34339,14 @@ async function runDashboard(argv) {
     }
     if (req.method === "GET" && url === "/api/state") {
       res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ...readCockpitState(), protectedAccounts: readAccountRulesSafe().protected }));
+      {
+        const st = readCockpitState();
+        const liveClaims = {};
+        for (const [loc, c] of Object.entries(st.clients ?? {})) {
+          liveClaims[loc] = liveClaim(c.stages?.[6] === "done", st.goLive?.[loc], st.outcomes?.[`${loc}:3`]?.at);
+        }
+        res.end(JSON.stringify({ ...st, protectedAccounts: readAccountRulesSafe().protected, liveClaims }));
+      }
       return;
     }
     if (req.method === "GET" && url === "/api/queue") {
@@ -34004,6 +34658,29 @@ async function runDashboard(argv) {
       });
       return;
     }
+    if (req.method === "POST" && url === "/api/manual-task") {
+      let body = "";
+      req.on("data", (c) => {
+        body += c;
+        if (body.length > 5e3) req.destroy();
+      });
+      req.on("end", () => {
+        try {
+          const { locationId: locationId2, id, claimed } = JSON.parse(body);
+          if (!currentRoster().some((r) => r.locationId === locationId2)) throw new Error("unknown client");
+          const st = readCockpitState();
+          const tasks2 = st.manualTasks?.[locationId2] ?? [];
+          if (!tasks2.some((t) => t.id === id)) throw new Error("That job is not on this client's list any more \u2014 run the check again.");
+          writeCockpitState({ ...st, manualTasks: { ...st.manualTasks ?? {}, [locationId2]: setTaskClaimed(tasks2, id, Boolean(claimed)) } });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true }));
+        } catch (e) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : "bad request" }));
+        }
+      });
+      return;
+    }
     if (req.method === "GET" && url === "/api/agency-profile") {
       const prof = readAgencyProfile();
       res.writeHead(200, { "Content-Type": "application/json" });
@@ -34213,8 +34890,27 @@ async function runDashboard(argv) {
           if (!currentRoster().some((r) => r.locationId === locationId2)) throw new Error("unknown client");
           const refusal = handMarkRefusal(stage, status);
           if (refusal) throw new Error(refusal);
+          if (stage === 6 && status === "done") {
+            const st6 = readCockpitState();
+            const refusal6 = goLiveRefusal({
+              verify: st6.outcomes?.[`${locationId2}:4`],
+              build: st6.outcomes?.[`${locationId2}:3`],
+              manualTasks: st6.manualTasks?.[locationId2] ?? [],
+              by
+            });
+            if (refusal6) throw new Error(refusal6);
+          }
+          if (stage === 5 && status === "done") {
+            const st5 = readCockpitState();
+            const gate3 = manualSignOffRefusal(
+              st5.manualTasks?.[locationId2] ?? [],
+              Boolean(st5.outcomes?.[`${locationId2}:4`])
+            );
+            if (gate3) throw new Error(gate3);
+          }
           const marked = recordHandMark(setStage(readCockpitState(), locationId2, stage, status), locationId2, stage, by, status);
-          writeCockpitState(marked);
+          const withSig = stage === 6 && status === "done" ? { ...marked, goLive: { ...marked.goLive ?? {}, [locationId2]: signOff({ verify: marked.outcomes?.[`${locationId2}:4`], manualTasks: marked.manualTasks?.[locationId2] ?? [], by }) } } : stage === 6 ? { ...marked, goLive: Object.fromEntries(Object.entries(marked.goLive ?? {}).filter(([k]) => k !== locationId2)) } : marked;
+          writeCockpitState(withSig);
           pushShared(locationId2);
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ ok: true }));
@@ -34278,6 +34974,8 @@ var init_dashboard = __esm({
     init_stage_runner();
     init_account_rules();
     init_run_cost();
+    init_manual_tasks();
+    init_go_live();
     init_provisioning();
     init_customization();
     init_question_set();
@@ -34824,7 +35522,7 @@ function confirmSaved(registry2) {
   }
   return true;
 }
-function parse3(argv, options, required) {
+function parse4(argv, options, required) {
   let parsed;
   try {
     parsed = (0, import_node_util2.parseArgs)({ args: argv, options, strict: true, allowPositionals: false });
@@ -34840,7 +35538,7 @@ function parse3(argv, options, required) {
   return parsed;
 }
 async function cmdRegisterLocation(argv, registry2) {
-  const p = parse3(
+  const p = parse4(
     argv,
     {
       "location-id": { type: "string" },
@@ -34890,7 +35588,7 @@ async function cmdRegisterLocation(argv, registry2) {
   return EXIT_OK2;
 }
 async function cmdRegisterCompanyFirebase(argv, registry2) {
-  const p = parse3(
+  const p = parse4(
     argv,
     {
       "company-id": { type: "string" },
@@ -34957,7 +35655,7 @@ async function cmdRegisterCompanyFirebase(argv, registry2) {
   return EXIT_OK2;
 }
 async function cmdRegisterAgencyKey(argv, registry2) {
-  const p = parse3(
+  const p = parse4(
     argv,
     { "api-key": { type: "string" }, "no-validate": { type: "boolean" } },
     ["api-key"]