gogcli-mcp-gmail 2.22.0 → 2.23.0

package/dist/index.js

@@ -452,9 +452,9 @@ var require_codegen = __commonJS({
       }
     };
     var Label = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
@@ -462,14 +462,14 @@ var require_codegen = __commonJS({
       }
     };
     var Break = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
-        const label = this.label ? ` ${this.label}` : "";
-        return `break${label};` + _n;
+        const label2 = this.label ? ` ${this.label}` : "";
+        return `break${label2};` + _n;
       }
     };
     var Throw = class extends Node {
@@ -881,12 +881,12 @@ var require_codegen = __commonJS({
         return this._endBlockNode(For);
       }
       // `label` statement
-      label(label) {
-        return this._leafNode(new Label(label));
+      label(label2) {
+        return this._leafNode(new Label(label2));
       }
       // `break` statement
-      break(label) {
-        return this._leafNode(new Break(label));
+      break(label2) {
+        return this._leafNode(new Break(label2));
       }
       // `return` statement
       return(value) {
@@ -31896,7 +31896,7 @@ var failIfNotEmptyParam = external_exports.boolean().optional().describe(
 );
 
 // ../gogcli-mcp/src/server.ts
-var VERSION = true ? "2.22.0" : "0.0.0";
+var VERSION = true ? "2.23.0" : "0.0.0";
 
 // ../gogcli-mcp/src/auth-log.ts
 var FAILURES = /* @__PURE__ */ new Set([
@@ -32556,6 +32556,791 @@ async function deliverViaDrive(path, name, driveFolder, account) {
     webViewLink: file2.webViewLink
   });
 }
+function originFromDraftId(id) {
+  return id.startsWith("s:") ? "non-api" : "api";
+}
+function rootsOwnThread(d) {
+  if (!d.messageId || !d.threadId) return false;
+  return d.messageId === d.threadId;
+}
+function parseHeaders(payload) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const h of payload?.headers ?? []) {
+    if (!h.name) continue;
+    const key = h.name.toLowerCase();
+    const existing = map2.get(key);
+    if (existing) existing.push(h.value ?? "");
+    else map2.set(key, [h.value ?? ""]);
+  }
+  return map2;
+}
+function headerValue(headers, name) {
+  return headers.get(name.toLowerCase())?.[0];
+}
+function appleIdentitySignals(headers) {
+  const out = [];
+  for (const h of headers ?? []) {
+    const name = h.name ?? "";
+    const lower = name.toLowerCase();
+    const value = h.value ?? "";
+    if (lower === "x-uniform-type-identifier") {
+      if (value.toLowerCase().startsWith("com.apple.")) out.push(`${name}: ${value}`);
+      continue;
+    }
+    if (lower === "x-universally-unique-identifier" || lower.startsWith("x-apple-")) {
+      out.push(`${name}: ${value}`);
+    }
+  }
+  return out;
+}
+function normalizeMessageId(v) {
+  const trimmed = v?.trim();
+  if (!trimmed) return void 0;
+  const stripped = trimmed.replace(/^</, "").replace(/>$/, "").trim();
+  return stripped.length > 0 ? stripped : void 0;
+}
+function messageIdsIn(references) {
+  const matches = references?.match(/<[^<>\s]+>/g) ?? [];
+  return matches.map((m) => m.slice(1, -1));
+}
+function normalizeBodyLines(text) {
+  return (text ?? "").replace(/\r\n?/g, "\n").split("\n").map((l) => l.replace(/\s+/g, " ").trim()).filter((l) => l.length > 0);
+}
+function bodySimilarity(a, b) {
+  const left = new Set(normalizeBodyLines(a));
+  const right = new Set(normalizeBodyLines(b));
+  if (left.size === 0 || right.size === 0) return 0;
+  let shared = 0;
+  for (const line of left) if (right.has(line)) shared += 1;
+  return shared / (left.size + right.size - shared);
+}
+var QUOTE_ATTRIBUTION_LINE = /^On\b.*\bwrote:$/i;
+var QUOTE_SEPARATOR_LINE = /^-{2,}\s*(original message|forwarded message)/i;
+function isQuotedBodyLine(line) {
+  return line.startsWith(">") || QUOTE_ATTRIBUTION_LINE.test(line) || QUOTE_SEPARATOR_LINE.test(line);
+}
+var SIGNATURE_DELIMITER_LINE = /^--$/;
+var CLIENT_SIGNATURE_LINE = /^(sent from my\b|sent from (mail|outlook|yahoo|windows)\b|sent via\b|get outlook for\b)/i;
+var GREETING_LINE = /^(hi|hello|hey|dear|good (morning|afternoon|evening)|greetings)\b[^.!?]{0,48}$/i;
+var SIGN_OFF_ALONE = /^(thanks|thanks again|thanks so much|thank you|thank you so much|many thanks|best|best regards|all the best|regards|kind regards|warmly|warm regards|sincerely|cheers|talk soon|speak soon|love|take care|appreciate it|respectfully|yours|yours truly|yours sincerely)[,.!]*$/i;
+var SIGN_OFF_WITH_NAME = /^(thanks|thank you|many thanks|best|best regards|all the best|regards|kind regards|warmly|warm regards|sincerely|cheers|love|take care|respectfully|yours)\s*[,\u2014\u2013-]\s*(.+)$/i;
+var NAME_LINE = /^-{0,2}\s*\p{L}[\p{L}'\u2019.-]*(?:\s+\p{L}[\p{L}'\u2019.-]*){0,2}$/u;
+var CONTACT_LINE = /^(?:[+(]?\d[\d\s().-]{6,}|[^\s@]+@[^\s@]+\.[^\s@]+|(?:https?:\/\/|www\.)\S+|@[\w.]+)$/i;
+function isNameLine(line) {
+  return !/[.!?:;]$/.test(line) && NAME_LINE.test(line);
+}
+function isSignOffLine(line) {
+  if (SIGN_OFF_ALONE.test(line)) return true;
+  const withName = line.match(SIGN_OFF_WITH_NAME);
+  return withName !== null && isNameLine(withName[2]);
+}
+function boilerplateLineFlags(lines) {
+  const flags = lines.map(() => false);
+  const delimiter2 = lines.findIndex((l) => SIGNATURE_DELIMITER_LINE.test(l));
+  if (delimiter2 !== -1) for (let i = delimiter2; i < lines.length; i += 1) flags[i] = true;
+  lines.forEach((line, i) => {
+    if (isSignOffLine(line) || CLIENT_SIGNATURE_LINE.test(line)) flags[i] = true;
+  });
+  if (lines.length > 0 && GREETING_LINE.test(lines[0])) flags[0] = true;
+  lines.forEach((line, i) => {
+    if (!isSignOffLine(line)) return;
+    for (let j = i + 1; j < lines.length; j += 1) {
+      const next = lines[j];
+      if (!isNameLine(next) && !CONTACT_LINE.test(next)) break;
+      flags[j] = true;
+    }
+  });
+  return flags;
+}
+function authoredBodyLines(text) {
+  const unquoted = normalizeBodyLines(text).filter((l) => !isQuotedBodyLine(l));
+  const flags = boilerplateLineFlags(unquoted);
+  return unquoted.filter((_, i) => !flags[i]);
+}
+function apparatusCounts(text) {
+  const all = normalizeBodyLines(text);
+  const unquoted = all.filter((l) => !isQuotedBodyLine(l));
+  return {
+    quoted: all.length - unquoted.length,
+    boilerplate: unquoted.length - authoredBodyLines(text).length
+  };
+}
+var FORK_BODY_SIMILARITY_THRESHOLD = 0.6;
+var FORK_MIN_SHARED_AUTHORED_LINES = 2;
+var FORK_MIN_SHARED_AUTHORED_CHARS = 40;
+var BODY_AGREEMENT_BASIS_NOTE = "Measured over lines NEITHER draft quotes AND that neither draft's mail client generated. Excluded as apparatus: quoted (`>`) lines, the `On ... wrote:` attribution, forward separators, the opening salutation, the closing formula, the name under it, and the signature block (an RFC 3676 `-- ` block, or a line like `Sent from my iPhone` \u2014 Apple Mail's own default). All of those are reproduced IDENTICALLY on every message a client composes, whatever the message says, so counting them pairs two unrelated short notes from one account: `Hi Jennifer,` + `Thanks,` + `Chris` + `Sent from my iPhone` alone is 4 lines and 43 characters. Lines are compared after collapsing runs of whitespace and dropping blanks, so a client that RE-WRAPPED a paragraph at a different width, or swapped straight quotes for curly ones, produces lines that no longer match and drives this number DOWN \u2014 a low score is weak evidence of absence.";
+function measureBodyAgreement(originalBody, candidateBody) {
+  const left = new Set(authoredBodyLines(originalBody));
+  const right = new Set(authoredBodyLines(candidateBody));
+  const shared = [...left].filter((line) => right.has(line));
+  const similarity = left.size === 0 || right.size === 0 ? 0 : shared.length / (left.size + right.size - shared.length);
+  const sharedAuthoredChars = shared.reduce((n, line) => n + line.length, 0);
+  const originalApparatus = apparatusCounts(originalBody);
+  const candidateApparatus = apparatusCounts(candidateBody);
+  return {
+    similarity,
+    similarityThreshold: FORK_BODY_SIMILARITY_THRESHOLD,
+    sharedAuthoredLines: shared.length,
+    minSharedAuthoredLines: FORK_MIN_SHARED_AUTHORED_LINES,
+    sharedAuthoredChars,
+    minSharedAuthoredChars: FORK_MIN_SHARED_AUTHORED_CHARS,
+    quotedLinesIgnored: { original: originalApparatus.quoted, candidate: candidateApparatus.quoted },
+    boilerplateLinesIgnored: { original: originalApparatus.boilerplate, candidate: candidateApparatus.boilerplate },
+    meetsThreshold: similarity >= FORK_BODY_SIMILARITY_THRESHOLD && shared.length >= FORK_MIN_SHARED_AUTHORED_LINES && sharedAuthoredChars >= FORK_MIN_SHARED_AUTHORED_CHARS,
+    basisNote: BODY_AGREEMENT_BASIS_NOTE
+  };
+}
+function normalizeFrom(v) {
+  const angled = v?.match(/<([^<>\s]+)>/);
+  const addr = angled ? angled[1] : v?.trim();
+  return addr ? addr.toLowerCase() : void 0;
+}
+async function runNormalized(args, opts) {
+  return normalizeTimestamps(await run(args, opts));
+}
+function parseInternalDateMs(v) {
+  if (v === void 0 || v.trim() === "") return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+var FORK_SIGNALS_THAT_NEVER_SUFFICE = [
+  'A draft id beginning `s:` means non-API (IMAP/sync) origin \u2014 Thunderbird, Outlook-over-IMAP and Gmail offline produce it too. It is not "Apple", and it is not "a fork".',
+  "threadId === messageId means the draft roots its own thread. Measured on a live mailbox, P(Apple | roots-own-thread) was 4/8 = 0.50 \u2014 a coin flip. Report it as a consequence, never use it as a discriminator.",
+  "An identical subject, even minutes apart. Same-subject same-sender drafts are routinely created deliberately; a subject+recency rule fires on all of them and is wrong every time. Subject can also be absent entirely.",
+  "Any single X-Apple-* header. It proves Apple wrote THIS draft; it says nothing about WHICH draft it replaced.",
+  "A UUID-shaped Message-Id, or `Mime-Version: 1.0 (1.0)`. The doubled form is iOS-only \u2014 macOS Mail writes `Mime-Version: 1.0 (Mac OS X Mail 16.0 ...)`, so its absence is not counter-evidence.",
+  "Recency alone.",
+  "A SHARED REPLY ROOT. Two drafts replying into the same conversation share one by construction, and in a mailbox whose threads are all with the same person that is nearly every pair of drafts. It links each draft to a common ANCESTOR \u2014 never the candidate to the original \u2014 so it is reported as corroboration and can never establish a pairing on its own.",
+  "QUOTED TEXT. Body agreement is measured only over lines NEITHER draft quotes, because Apple Mail quotes the original on every reply: two unrelated replies into one thread carry the same 30-line block, which scores 0.79 on a whole-body line metric while proving nothing.",
+  "GREETINGS, SIGN-OFFS AND SIGNATURE BLOCKS, for exactly the same reason as quoted text: a mail client reproduces them identically on every message whatever the message says. `Hi Jennifer,` + `Thanks,` + `Chris` + `Sent from my iPhone` is 4 lines and 43 characters of pure apparatus \u2014 enough, on its own, to clear a naive line-and-character threshold \u2014 and `Sent from my iPhone` is Apple Mail's own default signature. They are excluded from the lineage metric alongside quoting; the divergence report still counts them, because a merge that drops the signature really did drop it.",
+  "THE COMPOSITE TRAP: `s:` prefix AND threadId === messageId together are still insufficient. Both are consequences of the same single fact (non-API origin) and neither references the supposed original. No pairing verdict without a lineage signal.",
+  'Note the converse error too: a fork does NOT always lose its reply headers. A live Apple-authored draft was found carrying a full 5-deep References chain, so "Apple fork means threading is gone" must not be asserted anywhere.'
+];
+function replyRoots(d) {
+  const roots = messageIdsIn(d.references);
+  const inReplyTo = normalizeMessageId(d.inReplyTo);
+  if (inReplyTo) roots.push(inReplyTo);
+  return roots;
+}
+function firstSharedRoot(a, b) {
+  const bRoots = new Set(replyRoots(b));
+  for (const root of replyRoots(a)) if (bRoots.has(root)) return root;
+  return void 0;
+}
+function label(d) {
+  return d.draftId ?? "(unknown id)";
+}
+function evaluateForkPairing(original, candidate, tier) {
+  const signals = candidate.appleSignals ?? [];
+  if (tier < 2 && signals.length > 0) {
+    throw new Error(
+      `evaluateForkPairing was given Apple identity signals at tier ${tier}, but identity headers can only come from a tier 2 per-draft header fetch. This is a wiring bug: a cheap listing path must never be able to produce a "confirmed" fork pairing.`
+    );
+  }
+  const evidence = [];
+  const missing = [];
+  const agreement = measureBodyAgreement(original.bodyText, candidate.bodyText);
+  const originalMessageId = normalizeMessageId(original.messageIdHeader);
+  let lineage = false;
+  if (originalMessageId !== void 0 && replyRoots(candidate).includes(originalMessageId)) {
+    evidence.push(
+      `LINEAGE: the candidate's In-Reply-To/References cites the ORIGINAL DRAFT's own Message-Id <${originalMessageId}> \u2014 a link to the original itself, not to a shared ancestor`
+    );
+    lineage = true;
+  }
+  if (agreement.meetsThreshold) {
+    evidence.push(
+      `LINEAGE: the two drafts agree on text NEITHER of them quotes \u2014 authored body line similarity ${agreement.similarity.toFixed(2)} meets the ${FORK_BODY_SIMILARITY_THRESHOLD.toFixed(2)} threshold over ${agreement.sharedAuthoredLines} shared line(s) / ${agreement.sharedAuthoredChars} characters`
+    );
+    lineage = true;
+  }
+  const sharedRoot = firstSharedRoot(original, candidate);
+  if (sharedRoot) {
+    evidence.push(
+      `CORROBORATING ONLY (never a pairing on its own): both drafts reply into the same conversation \u2014 shared reply root <${sharedRoot}>. That links each draft to a common ANCESTOR, not the candidate to the original, and EVERY reply in that thread has it.`
+    );
+  }
+  if (!lineage) {
+    missing.push(
+      `no lineage signal: the candidate's In-Reply-To/References does not cite the original draft's Message-Id, and the text the two drafts wrote rather than quoted does not agree (similarity ${agreement.similarity.toFixed(2)} vs the ${FORK_BODY_SIMILARITY_THRESHOLD.toFixed(2)} threshold, ${agreement.sharedAuthoredLines} shared line(s) of ${agreement.sharedAuthoredChars} characters vs the ${FORK_MIN_SHARED_AUTHORED_LINES}/${FORK_MIN_SHARED_AUTHORED_CHARS} minimums)${sharedRoot ? ". A shared reply root is corroboration, not lineage" : ""}`
+    );
+  }
+  const identity = signals.length > 0;
+  if (identity) evidence.push(`the candidate carries Apple identity header(s): ${signals.join("; ")}`);
+  else missing.push("no Apple identity header on the candidate (X-Apple-*, X-Universally-Unique-Identifier, X-Uniform-Type-Identifier)");
+  const originalMs = parseInternalDateMs(original.internalDate);
+  const candidateMs = parseInternalDateMs(candidate.internalDate);
+  let ordering = false;
+  if (originalMs === void 0 || candidateMs === void 0) {
+    missing.push("internalDate is missing on one or both drafts, so it cannot be shown that the candidate is newer");
+  } else if (candidateMs > originalMs) {
+    ordering = true;
+    evidence.push(`the candidate is newer (internalDate ${candidateMs} > ${originalMs})`);
+  } else {
+    missing.push(`the candidate is not newer than the original (internalDate ${candidateMs} <= ${originalMs})`);
+  }
+  const originalFrom = normalizeFrom(original.from);
+  const candidateFrom = normalizeFrom(candidate.from);
+  let sameFrom = false;
+  if (originalFrom === void 0 || candidateFrom === void 0) {
+    missing.push("From missing on one or both drafts");
+  } else if (originalFrom === candidateFrom) {
+    sameFrom = true;
+    evidence.push(`same From (${originalFrom})`);
+  } else {
+    missing.push(`different From (${originalFrom} vs ${candidateFrom})`);
+  }
+  let verdict;
+  if (lineage) verdict = identity && ordering && sameFrom ? "confirmed" : "candidate";
+  else if (sharedRoot !== void 0) verdict = "candidate";
+  else verdict = "none";
+  let note;
+  if (verdict === "confirmed") {
+    note = `Draft ${label(candidate)} replaced draft ${label(original)}. All four signals are present \u2014 see evidence. Reconcile the bodies before sending: neither copy is guaranteed to be a superset of the other.`;
+  } else if (verdict === "candidate" && !lineage) {
+    note = `Unconfirmed and WEAK: could draft ${label(candidate)} be a rewrite of draft ${label(original)}? The ONLY thing connecting them is that both reply into the same conversation, which every reply in that thread does \u2014 it places them under a common ancestor and says nothing about one coming from the other. Nothing here is a link back to draft ${label(original)}, and the text they did not quote does not agree. Read both bodies yourself; do not merge or send on the strength of this.`;
+  } else if (verdict === "candidate") {
+    note = `Unconfirmed: could draft ${label(candidate)} be a rewrite of draft ${label(original)}? Something links them, but not everything a pairing needs \u2014 read "missing" and decide yourself. Do not merge or send on the strength of this alone.`;
+  } else {
+    note = `No lineage signal was found between draft ${label(candidate)} and draft ${label(original)}: neither cites the other and the text they did not quote does not agree. That is a failure to FIND evidence, not proof that they are unrelated \u2014 the comparison is line-based, so a client that re-wrapped the paragraphs or swapped in smart quotes can hide a real link. Read both bodies before concluding either way.`;
+  }
+  return {
+    verdict,
+    tier,
+    evidence,
+    missing,
+    bodyAgreement: agreement,
+    note
+  };
+}
+function decodeBase64UrlBytes(data) {
+  if (!data) return void 0;
+  try {
+    const binary = atob(data.replace(/-/g, "+").replace(/_/g, "/"));
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+    return bytes;
+  } catch {
+    return void 0;
+  }
+}
+var CP1252_HIGH = [
+  8364,
+  129,
+  8218,
+  402,
+  8222,
+  8230,
+  8224,
+  8225,
+  710,
+  8240,
+  352,
+  8249,
+  338,
+  141,
+  381,
+  143,
+  144,
+  8216,
+  8217,
+  8220,
+  8221,
+  8226,
+  8211,
+  8212,
+  732,
+  8482,
+  353,
+  8250,
+  339,
+  157,
+  382,
+  376
+];
+function decodeCp1252(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b >= 128 && b <= 159 ? CP1252_HIGH[b - 128] : b);
+  return out;
+}
+function decodeTextBytes(bytes, declaredCharset) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+  }
+  const charset = (declaredCharset ?? "").trim().toLowerCase().replace(/^["']|["']$/g, "");
+  if (charset !== "" && !/^(utf-?8|us-ascii|ascii)$/.test(charset)) {
+    try {
+      return new TextDecoder(charset, { fatal: true }).decode(bytes);
+    } catch {
+    }
+  }
+  return decodeCp1252(bytes);
+}
+var QUOTED_PRINTABLE_MARKER = /=(?:\r?\n|[89a-f][0-9a-f]|3d)/i;
+function decodeQuotedPrintableBytes(bytes) {
+  const src = decodeCp1252(bytes);
+  const out = [];
+  for (let i = 0; i < src.length; i += 1) {
+    if (src[i] !== "=") {
+      out.push(src.charCodeAt(i));
+      continue;
+    }
+    const rest = src.slice(i, i + 3);
+    const soft = /^=\r?\n/.exec(rest);
+    if (soft) {
+      i += soft[0].length - 1;
+      continue;
+    }
+    const hex3 = /^=([0-9A-Fa-f]{2})/.exec(rest);
+    if (hex3) {
+      out.push(parseInt(hex3[1], 16));
+      i += 2;
+      continue;
+    }
+    out.push(61);
+  }
+  return Uint8Array.from(out);
+}
+function partMimeType(part) {
+  return (part.mimeType ?? "").split(";")[0].trim().toLowerCase();
+}
+function decodePartText(part) {
+  let bytes = decodeBase64UrlBytes(part.body?.data);
+  if (bytes === void 0) return "";
+  const headers = parseHeaders(part);
+  const encoding = headerValue(headers, "Content-Transfer-Encoding")?.trim().toLowerCase();
+  if (encoding === "quoted-printable" && bytes.every((b) => b < 128) && QUOTED_PRINTABLE_MARKER.test(decodeCp1252(bytes))) {
+    bytes = decodeQuotedPrintableBytes(bytes);
+  }
+  const charset = /charset\s*=\s*([^;]+)/i.exec(headerValue(headers, "Content-Type") ?? "")?.[1];
+  return decodeTextBytes(bytes, charset);
+}
+function bestBodyText(payload) {
+  const firstOfType = /* @__PURE__ */ new Map();
+  const walk2 = (part) => {
+    if (!part) return;
+    const mime = partMimeType(part);
+    if (part.body?.data && !part.filename && !firstOfType.has(mime)) {
+      firstOfType.set(mime, decodePartText(part));
+    }
+    for (const child of part.parts ?? []) walk2(child);
+  };
+  walk2(payload);
+  return firstOfType.get("text/plain") ?? firstOfType.get("text/html") ?? "";
+}
+var DRAFT_DIFF_MAX_LINES = 200;
+function diffBodyLines(a, b, maxLines) {
+  const left = new Set(normalizeBodyLines(a));
+  const right = new Set(normalizeBodyLines(b));
+  const onlyInA = [...left].filter((line) => !right.has(line));
+  const onlyInB = [...right].filter((line) => !left.has(line));
+  const sharedLineCount = left.size - onlyInA.length;
+  const truncated = onlyInA.length > maxLines || onlyInB.length > maxLines;
+  let comparability = "compared";
+  if (left.size === 0) comparability = right.size === 0 ? "both-unreadable" : "a-unreadable";
+  else if (right.size === 0) comparability = "b-unreadable";
+  let supersetClaim;
+  let base;
+  if (comparability !== "compared") {
+    supersetClaim = "not-assessed";
+    const which = comparability === "both-unreadable" ? "NEITHER draft yielded any body text" : comparability === "a-unreadable" ? "Draft A yielded no body text" : "Draft B yielded no body text";
+    base = `${which} (it normalized to zero lines), so NOTHING WAS COMPARED and no containment claim is made in either direction \u2014 in particular this does NOT say one draft's text is safely present in the other. The draft may genuinely be empty, or its text may sit in a MIME part this server could not decode; read it with gog_gmail_drafts_get before overwriting or deleting either copy.`;
+  } else if (onlyInA.length > 0 && onlyInB.length > 0) {
+    supersetClaim = "neither";
+    base = "NEITHER copy is a superset: each draft holds lines the other does not. Recreating from either one alone LOSES WORK \u2014 merge the two bodies by hand, then write the merged text back with gog_gmail_drafts_update.";
+  } else if (onlyInA.length > 0) {
+    supersetClaim = "a-superset-of-b";
+    base = "Draft A is a superset of draft B: every line of B is present in A, and A has more.";
+  } else if (onlyInB.length > 0) {
+    supersetClaim = "b-superset-of-a";
+    base = "Draft B is a superset of draft A: every line of A is present in B, and B has more.";
+  } else {
+    supersetClaim = "identical";
+    base = "The two bodies are identical once whitespace and blank lines are normalized.";
+  }
+  return {
+    onlyInA: onlyInA.slice(0, maxLines),
+    onlyInB: onlyInB.slice(0, maxLines),
+    onlyInACount: onlyInA.length,
+    onlyInBCount: onlyInB.length,
+    sharedLineCount,
+    similarity: bodySimilarity(a, b),
+    comparability,
+    supersetClaim,
+    neitherIsSuperset: comparability === "compared" ? supersetClaim === "neither" : null,
+    truncated,
+    note: truncated ? `${base} (Line lists truncated to ${maxLines} per side; ${onlyInA.length} line(s) diverged only in A and ${onlyInB.length} only in B \u2014 onlyInACount/onlyInBCount are the true totals.)` : base
+  };
+}
+var GOG_DRAFTS_LIST_DEFAULT_MAX = 20;
+var DRAFT_LIST_ORIGIN_NOTE = '`origin` is derived from the draft id alone and costs nothing: `api` = created through the Gmail API (what this server does); `non-api` = the id begins `s:`, meaning the draft arrived over IMAP/sync. `non-api` is NOT a claim of "Apple Mail" \u2014 Thunderbird, Outlook-over-IMAP and Gmail offline produce `s:` ids too, and confirming Apple authorship needs an actual identity header, which only a per-draft fetch can see (gog_gmail_drafts_diff). `rootsOwnThread` is likewise a CONSEQUENCE, not a fork test: on a live mailbox P(Apple | rootsOwnThread) measured 4/8 = 0.50, a coin flip. Neither field, alone or together, establishes that one draft replaced another.';
+var DRAFT_ROOTS_OWN_THREAD_NOTE = "threadId equals this draft's own messageId, so the draft is the ROOT of a new thread: sending it starts a NEW conversation rather than replying, in front of every recipient including anyone on Cc. Normal for a draft composed from scratch \u2014 and also what a mail client's replacement of a previously threaded draft looks like.";
+var DRAFT_IN_THREAD_NOTE = "threadId differs from this draft's messageId, so the draft sits inside an existing thread and sending it continues that conversation. (Whether it also carries In-Reply-To/References is not visible from a listing \u2014 that needs a per-draft fetch.)";
+var DRAFT_ENRICH_COST_NOTE = "enrich spent ONE extra gog invocation (`gmail messages search in:drafts`), so the spawn cost is flat in the number of drafts. It is not free on the other axis: gog fans that one command out to one Gmail messages.get per matching draft at concurrency 10, so Google reads and wall-clock are linear in the result count. Narrow `max` before turning it on.";
+function describeDraftSide(draftId, msg) {
+  const headers = parseHeaders(msg.payload);
+  const bodyText = bestBodyText(msg.payload);
+  const side = {
+    draftId,
+    messageId: msg.id,
+    threadId: msg.threadId,
+    origin: originFromDraftId(draftId),
+    rootsOwnThread: rootsOwnThread({ id: draftId, messageId: msg.id, threadId: msg.threadId }),
+    subject: headerValue(headers, "Subject"),
+    from: headerValue(headers, "From"),
+    to: headerValue(headers, "To"),
+    cc: headerValue(headers, "Cc"),
+    internalDate: msg.internalDate,
+    messageIdHeader: headerValue(headers, "Message-Id"),
+    inReplyTo: headerValue(headers, "In-Reply-To"),
+    references: headerValue(headers, "References"),
+    appleIdentitySignals: appleIdentitySignals(msg.payload?.headers),
+    // The DE-DUPLICATED count, matching diffBodyLines/evaluateContentLoss, which
+    // compare Set members. Counting raw lines here broke the arithmetic a reader
+    // naturally checks: onlyInACount + sharedLineCount === bodyLineCount only
+    // holds when both sides count the same unit, and a body that repeats a line
+    // (a divider, a blank-ish separator) made it not hold.
+    bodyLineCount: new Set(normalizeBodyLines(bodyText)).size
+  };
+  return {
+    side,
+    facts: {
+      draftId,
+      messageIdHeader: side.messageIdHeader,
+      inReplyTo: side.inReplyTo,
+      references: side.references,
+      from: side.from,
+      subject: side.subject,
+      internalDate: side.internalDate,
+      bodyText,
+      appleSignals: side.appleIdentitySignals
+    }
+  };
+}
+function threadingDifferences(a, b) {
+  const out = [];
+  if (a.threadId !== b.threadId) {
+    out.push(
+      `The two drafts sit on different threadIds (${a.threadId ?? "(none)"} vs ${b.threadId ?? "(none)"}), so they are not the same conversation. Sending the one that roots its own thread starts a NEW conversation in front of every recipient, including anyone on Cc.`
+    );
+  }
+  const aReplies = Boolean(a.inReplyTo ?? a.references);
+  const bReplies = Boolean(b.inReplyTo ?? b.references);
+  if (aReplies !== bReplies) {
+    const withHeaders = aReplies ? a.draftId : b.draftId;
+    const without = aReplies ? b.draftId : a.draftId;
+    out.push(
+      `Draft ${withHeaders} carries reply headers (In-Reply-To/References) and draft ${without} does not: only the first will arrive as a reply. gog_gmail_drafts_update with replyToThreadId re-threads a draft in place, keeping its id \u2014 but it also requires a full body, so reconcile the bodies below first.`
+    );
+  }
+  if (out.length === 0) {
+    out.push("No threading difference: the two drafts share a threadId and agree on whether they carry reply headers.");
+  }
+  return out;
+}
+function threadingIntentOf(f) {
+  if (f.replyToMessageId) return { requested: "set", via: "replyToMessageId", target: f.replyToMessageId };
+  if (f.replyToThreadId) return { requested: "set", via: "replyToThreadId", target: f.replyToThreadId };
+  if (f.clearReplyContext) return { requested: "clear" };
+  return void 0;
+}
+var BODY_OVERWRITE_CAVEAT = "gog requires a body on every update, so there is no header-only edit: this call REWROTE the whole body. If a sibling draft holds text this body does not, that text now exists only there \u2014 compare them with gog_gmail_drafts_diff before the next write.";
+var VERIFICATION_PROVENANCE = "These are gog's own report of what it wrote, not an independent re-fetch, and they cost no extra gog invocation. To read the stored headers back from Gmail, use gog_gmail_raw with format=metadata on the draft's messageId.";
+function verifyThreading(intent, ack) {
+  const str = (name) => {
+    const v = ack[name];
+    return typeof v === "string" && v.trim() !== "" ? v : void 0;
+  };
+  const effective = {
+    threadId: str("threadId"),
+    inReplyTo: str("inReplyTo"),
+    references: str("references"),
+    replyContextSource: str("replyContextSource")
+  };
+  const hasLineage = effective.inReplyTo !== void 0;
+  const threadLabel = effective.threadId ?? "(none reported)";
+  if (intent.requested === "clear") {
+    return {
+      requested: "clear",
+      ok: !hasLineage,
+      effective,
+      note: hasLineage ? `WARNING: clearReplyContext was requested, but gog reports the draft STILL carries In-Reply-To ${effective.inReplyTo}. It has NOT been turned back into a standalone message. Re-read it before sending. ${VERIFICATION_PROVENANCE}` : `Reply context cleared: gog reports no In-Reply-To/References, so this draft will arrive as a standalone message. Its draft id and its threadId (${threadLabel}) are unchanged \u2014 dropping the headers does not move the draft out of the thread in Gmail's own UI, it only stops recipients' clients threading it. ${BODY_OVERWRITE_CAVEAT} ${VERIFICATION_PROVENANCE}`
+    };
+  }
+  return {
+    requested: "set",
+    via: intent.via,
+    target: intent.target,
+    ok: hasLineage,
+    effective,
+    note: hasLineage ? `Threading applied and verified: gog reports the draft now replies to ${effective.inReplyTo}, on thread ${threadLabel}, with the draft id unchanged \u2014 it was updated in place, not recreated. See effective.references and effective.replyContextSource for the rest ("caller" means the lineage was resolved from the target you named, "carried" that it came from the draft's own stored headers). ${BODY_OVERWRITE_CAVEAT} ${VERIFICATION_PROVENANCE}` : `WARNING: ${intent.via} ${intent.target} was accepted, but gog reports NO reply headers at all (inReplyTo is null). The draft HAS been moved onto thread ${threadLabel}, so this was not a no-op \u2014 it simply will not arrive as a reply, because recipients' mail clients thread on In-Reply-To/References, not on Gmail's threadId. And an explicit reply target REPLACES the draft's own stored reply context rather than carrying it forward, so any lineage the draft had before this call is gone. Do not send it as a reply on this evidence. ${VERIFICATION_PROVENANCE}`
+  };
+}
+function withThreadingVerification(result, verification) {
+  try {
+    const parsed = JSON.parse(String(resultText(result)));
+    return rawTextResult(JSON.stringify({ ...parsed, threadingVerification: verification }));
+  } catch {
+    return withNote(result, [`threadingVerification: ${verification.note}`]);
+  }
+}
+var CONTENT_LOSS_NO_CLAIM_NOTE = "This check compares two bodies and nothing else. It does not say that either draft replaced the other, and it cannot: YOU named this sibling, nothing here searched for it. Identical bodies would not prove a pairing and divergent bodies would not disprove one \u2014 a pairing verdict needs an identity header, a lineage link back to the original and an ordering, which is what gog_gmail_drafts_diff weighs and reports with its evidence.";
+var CONTENT_LOSS_COMPARISON_NOTE = "Lines are compared after collapsing runs of whitespace and dropping blank lines, and only against the plain-text `body` you passed \u2014 a bodyHtml is not compared, and neither are attachments, recipients or the subject. The comparison is LINE-BASED: a copy whose paragraphs were re-wrapped at a different width, or whose straight quotes became curly ones, no longer matches line for line, so it can be reported as loss even though no words were dropped. Read the listed lines before deciding.";
+function evaluateContentLoss(siblingDraftId, siblingBody, newBody, maxLines) {
+  const siblingLines = new Set(normalizeBodyLines(siblingBody));
+  const newLines = new Set(normalizeBodyLines(newBody));
+  const missing = [...siblingLines].filter((line) => !newLines.has(line));
+  const truncated = missing.length > maxLines;
+  const base = {
+    siblingDraftId,
+    siblingBodyLineCount: siblingLines.size,
+    newBodyLineCount: newLines.size,
+    linesOnlyInSibling: missing.slice(0, maxLines),
+    linesOnlyInSiblingCount: missing.length,
+    truncated,
+    similarity: bodySimilarity(siblingBody, newBody),
+    forkClaim: null,
+    forkClaimNote: CONTENT_LOSS_NO_CLAIM_NOTE
+  };
+  if (siblingLines.size === 0) {
+    return {
+      ...base,
+      status: "unchecked",
+      note: `No body text could be read from draft ${siblingDraftId}, so NOTHING WAS COMPARED and nothing is proven. The draft may genuinely be empty, or its text may sit in a MIME part this server could not decode. Read it with gog_gmail_drafts_get before overwriting draft text you cannot see. ${CONTENT_LOSS_COMPARISON_NOTE}`
+    };
+  }
+  if (missing.length === 0) {
+    return {
+      ...base,
+      status: "clean",
+      note: `Every line of draft ${siblingDraftId} is already present in the body you passed, so this update leaves nothing behind in that copy. It says nothing about the reverse direction: lines of the draft being UPDATED that your body omits are overwritten regardless \u2014 this check cannot see them, because gog's write acknowledgement never returns the previous body. ${CONTENT_LOSS_COMPARISON_NOTE}`
+    };
+  }
+  return {
+    ...base,
+    status: "would-lose",
+    note: `WARNING: ${missing.length} line(s) of draft ${siblingDraftId} are NOT in the body you passed. gog requires a body on every update, so this call rewrites the WHOLE body \u2014 afterwards those lines exist only in that sibling draft. Merge them into the body and retry, or pass acceptContentLoss:true to write anyway.` + (truncated ? ` (Line list truncated to ${maxLines}; linesOnlyInSiblingCount is the true total.)` : "") + ` ${CONTENT_LOSS_COMPARISON_NOTE}`
+  };
+}
+function unreadableSiblingCheck(siblingDraftId, reason) {
+  return {
+    siblingDraftId,
+    status: "unchecked",
+    siblingBodyLineCount: 0,
+    newBodyLineCount: 0,
+    linesOnlyInSibling: [],
+    linesOnlyInSiblingCount: 0,
+    truncated: false,
+    similarity: 0,
+    forkClaim: null,
+    forkClaimNote: CONTENT_LOSS_NO_CLAIM_NOTE,
+    note: `Could not read draft ${siblingDraftId} to check what this update would overwrite: ${reason}. NOTHING WAS COMPARED, so nothing is proven. A draft id that has stopped resolving is itself worth noting \u2014 that is what a mail client leaves behind when it rewrites a draft instead of updating it.`
+  };
+}
+async function checkSiblingContentLoss(siblingDraftId, newBody, account) {
+  let raw;
+  try {
+    raw = await runNormalized(["gmail", "drafts", "get", siblingDraftId, "--use-indexed-attachment-ids=false"], { account });
+  } catch (err) {
+    return unreadableSiblingCheck(siblingDraftId, String(err));
+  }
+  let message;
+  try {
+    message = JSON.parse(raw).draft?.message;
+  } catch {
+    message = void 0;
+  }
+  if (!message) {
+    return unreadableSiblingCheck(siblingDraftId, "`gog gmail drafts get` returned no `draft.message` object to read a body from");
+  }
+  return evaluateContentLoss(siblingDraftId, bestBodyText(message.payload), newBody, DRAFT_DIFF_MAX_LINES);
+}
+var CONTENT_LOSS_HOW_TO_PROCEED = [
+  "Merge the missing lines into your body and call gog_gmail_drafts_update again. The check re-runs, so a complete merge passes it.",
+  "Run gog_gmail_drafts_diff on the two ids first if you want the full picture \u2014 it reports both directions of divergence, whether either body is a superset, how the threading differs, and (separately, with its evidence) whether there is enough to say one draft replaced the other.",
+  "Pass acceptContentLoss:true to write this body as-is. The sibling draft is not touched either way, so the listed lines are still recoverable from it afterwards \u2014 but the draft you are updating loses whatever your body omits, permanently.",
+  "Drop forkSiblingDraftId to skip the check entirely (and the one gog call it costs)."
+];
+function contentLossRefusal(draftId, check2) {
+  const code = check2.status === "unchecked" ? "DRAFT_CONTENT_LOSS_UNCHECKED" : "DRAFT_CONTENT_LOSS";
+  const headline = check2.status === "unchecked" ? `the content-loss check you asked for could not be run against draft ${check2.siblingDraftId}` : `${check2.linesOnlyInSiblingCount} line(s) of draft ${check2.siblingDraftId} are missing from the body you passed`;
+  const payload = {
+    code,
+    codeMeaning: check2.status === "unchecked" ? "The named sibling could not be read, so the guard could not run. An unrun check is not a passed check, so the write was refused." : "The body passed would have dropped text the named sibling still holds, and gog rewrites the whole body on every update.",
+    tool: "gog_gmail_drafts_update",
+    draftId,
+    forkSiblingDraftId: check2.siblingDraftId,
+    whatHappened: `NOTHING WAS WRITTEN. Draft ${draftId} is byte-for-byte as it was: no body, subject, recipient, attachment or reply-header change was applied, and no gog write ran at all. ${headline}.`,
+    contentLossCheck: check2,
+    howToProceed: CONTENT_LOSS_HOW_TO_PROCEED
+  };
+  return errorResult(
+    `${code}: nothing was written \u2014 ${headline}. gog requires a body on every draft update, so there is no header-only edit and the update would have rewritten the whole body.
+
+` + JSON.stringify(payload, null, 2)
+  );
+}
+function withContentLossCheck(result, check2) {
+  try {
+    const parsed = JSON.parse(String(resultText(result)));
+    return rawTextResult(JSON.stringify({ ...parsed, contentLossCheck: check2 }));
+  } catch {
+    return withNote(result, [`contentLossCheck: ${check2.note}`]);
+  }
+}
+var DRAFT_NOT_FOUND_PATTERN = /Google API error \(404\b|\b404\b[^\n]{0,40}not\s?found/i;
+var DRAFT_FORK_MAX_CANDIDATES = 20;
+var DRAFT_FORK_CLAIM_NOTE = "This report names NO replacement, and cannot. The 404'd draft can no longer be fetched, so there is nothing left to establish lineage against \u2014 no References citing it, no shared reply root, no body to compare \u2014 and without a lineage signal no pairing verdict is possible at any cost tier. The drafts below are simply the drafts that exist right now; ordering is presentation, not evidence. To decide whether one draft replaced another, name a PAIR and run gog_gmail_drafts_diff, which reads both sides' headers and bodies.";
+var DRAFT_FORK_OTHER_EXPLANATIONS = [
+  "The draft was deleted \u2014 by you, by a mail client, or by an earlier gog_gmail_drafts_delete. A deleted draft 404s identically.",
+  "The draft was already sent. Sending consumes the draft, so its id stops resolving; check Sent before recreating anything.",
+  "A mail client rewrote the draft instead of updating it in place, writing a NEW draft and abandoning this id. This is the only one of the three that strands text in two places, and the reason this report exists."
+];
+function replyTargetExplanation(replyTarget) {
+  return `The 404 may have been about your REPLY TARGET rather than the draft. You passed ${replyTarget.via}=${replyTarget.target}, and \`gog gmail drafts update\` resolves up to three different Google entities \u2014 the draft (Users.Drafts.Get/Update), the thread behind --thread-id and the message behind --reply-to-message-id \u2014 which gog renders with the IDENTICAL 404 string (internal/errfmt/googleapi.go). Thread ids and message ids are both 16-hex strings and are routinely confused, and a thread id copied from a stale record may simply no longer exist. Fetch it \u2014 gog_gmail_thread_get for a thread id, gog_gmail_get for a message id \u2014 before concluding anything about the draft.`;
+}
+var DRAFT_LISTING_BASIS_NOTE = {
+  "complete-listing": (draftId, listed) => `The listing returned ${listed} draft(s) \u2014 FEWER than the ${DRAFT_FORK_MAX_CANDIDATES}-draft window it asked for, so it covers the whole Drafts folder. Draft ${draftId} really is not in the mailbox.`,
+  "capped-listing": (draftId) => `The listing came back FULL: ${DRAFT_FORK_MAX_CANDIDATES} drafts, which is the entire window it asked for, so it is TRUNCATED and draft ${draftId} could still exist beyond it. "Not listed here" is NOT evidence that the draft is gone \u2014 the window is capped by construction, because this is a failure path and must not grow with the size of the mailbox. Run gog_gmail_drafts_list with a larger max (or all:true) before concluding the draft forked.`,
+  "listing-unavailable": (draftId) => `The listing FAILED, so nothing here shows whether draft ${draftId} still exists. The 404 is the only evidence there is, and gog renders the draft, thread and message 404s identically. Run gog_gmail_drafts_list yourself before acting.`
+};
+var DRAFT_FORK_NEXT_STEPS = [
+  "Run gog_gmail_drafts_list \u2014 origin and rootsOwnThread cost nothing there \u2014 and look for a draft you did not create through this server.",
+  "Name a PAIR and run gog_gmail_drafts_diff: it is the only path in this server that can issue a fork verdict, because it is the only one that reads both sides' identity headers, reply lineage and bodies. It cannot be pointed at THIS id \u2014 a 404'd draft cannot be fetched at all \u2014 so diff the survivor against another draft you still have.",
+  "If a replacement lost its reply threading, re-thread it IN PLACE with gog_gmail_drafts_update replyToThreadId=<the original thread id>: the draft keeps its id and gog resolves In-Reply-To/References from that thread's latest message, reporting them back under threadingVerification. It requires a full body, so merge the two bodies FIRST \u2014 whatever you do not pass is lost.",
+  "If the draft was deleted or already sent, nothing forked and there is nothing to reconcile."
+];
+async function currentDraftsForForkReport(account) {
+  let entries;
+  try {
+    const listed = JSON.parse(
+      await run(["gmail", "drafts", "list", `--max=${DRAFT_FORK_MAX_CANDIDATES}`], { account })
+    );
+    if (!Array.isArray(listed.drafts)) throw new Error("`gog gmail drafts list` returned no drafts array");
+    entries = listed.drafts;
+  } catch (err) {
+    return {
+      extraGogCalls: 1,
+      listingBasis: "listing-unavailable",
+      currentDraftsUnavailable: `Could not list the surviving drafts (${String(err)}), so this report names none. Run gog_gmail_drafts_list yourself \u2014 origin and rootsOwnThread are free there.`
+    };
+  }
+  const byMessageId = /* @__PURE__ */ new Map();
+  let enrichmentNote;
+  try {
+    const searched = JSON.parse(await runNormalized([
+      "gmail",
+      "messages",
+      "search",
+      "in:drafts",
+      `--max=${DRAFT_FORK_MAX_CANDIDATES}`,
+      "--include-attachments=false",
+      "--use-indexed-attachment-ids=false"
+    ], { account }));
+    if (!Array.isArray(searched.messages)) throw new Error("`gog gmail messages search in:drafts` returned no messages array");
+    for (const m of searched.messages) {
+      if (m.id) byMessageId.set(m.id, m);
+    }
+    enrichmentNote = DRAFT_ENRICH_COST_NOTE;
+  } catch (err) {
+    enrichmentNote = `subject, from and internalDateIso are missing: the single enrichment call failed (${String(err)}). The free fields (origin, rootsOwnThread) are unaffected.`;
+  }
+  const currentDrafts = entries.map((d) => {
+    const extra = byMessageId.get(d.messageId);
+    return {
+      ...d,
+      origin: originFromDraftId(d.id ?? ""),
+      rootsOwnThread: rootsOwnThread(d),
+      subject: extra?.subject,
+      from: extra?.from,
+      internalDateIso: extra?.internalDateIso
+    };
+  });
+  currentDrafts.sort((x, y) => (y.internalDateIso ?? "").localeCompare(x.internalDateIso ?? ""));
+  const listingBasis = entries.length >= DRAFT_FORK_MAX_CANDIDATES ? "capped-listing" : "complete-listing";
+  return { extraGogCalls: 2, listingBasis, currentDrafts, enrichmentNote };
+}
+function splitListingBasis(report) {
+  const { listingBasis, ...rest } = report;
+  return { basis: listingBasis, rest };
+}
+function draftForkedResult(tool, draftId, gogError, report, replyTarget) {
+  const { basis, rest } = splitListingBasis(report);
+  const listed = Array.isArray(rest.currentDrafts) ? rest.currentDrafts.length : 0;
+  const proven = basis === "complete-listing";
+  const whatHappened = proven ? `${tool} could not act on draft ${draftId}: Gmail no longer has a draft with that id, and a listing that covered the whole Drafts folder does not contain it either. Editing a draft in a real mail client does not update it in place \u2014 the client writes a NEW draft and abandons the original \u2014 so the id you were given stops resolving, the replacement usually sits on its OWN threadId with no In-Reply-To/References (sending it would start a new conversation in front of every recipient, including anyone on Cc), and each copy can hold text the other lost. Gmail has no draft under this id, so nothing this call carried \u2014 subject, body, recipients \u2014 is saved under it.` : `${tool} did not run and NOTHING WAS WRITTEN: Gmail returned 404 notFound. Whether draft ${draftId} itself still exists is NOT established here \u2014 ${DRAFT_LISTING_BASIS_NOTE[basis](draftId, listed)} A mail client rewriting a draft instead of updating it in place is one explanation for a 404 like this, and the reason this report exists, but on this evidence it is only one of several \u2014 read otherExplanations before acting on any of them.`;
+  const payload = {
+    code: "DRAFT_FORKED",
+    codeMeaning: "Gmail returned 404 notFound for this draft id. DRAFT_FORKED names the most common CAUSE \u2014 a mail client rewriting the draft instead of updating it in place \u2014 not a proven one: deletion and sending produce the same 404, and so does a stale reply target. See otherExplanations, and see listingEvidence for what the post-failure listing could actually show.",
+    tool,
+    draftId,
+    gogError,
+    whatHappened,
+    replyTarget: replyTarget ?? null,
+    listingEvidence: {
+      basis,
+      windowSize: DRAFT_FORK_MAX_CANDIDATES,
+      draftsListed: basis === "listing-unavailable" ? null : listed,
+      draftFoundInListing: false,
+      establishesTheDraftIsGone: proven,
+      note: DRAFT_LISTING_BASIS_NOTE[basis](draftId, listed)
+    },
+    forkClaim: null,
+    forkClaimNote: DRAFT_FORK_CLAIM_NOTE,
+    ...rest,
+    otherExplanations: replyTarget ? [replyTargetExplanation(replyTarget), ...DRAFT_FORK_OTHER_EXPLANATIONS] : DRAFT_FORK_OTHER_EXPLANATIONS,
+    nextSteps: DRAFT_FORK_NEXT_STEPS,
+    signalsThatNeverSuffice: FORK_SIGNALS_THAT_NEVER_SUFFICE
+  };
+  const headline = proven ? `DRAFT_FORKED: draft ${draftId} no longer resolves \u2014 Gmail 404'd it and a listing that covered the whole Drafts folder does not contain it \u2014 so ${tool} did not run. The usual cause is a mail client rewriting the draft under a new id rather than updating it; deletion and sending look identical from here.` : `DRAFT_FORKED: Gmail returned 404 notFound for draft ${draftId}, so ${tool} did not run and nothing was written. Whether that draft still exists is NOT established: ${DRAFT_LISTING_BASIS_NOTE[basis](draftId, listed)}`;
+  return errorResult(
+    `${headline} No replacement is named below \u2014 that judgement needs a named pair and gog_gmail_drafts_diff.
+
+` + JSON.stringify(payload, null, 2)
+  );
+}
+function draftIsStillListed(report, draftId) {
+  const listed = report.currentDrafts;
+  return Array.isArray(listed) && listed.some((d) => d.id === draftId);
+}
+var NOT_THE_DRAFT_RACE_NOTE = "The listing was taken AFTER the failure, so it is evidence about now, not about the instant the call ran. If something recreated a draft under this id in between \u2014 vanishingly unlikely, but not impossible \u2014 the listed draft could be a different one from the draft you addressed.";
+var NOT_THE_DRAFT_WHY_404 = "`gog gmail drafts update` resolves up to THREE different Google entities, and gog renders all three 404s with the same string (`Google API error (404 notFound): Requested entity was not found.`, internal/errfmt/googleapi.go): the DRAFT itself (Users.Drafts.Get/Update), the THREAD behind --thread-id (Users.Threads.Get, i.e. replyToThreadId) and the MESSAGE behind --reply-to-message-id (Users.Messages.Get). The error text alone cannot tell them apart \u2014 the draft listing can.";
+function notTheDraftResult(tool, draftId, gogError, report, replyTarget) {
+  const targetClause = replyTarget ? `You passed ${replyTarget.via}=${replyTarget.target}; since the draft resolves, THAT id is the one that did not, and it is the first thing to check. Thread ids and message ids are both 16-hex strings and are routinely confused, and a thread id copied from a stale record may simply no longer exist.` : "This call named no reply target, so the 404 came from somewhere else in it. Whatever it was, it was not this draft id.";
+  const { rest } = splitListingBasis(report);
+  const payload = {
+    code: "GOOGLE_404_NOT_THE_DRAFT",
+    codeMeaning: `Google returned 404 notFound, but draft ${draftId} is STILL LISTED in the mailbox, so the 404 was not about the draft id. It is deliberately NOT reported as a fork: nothing here suggests a mail client replaced anything.`,
+    tool,
+    draftId,
+    gogError,
+    whatHappened: `${tool} did not run and NOTHING WAS WRITTEN \u2014 but draft ${draftId} still exists: it is still listed below, in a listing taken after the failure. ${NOT_THE_DRAFT_WHY_404} ${targetClause}`,
+    replyTarget: replyTarget ?? null,
+    forkClaim: null,
+    forkClaimNote: "No fork is claimed and none is implied. The draft you addressed still resolves, which is the opposite of what a mail client rewriting a draft leaves behind.",
+    ...rest,
+    raceNote: NOT_THE_DRAFT_RACE_NOTE,
+    nextSteps: [
+      "Check the reply target, not the draft: a thread id belongs in replyToThreadId and a message id in replyToMessageId, and both are 16-hex strings. Fetch it \u2014 gog_gmail_thread_get for a thread id, gog_gmail_get for a message id \u2014 and a 404 there confirms the target is what is missing.",
+      "If the thread id came from a stale record (an old fork report, an earlier note), re-find the conversation with gog_gmail_search and take the thread id from a message that still exists.",
+      "Re-run the call without the reply target to confirm the draft itself writes fine. Remember it rewrites the WHOLE body, so pass the body you actually want.",
+      "Do NOT go hunting for a replacement draft. Nothing here says this draft forked."
+    ]
+  };
+  return errorResult(
+    `GOOGLE_404_NOT_THE_DRAFT: Google said 404 notFound, but draft ${draftId} is still listed, so the 404 was not about the draft id \u2014 ${replyTarget ? `the reply target ${replyTarget.via}=${replyTarget.target} is the remaining explanation` : "something else in the call is the explanation"}. ${tool} did not run and nothing was written. This is NOT a fork.
+
+` + JSON.stringify(payload, null, 2)
+  );
+}
+async function forkAwareDraftFailure(result, tool, draftId, account, replyTarget) {
+  if (result.isError !== true) return result;
+  const text = String(resultText(result));
+  if (!DRAFT_NOT_FOUND_PATTERN.test(text)) return result;
+  const report = await currentDraftsForForkReport(account);
+  return draftIsStillListed(report, draftId) ? notTheDraftResult(tool, draftId, text, report, replyTarget) : draftForkedResult(tool, draftId, text, report, replyTarget);
+}
 function registerExtraGmailTools(server) {
   server.registerTool("gog_gmail_raw", {
     description: "Dump the raw Gmail API response as JSON (lossless; for scripting and LLM consumption).",
@@ -32903,20 +33688,137 @@ function registerExtraGmailTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_gmail_drafts_list", {
-    description: "List Gmail drafts.",
+    description: 'List Gmail drafts. Each entry is annotated FOR FREE \u2014 no extra gog invocation, whatever the number of drafts \u2014 with `origin` (`api` = created through the Gmail API; `non-api` = the id begins `s:`, i.e. it arrived over IMAP/sync) and `rootsOwnThread` (threadId equals the draft\'s own messageId, so sending it starts a NEW conversation instead of replying). Read those two as facts about the draft, NOT as a fork verdict: `non-api` is not "Apple Mail" (Thunderbird, Outlook-over-IMAP and Gmail offline all produce `s:` ids), and rootsOwnThread was a 4/8 = 0.50 coin flip for Apple authorship on a live mailbox. The prose behind rootsOwnThread is one of exactly two constants, so it rides along ONCE per result under `threadingNotes` (`rootsOwnThread` / `inThread`) and the per-row boolean selects between them. To decide whether one draft actually replaced another, diff the named pair with gog_gmail_drafts_diff.',
     annotations: { readOnlyHint: true },
     inputSchema: {
       max: external_exports.number().optional().describe("Max results (default: 20)"),
       page: external_exports.string().optional().describe("Page token"),
       all: external_exports.boolean().optional().describe("Fetch all pages"),
+      enrich: external_exports.boolean().optional().describe(
+        "Add subject, from and internalDateIso to each draft. Costs ONE extra gog invocation (`gmail messages search in:drafts`) regardless of how many drafts there are \u2014 but that single command makes gog fetch every matching draft server-side at concurrency 10, so Google reads and wall-clock are linear in the result count even though gog spawns are not. Narrow `max` before enabling it. If the search fails the listing silently degrades to the free fields rather than erroring."
+      ),
       account: accountParam
     }
-  }, async ({ max, page, all, account }) => {
+  }, async ({ max, page, all, enrich, account }) => {
     const args = ["gmail", "drafts", "list"];
     if (max !== void 0) args.push(`--max=${max}`);
     if (page) args.push(`--page=${page}`);
     if (all) args.push("--all");
-    return runOrDiagnose(args, { account });
+    const result = await runOrDiagnose(args, { account });
+    let parsed;
+    let entries;
+    try {
+      parsed = JSON.parse(resultText(result) ?? "");
+      const rawDrafts = parsed.drafts;
+      if (!Array.isArray(rawDrafts)) return result;
+      entries = rawDrafts;
+    } catch {
+      return result;
+    }
+    const byMessageId = /* @__PURE__ */ new Map();
+    let enrichment;
+    if (enrich) {
+      const searchArgs = ["gmail", "messages", "search", "in:drafts", `--max=${max ?? GOG_DRAFTS_LIST_DEFAULT_MAX}`];
+      if (all) searchArgs.push("--all");
+      if (page) searchArgs.push(`--page=${page}`);
+      searchArgs.push("--include-attachments=false", "--use-indexed-attachment-ids=false");
+      try {
+        const messages = JSON.parse(await runNormalized(searchArgs, { account })).messages;
+        if (!Array.isArray(messages)) throw new Error("`gog gmail messages search in:drafts` returned no messages array");
+        for (const m of messages) {
+          if (m.id) byMessageId.set(m.id, m);
+        }
+        enrichment = { requested: true, applied: true, extraGogCalls: 1, matched: 0, unmatched: 0, costNote: DRAFT_ENRICH_COST_NOTE };
+      } catch (err) {
+        enrichment = {
+          requested: true,
+          applied: false,
+          extraGogCalls: 1,
+          reason: `Enrichment failed, so the listing degraded to the free tier-0 fields (origin, rootsOwnThread): ${String(err)}`
+        };
+      }
+    }
+    let matched = 0;
+    const drafts = entries.map((d) => {
+      const roots = rootsOwnThread(d);
+      const extra = byMessageId.get(d.messageId);
+      if (extra) matched += 1;
+      return {
+        ...d,
+        origin: originFromDraftId(d.id ?? ""),
+        rootsOwnThread: roots,
+        ...extra ? { subject: extra.subject, from: extra.from, internalDateIso: extra.internalDateIso } : {}
+      };
+    });
+    if (enrichment?.applied === true) {
+      enrichment.matched = matched;
+      enrichment.unmatched = entries.length - matched;
+    }
+    return rawTextResult(JSON.stringify({
+      ...parsed,
+      drafts,
+      originNote: DRAFT_LIST_ORIGIN_NOTE,
+      threadingNotes: { rootsOwnThread: DRAFT_ROOTS_OWN_THREAD_NOTE, inThread: DRAFT_IN_THREAD_NOTE },
+      ...enrichment ? { enrichment } : {}
+    }));
+  });
+  server.registerTool("gog_gmail_drafts_diff", {
+    description: "Compare TWO NAMED DRAFTS and report exactly how they diverged: which body lines exist only in one, whether either is a superset of the other, how their threading differs, and \u2014 kept deliberately separate from all of that \u2014 whether there is enough evidence to say one REPLACED the other. Use it when a draft you created stopped resolving (`gog_gmail_drafts_update` returning `Google API error (404 notFound)` is the usual first symptom) and a newer draft has appeared: editing a draft in a real mail client does not update it in place, it writes a new draft and abandons the original, so both copies can hold text the other lost. COST: exactly 2 gog invocations, one `gmail drafts get` per named draft. It never scans the mailbox and never grows with the number of drafts. THE PAIRING VERDICT IS `confirmed` ONLY when all four of these hold: an Apple identity header on the candidate, a real LINEAGE link FROM THE CANDIDATE TO THE ORIGINAL, a strictly newer candidate, and the same From. Exactly two things count as lineage, and both point at the original itself: (a) the ORIGINAL DRAFT's own Message-Id appearing in the candidate's In-Reply-To/References, or (b) agreement on text NEITHER draft quoted AND NEITHER CLIENT GENERATED \u2014 the salutation, the closing formula, the name under it and the signature block are excluded alongside quoting, because a mail client reproduces all of them identically on every message it composes \u2014 meeting all three printed minimums (similarity, shared lines, shared characters \u2014 all reported under bodyAgreement, alongside quotedLinesIgnored and boilerplateLinesIgnored so you can see what each filter removed). A SHARED REPLY ROOT IS NOT LINEAGE: it links both drafts to a common ANCESTOR, which every reply in a thread has, so it is reported as corroboration and can raise the answer no higher than an explicitly WEAK `candidate`. Anything less than all four is `candidate` and names every missing signal; with neither lineage nor corroboration it is `none` \u2014 which means no evidence was FOUND, not that the drafts are proven unrelated (the comparison is line-based, so re-wrapping and smart quotes can hide a real link). NONE OF THE FOLLOWING EVER SUFFICES, alone or combined: " + FORK_SIGNALS_THAT_NEVER_SUFFICE.join(" ") + " Act on `confirmed` only after reading the evidence list; treat `candidate` as a question to verify by hand. Merging the wrong pair sends the wrong text to the wrong thread, in front of everyone on Cc.",
+    annotations: { readOnlyHint: true },
+    inputSchema: {
+      draftIdA: external_exports.string().describe("First draft id \u2014 conventionally the ORIGINAL (the one you created). Direction is decided by internalDate, not by this order, and the answer says which it treated as the original."),
+      draftIdB: external_exports.string().describe("Second draft id \u2014 conventionally the SUSPECTED REPLACEMENT."),
+      maxDiffLines: external_exports.number().int().positive().optional().describe(`Cap on the per-side line lists (default ${DRAFT_DIFF_MAX_LINES}); must be a positive integer. The counts and the verdict are computed on the FULL bodies; only the printed lists are capped, \`truncated\` says when they were, and onlyInACount/onlyInBCount give the untruncated totals.`),
+      account: accountParam
+    }
+  }, async ({ draftIdA, draftIdB, maxDiffLines, account }) => {
+    const fetchArgs = (id) => ["gmail", "drafts", "get", id, "--use-indexed-attachment-ids=false"];
+    let rawA;
+    let rawB;
+    try {
+      rawA = await runNormalized(fetchArgs(draftIdA), { account });
+      rawB = await runNormalized(fetchArgs(draftIdB), { account });
+    } catch (err) {
+      return diagnose(new Error(
+        `gog_gmail_drafts_diff could not fetch both drafts (${draftIdA}, ${draftIdB}): ${String(err)}. A draft id that has stopped resolving is exactly what a mail client leaves behind when it rewrites a draft instead of updating it \u2014 the old id 404s and a new draft holds the edited text. Run gog_gmail_drafts_list (origin and rootsOwnThread are free there), pick the surviving id, and diff it against the one that still resolves.`
+      ));
+    }
+    const parseDraft = (raw) => {
+      try {
+        return JSON.parse(raw).draft?.message;
+      } catch {
+        return void 0;
+      }
+    };
+    const msgA = parseDraft(rawA);
+    const msgB = parseDraft(rawB);
+    if (!msgA || !msgB) {
+      return errorResult(
+        `Could not read the stored message for draft ${msgA ? draftIdB : draftIdA} \u2014 \`gog gmail drafts get\` returned no \`draft.message\` object. Nothing is reported rather than diffing half a pair and letting the missing side read as "empty".`
+      );
+    }
+    const a = describeDraftSide(draftIdA, msgA);
+    const b = describeDraftSide(draftIdB, msgB);
+    const aMs = parseInternalDateMs(msgA.internalDate);
+    const bMs = parseInternalDateMs(msgB.internalDate);
+    const bIsCandidate = !(aMs !== void 0 && bMs !== void 0 && bMs < aMs);
+    const original = bIsCandidate ? a : b;
+    const candidate = bIsCandidate ? b : a;
+    return textResult({
+      drafts: { a: a.side, b: b.side },
+      bodyDiff: diffBodyLines(
+        bestBodyText(msgA.payload),
+        bestBodyText(msgB.payload),
+        maxDiffLines ?? DRAFT_DIFF_MAX_LINES
+      ),
+      threadingDifferences: threadingDifferences(a.side, b.side),
+      forkPairing: {
+        originalDraftId: original.side.draftId,
+        candidateDraftId: candidate.side.draftId,
+        ...evaluateForkPairing(original.facts, candidate.facts, 2)
+      },
+      costNote: "This call made exactly 2 gog invocations, one `gmail drafts get` per named draft, and is capped there by construction."
+    });
   });
   server.registerTool("gog_gmail_drafts_get", {
     description: "Get a Gmail draft by ID.",
@@ -32973,18 +33875,40 @@ function registerExtraGmailTools(server) {
     if (f.from) args.push(`--from=${f.from}`);
     args.push(f.autoFromAddressedAlias ? "--auto-from-addressed-alias" : "--auto-from-addressed-alias=false");
   }
-  async function writeDraft(args, account, returnFull, knownDraftId) {
+  function withRefetchNote(written, draftId) {
+    return {
+      ...written,
+      content: [
+        ...written.content,
+        {
+          type: "text",
+          text: `Note: the write to draft ${draftId} SUCCEEDED and is acknowledged above. The follow-up read-back requested by returnFull could not be performed \u2014 the id did not resolve, which on this mailbox usually means the draft was forked by a mail client between the write and the read. Nothing was lost. Run gog_gmail_drafts_list to find the current id, or gog_gmail_drafts_get on ${draftId} to confirm.`
+        }
+      ]
+    };
+  }
+  async function writeDraft(args, account, returnFull, knownDraftId, intent) {
     const result = await runOrDiagnose(args, { account });
-    if (!returnFull) return result;
-    let parsed;
+    let ack;
+    let ackDraftId;
     try {
-      parsed = JSON.parse(resultText(result) ?? "");
+      ack = JSON.parse(resultText(result) ?? "");
+      ackDraftId = typeof ack.draftId === "string" ? ack.draftId : void 0;
     } catch {
       return result;
     }
-    const draftId = knownDraftId ?? parsed.draftId;
-    if (!draftId) return result;
-    return runOrDiagnose(["gmail", "drafts", "get", draftId, "--use-indexed-attachment-ids=false"], { account });
+    const verification = intent ? verifyThreading(intent, ack) : void 0;
+    let final = result;
+    if (returnFull) {
+      const draftId = knownDraftId ?? ackDraftId;
+      if (draftId) {
+        const refetched = await runOrDiagnose(["gmail", "drafts", "get", draftId, "--use-indexed-attachment-ids=false"], { account });
+        if (refetched.isError !== true) final = refetched;
+        else final = withRefetchNote(result, draftId);
+      }
+    }
+    if (!verification) return final;
+    return withThreadingVerification(final, verification);
   }
   server.registerTool("gog_gmail_drafts_create", {
     description: "Create a new Gmail draft. Recipients (to/cc/bcc) are optional; omit them (or set omitRecipients) to create a recipient-less draft as an accidental-send guard. For replies, prefer replyToThreadId (anchors to the thread's latest message) or replyToMessageId (a specific message) \u2014 don't pass a thread id into replyToMessageId, which mis-threads silently.",
@@ -32995,20 +33919,51 @@ function registerExtraGmailTools(server) {
     return writeDraft(args, account, returnFull);
   });
   server.registerTool("gog_gmail_drafts_update", {
-    description: "Update an existing Gmail draft. For replies, prefer replyToThreadId (threads off the thread's latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId. An update preserves the draft's existing reply context (In-Reply-To/References) and its threadId; it never invents reply headers for a draft that is not a reply. The result reports the effective inReplyTo/references so you can verify threading without a raw-header fetch. Attachment semantics: supplying attach REPLACES the draft's existing attachments; omitting it preserves them; set clearAttachments to remove all.",
+    description: "Update an existing Gmail draft. For replies, prefer replyToThreadId (threads off the thread's latest message) or replyToMessageId (a specific message) over passing a thread id into replyToMessageId. An update preserves the draft's existing reply context (In-Reply-To/References) and its threadId; it never invents reply headers for a draft that is not a reply. Attachment semantics: supplying attach REPLACES the draft's existing attachments; omitting it preserves them; set clearAttachments to remove all. REPAIRING THREADING IN PLACE: passing replyToThreadId re-anchors the draft onto that thread and lets gog resolve In-Reply-To/References from the thread's latest sent-or-received message, KEEPING THE SAME DRAFT ID \u2014 so a draft that lost its reply headers (typically one a mail client rewrote from scratch) is adopted back onto the conversation in a single call. Whenever you change reply context (replyToThreadId, replyToMessageId or clearReplyContext) the result gains a `threadingVerification` block reporting the effective threadId/inReplyTo/references/replyContextSource, an `ok` flag and a plain-English note, so you can confirm the repair WITHOUT a raw-header fetch and without a second call. Read it: an explicit reply target REPLACES the draft's stored lineage rather than merging with it, and if the target thread yields no reply headers the draft is still MOVED onto that thread \u2014 it would arrive inside the conversation but not as a reply. THE BODY IS ALWAYS OVERWRITTEN: gog requires a body on every update, so there is no header-only edit. If a sibling copy of this draft exists, diff them with gog_gmail_drafts_diff and merge BEFORE updating, or whatever text you do not pass is lost. A 404 comes back diagnosed rather than as a bare notFound, and the diagnosis is checked against a draft listing first: GOOGLE_404_NOT_THE_DRAFT when the draft is still listed \u2014 because replyToThreadId and replyToMessageId resolve their own Google entities and a miss on either 404s with the identical message \u2014 and DRAFT_FORKED otherwise. That listing is capped at 20 drafts, so DRAFT_FORKED reports under `listingEvidence` whether its own evidence actually covers the mailbox: only `complete-listing` (the window came back short of 20, so it saw the whole Drafts folder) says the draft is gone. `capped-listing` and `listing-unavailable` say in words that they establish nothing about the draft, and any reply target you passed is echoed there with its explanation listed first.",
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: external_exports.string().describe("Draft ID"),
       ...draftWriteSchema,
       clearAttachments: external_exports.boolean().optional().describe("Remove all attachments from the draft. By default, omitting attach preserves the draft's existing attachments; this intentionally clears them. Ignored if attach is also supplied (attach replaces)."),
-      clearReplyContext: external_exports.boolean().optional().describe("Strip In-Reply-To/References from the draft, turning a reply back into a standalone message while keeping the same draft id and threadId. Use this to repair a mis-threaded draft in place instead of deleting and recreating it. Mutually exclusive with replyToMessageId, replyToThreadId and quote \u2014 gog rejects the call if any of them is combined with this.")
+      clearReplyContext: external_exports.boolean().optional().describe("Strip In-Reply-To/References from the draft, turning a reply back into a standalone message while keeping the same draft id and threadId. Use this to repair a mis-threaded draft in place instead of deleting and recreating it. Mutually exclusive with replyToMessageId, replyToThreadId and quote \u2014 gog rejects the call if any of them is combined with this."),
+      forkSiblingDraftId: external_exports.string().optional().describe("Id of the OTHER copy of this draft \u2014 the one a mail client left behind, or the one you are merging from. Because gog requires a body on every update, this call rewrites the WHOLE body; naming a sibling makes the tool read that draft FIRST (one extra gog call, on this id only \u2014 it never scans) and refuse to write if your body omits any line the sibling still holds, naming the exact lines. Set acceptContentLoss to write anyway. Omit this param and nothing extra is spent. It is purely a text comparison and makes NO claim that either draft replaced the other \u2014 for that verdict use gog_gmail_drafts_diff."),
+      acceptContentLoss: external_exports.boolean().optional().describe("Write even though the forkSiblingDraftId check found lines your body drops \u2014 or could not be run at all (sibling unfetchable/unreadable). Without it either outcome refuses the write and changes nothing. The lines are still reported on the result under contentLossCheck. Ignored when forkSiblingDraftId is not set.")
+    }
+  }, async ({ draftId, account, returnFull, clearAttachments, clearReplyContext, forkSiblingDraftId, acceptContentLoss, ...flags }) => {
+    let check2;
+    let overridden = false;
+    if (forkSiblingDraftId) {
+      check2 = await checkSiblingContentLoss(forkSiblingDraftId, flags.body, account);
+      if (check2.status !== "clean" && !acceptContentLoss) return contentLossRefusal(draftId, check2);
+      overridden = check2.status !== "clean";
     }
-  }, async ({ draftId, account, returnFull, clearAttachments, clearReplyContext, ...flags }) => {
     const args = ["gmail", "drafts", "update", draftId];
     appendDraftFlags(args, flags);
     if (clearAttachments) args.push("--clear-attachments");
     if (clearReplyContext) args.push("--clear-reply-context");
-    return writeDraft(args, account, returnFull, draftId);
+    const intent = threadingIntentOf({ ...flags, clearReplyContext });
+    const result = await writeDraft(args, account, returnFull, draftId, intent);
+    const reported = await forkAwareDraftFailure(
+      result,
+      "gog_gmail_drafts_update",
+      draftId,
+      account,
+      intent?.requested === "set" ? { via: intent.via, target: intent.target } : void 0
+    );
+    if (check2 !== void 0 && overridden) {
+      check2 = reported.isError === true ? {
+        ...check2,
+        acknowledged: true,
+        written: false,
+        note: `${check2.note} acceptContentLoss was set, so the write was ATTEMPTED \u2014 but it FAILED and NOTHING WAS SAVED. Draft ${draftId} is unchanged and the lines listed above still exist in draft ${check2.siblingDraftId}; nothing was lost by this call. Read the error above before retrying.`
+      } : {
+        ...check2,
+        acknowledged: true,
+        written: true,
+        note: `${check2.note} acceptContentLoss was set, so the update WAS written despite this: draft ${draftId} now holds only the body you passed, and the lines listed above exist only in draft ${check2.siblingDraftId}.`
+      };
+    }
+    return check2 ? withContentLossCheck(reported, check2) : reported;
   });
   server.registerTool("gog_gmail_drafts_delete", {
     description: "Permanently delete a Gmail draft (not reversible \u2014 drafts do not go to Trash). Requires force:true to delete non-interactively.",
@@ -33024,14 +33979,15 @@ function registerExtraGmailTools(server) {
     return runOrDiagnose(args, { account });
   });
   server.registerTool("gog_gmail_drafts_send", {
-    description: "Send an existing Gmail draft.",
+    description: "Send an existing Gmail draft. If the id no longer resolves, the 404 comes back as a DRAFT_FORKED report \u2014 what happened, the drafts that do exist (with their free origin/rootsOwnThread fields) and what to do next \u2014 rather than a bare notFound. It names no replacement: that judgement needs a named pair and gog_gmail_drafts_diff. If the draft turns out to be still listed, the answer is GOOGLE_404_NOT_THE_DRAFT instead and claims no fork at all.",
     annotations: { destructiveHint: true },
     inputSchema: {
       draftId: external_exports.string().describe("Draft ID to send"),
       account: accountParam
     }
   }, async ({ draftId, account }) => {
-    return runOrDiagnose(["gmail", "drafts", "send", draftId], { account });
+    const result = await runOrDiagnose(["gmail", "drafts", "send", draftId], { account });
+    return forkAwareDraftFailure(result, "gog_gmail_drafts_send", draftId, account);
   });
   server.registerTool("gog_gmail_import", {
     description: "Import an existing RFC822/EML message INTO the mailbox. This is Gmail's import path, not a send: nothing leaves the account, and the message keeps its own From/Date/Message-Id headers so it files where it belongs chronologically. Use it to restore an exported message or to file a .eml under a label; to actually send mail use gog_gmail_send, and to stage one use gog_gmail_drafts_create. The file is read on the gog SERVER, not your machine.",
@@ -33045,7 +34001,7 @@ function registerExtraGmailTools(server) {
     }
   }, async ({ file: file2, labels, internalDateSource, neverMarkSpam, processForCalendar, account }) => {
     const args = ["gmail", "import", file2];
-    if (labels) for (const label of labels) args.push(`--label=${label}`);
+    if (labels) for (const label2 of labels) args.push(`--label=${label2}`);
     if (internalDateSource) args.push(`--internal-date-source=${internalDateSource}`);
     if (neverMarkSpam) args.push("--never-mark-spam");
     if (processForCalendar) args.push("--process-for-calendar");
@@ -33146,7 +34102,7 @@ function registerExtraGmailTools(server) {
       allowSelf: external_exports.boolean().optional().describe("Allow replying to messages sent by your own address"),
       account: accountParam
     }
-  }, async ({ query, max, subject, body, bodyHtml, from, replyTo, label, archive, markRead, skipBulk, allowSelf, account }) => {
+  }, async ({ query, max, subject, body, bodyHtml, from, replyTo, label: label2, archive, markRead, skipBulk, allowSelf, account }) => {
     const args = ["gmail", "autoreply", query];
     if (max !== void 0) args.push(`--max=${max}`);
     if (subject) args.push(`--subject=${subject}`);
@@ -33154,7 +34110,7 @@ function registerExtraGmailTools(server) {
     if (bodyHtml) args.push(`--body-html=${bodyHtml}`);
     if (from) args.push(`--from=${from}`);
     if (replyTo) args.push(`--reply-to=${replyTo}`);
-    if (label) args.push(`--label=${label}`);
+    if (label2) args.push(`--label=${label2}`);
     if (archive) args.push("--archive");
     if (markRead) args.push("--mark-read");
     if (skipBulk) args.push("--skip-bulk");