@elitedcs/ghl-mcp 3.97.1 → 3.97.3

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 3.97.3: A sub-account is never created twice at the same moment, and brain setup names the right fix
+
+**Two Creates of one business name at the same moment: the second is refused.** When the same name is being created in the cockpit and in chat, or in two assistant windows on one computer, the second Create now says the sub-account is being created right now and to wait for that to finish. Before, both could go through and make the sub-account twice. This works when every window runs 3.97.3 or later. If GHL Command cannot check this because its shared file is busy, or cannot be read or written, nothing is created and it says to try again in a moment.
+
+**Brain setup now gives the right fix for each Anthropic refusal:** a key it does not accept needs a new key; billing, credit or a usage limit keep the same key and say what to fix; a model your workspace cannot use is named, with how to turn on access.
+
+The brain's send-or-hold check now has up to 15 seconds to answer (was 6), so the first check after a quiet spell is no longer held just for being slow.
+
+## 3.97.2: Two assistant windows share one computer more safely, cockpit runs never wait on a question, and the client brain fails safe
+
+**Two assistant windows on one computer keep each other's unrelated changes.** When GHL Command runs in more than one assistant window at once, each one now saves your registered accounts, connections and cockpit board under a shared lock, and merges its change onto what the other saved. Before, one could save over an account the other had just registered. Editing the same details in both windows at once can still replace the earlier change. If the lock stays busy for 5 seconds, nothing is written, and the tool or the card says what was not saved and what to do next; only a few background notes (such as when the desktop icon was offered) are skipped without a message. Most of a cockpit run's own saves (a step's status and record, its job list and its check record) try three times over about 2 to 3 seconds instead. If the lock is still busy, the run's progress says in plain words which one could not be saved and what to do next, and a step that finished still reads as finished; its card shows what was last saved. A sub-account that was created is always reported as created, in chat and in the cockpit, even when its key or its card could not be saved. If the cockpit could not save it, the New Client page lists it as created until you register it with its key or press "Dismiss: I removed this sub-account", and neither the cockpit nor chat will create that name again until then.
+
+**Capability runs in the cockpit never stop to ask a question nobody can answer.** They run without a person watching. Anything only you can decide now comes back on the capability card as "Needs your answer:", before "Waiting on a person:", including when the run did not finish. If the approved plan names no packages, the payments run creates no products and asks you instead.
+
+**Build and Verify check every approval again right before they start**, on a fresh read, so an approval withdrawn a moment earlier is never acted on.
+
+**health_check now names the assistant it is running in** and the license plan this session runs on.
+
+**The client brain fails safe:**
+- When the judge leans toward sending a reply to a lead but is not sure, it holds the reply for a person and tries to add the judge's reason as a note on the contact. Appointment reminders still send.
+- When Anthropic refuses the brain's key, the brain records it, shows a red line on the brain pages, and counts what went out unchecked. Saving a new key clears it once Anthropic accepts that key.
+- When writing a draft fails, nothing is sent: the brain tries to add one note to the lead's contact saying so, and the drafts page shows a "Draft failed" card in the same words (the newest 20 from the last 48 hours).
+- A suggestion that ran out of time can be dismissed: too late, not wrong. Dismissing teaches the brain nothing, so it may suggest it again. Rejecting still means "never suggest this again".
+
+**Fixes:**
+- A value that still holds a merge placeholder, with either "{{" or "}}", is never counted as filled on the client page or the switched-off list, and never releases a held automation.
+- A value the plan itself carries no longer releases a held automation when the latest check, or the build's own read, read that value blank or as a placeholder.
+
 ## 3.97.1: The cockpit says what is true about your computer, your build and your handoff
 
 **The build steps now open with a "This computer" strip.** Above step 1 it shows, from your last readiness check, whether Claude Code is installed, whether it is signed in, and whether GHL Command is ready in it. The sign-in check costs nothing: it asks Claude Code directly and runs no model. A Claude Code too old to answer says "Not checked", never "Signed in".

package/README.md

@@ -904,7 +904,7 @@ Built by **[Elite DCs, LLC](https://elitedcs.com)** — a digital marketing and
 
 **Tech stack:** TypeScript, Node.js, esbuild, MCP SDK, Zod, GHL API v2, Firebase Auth
 
-**Version:** 3.97.1
+**Version:** 3.97.3
 
 ---
 

package/dist/brain-function.js

@@ -15031,8 +15031,17 @@ var NOTE_HEADINGS = {
   needsHuman: "Needs a human:",
   brainUnreadable: "Could not read the brain; a person should reply.",
   /** Brain v1 step 2: the gate held a draft. Followed by the reasons, then the draft. */
-  held: "HELD, not sent:"
+  held: "HELD, not sent:",
+  /** R5 (2026-11-02): the model call failed, so there is no draft. Followed by the plain reason (draftFailedNote). */
+  draftFailed: "Brain draft failed:"
 };
+var DRAFT_FAILED_CHECK = "draft_failed";
+var REFUSAL_PREFIX = {
+  key: "the brain's Anthropic key stopped working",
+  organization: "Anthropic stopped the organization behind the brain's key (billing, credit or a usage limit; the key itself is fine)",
+  model: "Anthropic will not let the brain's key use a model the brain needs (the key itself is fine)"
+};
+var draftFailedNote = (reason) => `${NOTE_HEADINGS.draftFailed} ${reason}. Nothing was sent.`;
 
 // src/brain/booking.ts
 var ENDED_APPOINTMENT_STATUSES = /* @__PURE__ */ new Set(["cancelled", "canceled", "noshow", "no_show", "no-show", "showed"]);
@@ -15743,6 +15752,72 @@ function createGhlHttp(opts) {
   };
 }
 
+// src/brain/key-health.ts
+var AnthropicRefusedError = class extends Error {
+  constructor(status, refusal) {
+    super(`the model answered ${status}`);
+    this.status = status;
+    this.refusal = refusal;
+    this.name = "AnthropicRefusedError";
+  }
+  status;
+  refusal;
+};
+var NO_CREDIT = /credit balance is too low|insufficient (?:credit|funds)/i;
+var IDENTITY_LINKED = /anthropic-workspace-id/i;
+var USAGE_LIMIT = /usage limit/i;
+var NAMES_THE_MODEL = /\b(?:specified|requested|this) model\b/i;
+var namesTheModel = (message, model) => model.length > 0 && message.includes(model) || NAMES_THE_MODEL.test(message);
+var escaped = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var modelAccessWords = (message, model) => {
+  const id = model ? escaped(model) : "(?!)";
+  return new RegExp(`access to (?:the )?(?:model\\b|${id})|have access to (?:the )?(?:model\\b|${id})|permission to use|not permitted to use|not available to (?:this|your) (?:workspace|organization)`, "i").test(message);
+};
+var aboutTheModel = (type, message, model) => namesTheModel(message, model) && (type === "permission_error" || type === "invalid_request_error" && modelAccessWords(message, model));
+var NOT_RECOGNIZED = "Anthropic does not recognize the key, which may have been deleted, replaced or copied incompletely";
+function anthropicRefusal(status, body, model) {
+  const r = (cause, reason) => ({ cause, reason, model });
+  if (status === 401) return r("key", NOT_RECOGNIZED);
+  let error51 = null;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed && parsed.type === "error" && parsed.error && typeof parsed.error === "object") error51 = parsed.error;
+  } catch {
+    error51 = null;
+  }
+  if (!error51 || status >= 500) return null;
+  const type = typeof error51.type === "string" ? error51.type : "";
+  const message = typeof error51.message === "string" ? error51.message : "";
+  if (USAGE_LIMIT.test(message)) return r("organization", "a usage limit set on the Anthropic organization or its workspace stops it");
+  if (status === 429) return null;
+  if (type === "billing_error") return r("organization", "the Anthropic organization's billing stops it");
+  if (NO_CREDIT.test(message)) return r("organization", "the Anthropic organization's credit balance is empty");
+  if (IDENTITY_LINKED.test(message)) return r("key", "the key is an identity-linked key, which Anthropic refuses for the brain");
+  if (type === "not_found_error" || aboutTheModel(type, message, model)) {
+    return r("model", `the model is ${model}`);
+  }
+  if (type === "authentication_error") return r("key", NOT_RECOGNIZED);
+  if (type === "permission_error") return r("key", "Anthropic says the key may not do what the brain needs");
+  return null;
+}
+async function responseText(res) {
+  try {
+    return typeof res.text === "function" ? (await res.text()).slice(0, 4e3) : "";
+  } catch {
+    return "";
+  }
+}
+async function recordKeyHealth(db2, client, signal, now, judgmentId = null) {
+  if (!signal) return;
+  try {
+    await asRuntime(db2, client, (tx) => tx.query(
+      "select brain.note_anthropic_health($1, $2, $3, $4::timestamptz, $5::bigint)",
+      signal.ok ? [signal.model.slice(0, 100), null, null, now.toISOString(), judgmentId] : [signal.refusal.model.slice(0, 100), signal.refusal.cause, signal.refusal.reason.slice(0, 300), now.toISOString(), judgmentId]
+    ));
+  } catch {
+  }
+}
+
 // src/brain/model.ts
 var MessagesResponse = external_exports.object({
   model: external_exports.string().optional(),
@@ -15774,7 +15849,11 @@ function createAnthropicDraftModel(opts) {
         }),
         signal: AbortSignal.timeout(Math.min(req.timeoutMs, opts.timeoutMs ?? req.timeoutMs))
       });
-      if (!res.ok) throw new Error(`the model answered ${res.status}`);
+      if (!res.ok) {
+        const refused = anthropicRefusal(res.status, await responseText(res), req.model);
+        if (refused) throw new AnthropicRefusedError(res.status, refused);
+        throw new Error(`the model answered ${res.status}`);
+      }
       const body = MessagesResponse.parse(await res.json());
       const text2 = body.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
       return {
@@ -15880,28 +15959,40 @@ function judgedHoldWhy(judgmentId) {
   const ref = judgmentId ? ` (judgment ${judgmentId})` : "";
   return `The brain's judge said not to send this message now. The brain is recording its reason${ref} and will try to add it to the contact as a note.`;
 }
+var LOW_CONFIDENCE_RULE = { holdBelow: "medium", reminder: "send" };
+var CONFIDENCE_RANK = { low: 0, medium: 1, high: 2 };
+function unsureSendHolds(answer, kind, rule = LOW_CONFIDENCE_RULE) {
+  if (answer.decision !== "send" || CONFIDENCE_RANK[answer.confidence] >= CONFIDENCE_RANK[rule.holdBelow]) return false;
+  return kind === "ask" || rule.reminder === "hold";
+}
+var UNSURE_HOLD_WHY = "The brain's judge leaned toward sending this message but was not sure, so it held it for a person to check.";
 function askReply(answer, outcome) {
-  if (!outcome.ok || answer.why === STOPPED_WHY) return answer;
+  if (!outcome.ok || answer.why === STOPPED_WHY || answer.why === UNSURE_HOLD_WHY) return answer;
   return { ...answer, why: answer.send === "yes" ? JUDGED_SEND_WHY : judgedHoldWhy(answer.judgmentId) };
 }
 function judgeNote(judgmentId, message, answer) {
   const esc2 = (v) => v.replace(/</g, "\u2039").replace(/>/g, "\u203A");
   const lines = [
-    `The brain's judge said not to send a message to this lead (judgment ${judgmentId}).`,
+    answer.decision === "send" ? `The brain's judge was not sure about a message to this lead, so the brain held it for a person (judgment ${judgmentId}). The judge leaned toward sending it.` : `The brain's judge said not to send a message to this lead (judgment ${judgmentId}).`,
     `Message: ${esc2(message.slice(0, 600))}`,
     `Why: ${esc2(answer.reason)}`,
+    ...answer.decision === "send" ? [`How sure the judge was: ${answer.confidence}`] : [],
     `Where the lead is: ${esc2(answer.lead_stage)}`
   ];
   if (answer.better_message) lines.push(`What would fit now: ${esc2(answer.better_message)}`);
   return lines.join("\n");
 }
-var JUDGE_ASK_DEADLINE_MS = 6e3;
+var JUDGE_ASK_DEADLINE_MS = 15e3;
 var JUDGE_SETTLE_MS = 700;
 function workflowAnswer(outcome, judgmentId, kind = "ask", facts = null, rule = DEFAULT_FAIL_RULE, known = {}) {
   const hold = (why) => ({ send: "no", why, judgmentId, held: true, task: rule.taskOnHold ? `The brain held a message to this lead. ${why} Check it and send it by hand if it should go.` : null });
   const optedOut = facts?.brainState?.optedOut === true || facts?.lead.doNotDisturb === true || known.optedOut === true;
   if (outcome.ok) {
-    if (outcome.answer.decision === "send") return optedOut ? { send: "no", why: STOPPED_WHY, judgmentId, held: false, task: null } : { send: "yes", why: outcome.answer.reason, judgmentId, held: false, task: null };
+    if (outcome.answer.decision === "send") {
+      if (optedOut) return { send: "no", why: STOPPED_WHY, judgmentId, held: false, task: null };
+      if (unsureSendHolds(outcome.answer, kind)) return hold(UNSURE_HOLD_WHY);
+      return { send: "yes", why: outcome.answer.reason, judgmentId, held: false, task: null };
+    }
     return { send: "no", why: outcome.answer.reason, judgmentId, held: false, task: null };
   }
   const policy = kind === "reminder" ? rule.reminderWhenUnjudged : rule.askWhenUnjudged;
@@ -15929,14 +16020,18 @@ function createAnthropicJudgeModel(opts) {
       } catch (error51) {
         return failed(error51 instanceof Error && (error51.name === "TimeoutError" || error51.name === "AbortError") ? "the model did not answer in time" : "the model could not be reached", true);
       }
-      if (!res.ok) return failed(`the model answered ${res.status}`);
+      if (!res.ok) {
+        const refused = anthropicRefusal(res.status, await responseText(res), JUDGE_MODEL);
+        const out = failed(refused ? `${REFUSAL_PREFIX[refused.cause]}: ${refused.reason}` : `the model answered ${res.status}`);
+        return refused ? { ...out, outcome: { ...out.outcome, refused } } : out;
+      }
       let body;
       try {
         body = await res.json();
       } catch {
         return failed("the model's reply was not JSON", true);
       }
-      return { outcome: readJudgeResponse(body), ms: clock3() - t0 };
+      return { outcome: { ...readJudgeResponse(body), keyWorked: true }, ms: clock3() - t0 };
     }
   };
 }
@@ -17895,6 +17990,15 @@ ${fence(latest)}
 // src/brain/responder.ts
 var mappingWhere = (clientName, ids) => `Open the cockpit, Brain, client ${clientName}, proposal ${ids.map((id) => `#${id}`).join(", ")}, and confirm it with Touch ID.`;
 var Reservation = external_exports.object({ ok: external_exports.boolean(), id: external_exports.number().int().optional(), why: external_exports.string().optional() });
+var DRAFT_UNREADABLE_REASON = "Anthropic's model answered, but not with a reply the brain could use";
+var NOTE_READ_BACK_FAILED = "the note was written, but reading it back from GoHighLevel failed";
+function draftFailureReason(e) {
+  if (e instanceof AnthropicRefusedError) return `${REFUSAL_PREFIX[e.refusal.cause]}: ${e.refusal.reason}`;
+  if (e instanceof Error && (e.name === "TimeoutError" || e.name === "AbortError")) return "Anthropic's model did not answer in time";
+  const status = e instanceof Error ? /^the model answered (\d{3})$/.exec(e.message)?.[1] : void 0;
+  if (status) return `Anthropic's model answered with an error (${status})`;
+  return "Anthropic's model could not be reached, or its reply could not be read";
+}
 var Stop = class extends Error {
   constructor(outcome, why) {
     super(why);
@@ -17935,6 +18039,7 @@ async function runResponder(deps, client, input) {
   let modelCalls = 0;
   const typeFlags = [];
   let reservedId = null;
+  let keySignal = null;
   const maxTokens = deps.env.maxOutputTokens ?? 600;
   const log = {
     brief: { stage: "not built" },
@@ -17974,6 +18079,29 @@ async function runResponder(deps, client, input) {
     log.noteId = (await writeNoteMarked(`${NOTE_HEADINGS.held} ${why}`)).id;
     throw new Stop("held", why);
   };
+  const noteDraftFailed = async (reason) => {
+    typeFlags.push({ check: DRAFT_FAILED_CHECK, pass: false, why: cut(reason, 300) });
+    if (Date.now() > deadline) {
+      typeFlags.push({ check: "note_read_back", pass: false, why: "no time was left in the run to write the note" });
+      return;
+    }
+    const note = draftFailedNote(reason);
+    let written;
+    try {
+      written = await writeNoteMarked(note);
+      log.noteId = written.id;
+    } catch {
+      typeFlags.push({ check: "note_read_back", pass: false, why: "the note saying the draft failed could not be written to GoHighLevel" });
+      return;
+    }
+    try {
+      const notes = await ghl.readNotes(input.contactId);
+      const arrived = notes.some((n) => written.id !== null && n.id === written.id || n.body === note);
+      typeFlags.push(arrived ? { check: "note_read_back", pass: true } : { check: "note_read_back", pass: false, why: "the note was not found in GoHighLevel after writing it" });
+    } catch {
+      typeFlags.push({ check: "note_read_back", pass: false, why: NOTE_READ_BACK_FAILED });
+    }
+  };
   const body = async () => {
     if (!deps.env.responderEnabled) throw new Stop("skipped_off", "BRAIN_RESPONDER_ENABLED is off");
     if (client.responderMode === "off") throw new Stop("skipped_off", "responder is off for this client");
@@ -18094,11 +18222,22 @@ async function runResponder(deps, client, input) {
     log.model = deps.env.modelId;
     const modelBudget = Math.min(RUN_LIMITS.modelTimeoutMs, deadline - Date.now() - 2e3);
     if (modelBudget <= 0) throw new Stop("error", `per-run limit: no time left for the model within ${RUN_LIMITS.timeoutMs} ms`);
-    const result = await deps.model.draft({ model: deps.env.modelId, system: prompt.system, user: prompt.user, maxTokens, timeoutMs: modelBudget, purposes });
+    let result;
+    try {
+      result = await deps.model.draft({ model: deps.env.modelId, system: prompt.system, user: prompt.user, maxTokens, timeoutMs: modelBudget, purposes });
+      keySignal = { ok: true, model: deps.env.modelId };
+    } catch (e) {
+      if (e instanceof AnthropicRefusedError) keySignal = { ok: false, refusal: e.refusal };
+      await noteDraftFailed(draftFailureReason(e));
+      throw new Stop("error", e instanceof Error ? cut(e.message, 200) : "unexpected failure");
+    }
     log.inputTokens = result.inputTokens;
     log.outputTokens = result.outputTokens;
     log.cost = costUsd(deps.env.modelId, result.inputTokens, result.outputTokens) ?? 0;
-    if (!result.answer) throw new Stop("error", "the model's answer was not the expected shape");
+    if (!result.answer) {
+      await noteDraftFailed(DRAFT_UNREADABLE_REASON);
+      throw new Stop("error", "the model's answer was not the expected shape");
+    }
     if (!wellFormed(result.answer)) await refuseBroken("The model's reply");
     log.draft = result.answer.reply;
     log.purpose = result.answer.purpose;
@@ -18293,6 +18432,7 @@ ${stamp}`;
   } finally {
     if (timer) clearTimeout(timer);
   }
+  await recordKeyHealth(deps.db, client, keySignal, now);
   const checks = toWellFormed([...typeFlags, ...log.why ? [...log.checks, { check: "outcome", pass: log.outcome === "drafted", why: log.why }] : log.checks]);
   log.draft = log.draft === null ? null : toWellFormed(log.draft);
   log.brief = toWellFormed(log.brief);
@@ -18739,6 +18879,12 @@ function createBrainHandler(deps) {
 }
 
 // src/brain/judge-runtime.ts
+var keySignalOf = (o) => {
+  if (!o.ok && o.refused) return { ok: false, refusal: o.refused };
+  if (!o.keyWorked) return null;
+  const answered2 = o.model ?? JUDGE_MODEL;
+  return { ok: true, model: answered2.startsWith(JUDGE_MODEL) ? JUDGE_MODEL : answered2 };
+};
 function judgeWorstCost(prompt) {
   return costUsdAtMost(prompt.system.length + prompt.user.length, 4e3);
 }
@@ -18867,7 +19013,7 @@ async function judgeOnce(deps, client, contactId, message, kind, source, facts,
   const timings = { total: ms2(clock2() - timing.startedAt), db: ms2(db2), ghl: ms2(timing.ghl), license: ms2(licence2?.ms), model: ms2(modelMs) };
   const a = outcome.ok ? outcome.answer : null;
   const given = timing.answered?.(outcome) ?? workflowAnswer(outcome, null, kind, facts);
-  const held = !outcome.ok && given.held;
+  const held = given.held;
   const settleOnce = () => asRuntime(deps.db, client, (tx) => tx.query(
     // `::text::jsonb`: the live driver (postgres.js) JSON-encodes a parameter typed jsonb, so a plain `::jsonb` stored these
     // as jsonb STRINGS on brain-demo (judgments 1-18, found 2026-10-29: every timing read 0). See payload-string-2026-09-27.
@@ -18892,8 +19038,12 @@ async function judgeOnce(deps, client, contactId, message, kind, source, facts,
     ]
   ));
   const settled = timing.claim ? retried(settleOnce, SETTLE_RETRY_MS) : settleOnce();
-  if (timing.claim) deps.waitUntil(settled.catch(() => void 0));
-  else await settled;
+  const recordKey = () => recordKeyHealth(deps.db, client, keySignalOf(judged.outcome), now, String(r.id));
+  if (timing.claim) deps.waitUntil(settled.catch(() => void 0).then(recordKey));
+  else {
+    await settled;
+    await recordKey();
+  }
   return { outcome, id: String(r.id), settled };
 }
 var SETTLE_RETRY_MS = [1e3, 3e3];
@@ -19010,7 +19160,7 @@ async function askOnce(deps, askKeyHash, raw, arrivedAt, seen, finish) {
       { startedAt, db: dbMs, ghl: ghlMs, licence: licenceCheck, deadlineAt, claim: (o, judgmentId) => finish(reply2(o, judgmentId)), answered: (o) => reply2(o, null) }
     );
     const answer = reply2(outcome, id);
-    if (outcome.ok && outcome.answer.decision === "dont_send" && id !== null && answer.send === "no") {
+    if (outcome.ok && (outcome.answer.decision === "dont_send" || answer.why === UNSURE_HOLD_WHY) && id !== null && answer.send === "no") {
       const port = value.ghl;
       const verdict = outcome.answer;
       const write = (p) => p.writeNote(contactId, judgeNote(id, message, verdict));
@@ -19067,7 +19217,8 @@ async function judgeReplay(deps, client, raw = null) {
   for (const c of cases) {
     const { outcome } = await judgeOnce(deps, client, c.ghl_contact_id, c.message, c.kind, "replay", c.facts, ctx, now);
     const decision = outcome.ok ? outcome.answer.decision : null;
-    results.push({ judgmentId: String(c.id), owner: c.owner, before: c.decision, now: decision, agrees: decision === c.owner, why: outcome.ok ? outcome.answer.reason : outcome.why });
+    const did = outcome.ok && unsureSendHolds(outcome.answer, c.kind) ? "dont_send" : decision;
+    results.push({ judgmentId: String(c.id), owner: c.owner, before: c.decision, now: decision, wouldDo: did, agrees: did === c.owner, why: outcome.ok ? outcome.answer.reason : outcome.why });
   }
   const left = Math.max(0, page.total - cases.length);
   return { status: 200, body: { cases: results.length, agree: results.filter((r) => r.agrees).length, results, left, nextAfterId: left && cases.length ? String(cases[cases.length - 1].id) : null } };