fix(gmail): exclude dot/plus variants of your own address from reply-all

Gmail ignores dots and anything after "+" in the local part of an address,
so mail addressed to a dotless or tagged variant of your own address (e.g.
"johndoe@gmail.com" vs the connected "john.doe@gmail.com") lands in the same
inbox. Replying to such a thread compared addresses literally, so the variant
wasn't recognized as "you" and was included as an outbound recipient —
sending you your own reply as if it were a new message from someone else.

Reply recipient resolution now canonicalizes Gmail/Googlemail addresses
(lowercase, dots and +tag stripped) before checking whether a header address
belongs to the connected mailbox.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013bZaWo6FPSsSNL5MhE5umC

Author: KrisBraun

connectors/google/src/mail/gmail-api.test.ts

@@ -4,6 +4,7 @@ import {
   buildForwardMessage,
   buildNewEmailMessage,
   buildReplyMessage,
+  canonicalizeGmailAddress,
   classifyCalendarThread,
   formatFromHeader,
   stripQuotedReply,
@@ -669,3 +670,36 @@ describe("classifyCalendarThread", () => {
     expect(classifyCalendarThread([msgWithIcs(icsReply)])).toBeNull();
   });
 });
+
+describe("canonicalizeGmailAddress", () => {
+  it("strips dots from the local part of a gmail.com address", () => {
+    expect(canonicalizeGmailAddress("kris.braun@gmail.com")).toBe(
+      "krisbraun@gmail.com"
+    );
+    expect(canonicalizeGmailAddress("krisbraun@gmail.com")).toBe(
+      "krisbraun@gmail.com"
+    );
+  });
+
+  it("strips a +tag suffix from the local part", () => {
+    expect(canonicalizeGmailAddress("kris.braun+updates@gmail.com")).toBe(
+      "krisbraun@gmail.com"
+    );
+  });
+
+  it("normalizes googlemail.com to the same canonical form as gmail.com", () => {
+    expect(canonicalizeGmailAddress("kris.braun@googlemail.com")).toBe(
+      "krisbraun@gmail.com"
+    );
+  });
+
+  it("lowercases but otherwise leaves non-Gmail domains untouched", () => {
+    expect(canonicalizeGmailAddress("Kris.Braun@Example.com")).toBe(
+      "kris.braun@example.com"
+    );
+  });
+
+  it("returns the lowercased input unchanged when there's no @", () => {
+    expect(canonicalizeGmailAddress("not-an-email")).toBe("not-an-email");
+  });
+});

connectors/google/src/mail/gmail-api.ts

@@ -536,6 +536,27 @@ export function splitEmailList(headerValue: string): string[] {
   return parts;
 }
 
+/**
+ * Canonicalizes a Gmail/Googlemail address for self-identity comparison.
+ * Gmail treats dots in the local part and anything after a `+` as
+ * insignificant for delivery — `kris.braun@gmail.com`, `krisbraun@gmail.com`,
+ * and `kris.braun+tag@gmail.com` all route to the same mailbox — but message
+ * headers preserve whichever exact variant was used to address the mail. A
+ * literal string comparison against the account's canonical address (as
+ * returned by the Gmail API) therefore misses these variants, letting the
+ * user's own address survive into an outbound reply-all as if it were a
+ * distinct recipient. Non-Gmail domains are returned lowercased, unchanged.
+ */
+export function canonicalizeGmailAddress(email: string): string {
+  const lower = email.trim().toLowerCase();
+  const at = lower.lastIndexOf("@");
+  if (at === -1) return lower;
+  const domain = lower.slice(at + 1);
+  if (domain !== "gmail.com" && domain !== "googlemail.com") return lower;
+  const local = lower.slice(0, at).split("+")[0]!.replace(/\./g, "");
+  return `${local}@gmail.com`;
+}
+
 /**
  * Parses a comma-separated email header value into an array of email address strings.
  * Skips entries that are not valid email addresses (e.g. "undisclosed-recipients:;").

connectors/google/src/mail/sync.test.ts

@@ -446,6 +446,86 @@ describe("onNoteCreatedFn — calendar event thread", () => {
   });
 });
 
+/** A plain (non-calendar) Gmail thread whose sole message addressed the
+ *  connected mailbox via a dot-variant of its own address. */
+function gmailAliasReplyThread(): GmailThread {
+  const message: GmailMessage = {
+    id: "msg-orig-1",
+    threadId: "gmail-thread-1",
+    labelIds: ["INBOX"],
+    snippet: "Hi Kris",
+    historyId: "1",
+    internalDate: "1700000000000",
+    sizeEstimate: 100,
+    payload: {
+      mimeType: "text/plain",
+      headers: [
+        { name: "Message-ID", value: "<orig@mail.gmail.com>" },
+        { name: "From", value: "Hilary Collier <hilary.collier@example.com>" },
+        { name: "To", value: "krisbraun@gmail.com" },
+        { name: "Cc", value: "annie@example.com" },
+        { name: "Subject", value: "Surprise Tribute Video" },
+      ],
+      body: { size: 10, data: b64url("Hi Kris") },
+    },
+  };
+  return { id: "gmail-thread-1", historyId: "1", messages: [message] };
+}
+
+function plainThread(over: Record<string, unknown> = {}) {
+  return {
+    id: "T2",
+    title: "Surprise Tribute Video",
+    meta: { channelId: "INBOX", threadId: "gmail-thread-1" },
+    accessContacts: [
+      { id: "c-me", email: "kris.braun@gmail.com" },
+      { id: "c-hilary", email: "hilary.collier@example.com" },
+      { id: "c-annie", email: "annie@example.com" },
+    ],
+    ...over,
+  } as unknown as import("@plotday/twister").Thread;
+}
+
+function plainReplyNote(over: Record<string, unknown> = {}) {
+  return {
+    id: "n2",
+    author: { id: "c-me" },
+    content: "Sounds good!",
+    recipients: null,
+    accessContacts: null,
+    actions: [],
+    ...over,
+  } as unknown as import("@plotday/twister").Note;
+}
+
+describe("onNoteCreatedFn — plain Gmail thread reply-all", () => {
+  it("excludes the connected mailbox's own dot-variant alias address from the outbound recipients", async () => {
+    vi.spyOn(GmailApi.prototype, "getThread").mockResolvedValue(
+      gmailAliasReplyThread()
+    );
+    // The account's canonical/connected address (with dot) never literally
+    // matches the alias form the original message was addressed to
+    // (krisbraun@gmail.com) — Gmail treats both as the same mailbox.
+    vi.spyOn(GmailApi.prototype, "getProfile").mockResolvedValue({
+      emailAddress: "kris.braun@gmail.com",
+    });
+    vi.spyOn(GmailApi.prototype, "getUserInfo").mockResolvedValue({
+      email: "kris.braun@gmail.com",
+    });
+    const send = vi
+      .spyOn(GmailApi.prototype, "sendMessage")
+      .mockResolvedValue({ id: "sent-9", threadId: "gmail-thread-1" });
+    const { host } = makeHost();
+
+    await onNoteCreatedFn(host, plainReplyNote(), plainThread());
+
+    expect(send).toHaveBeenCalledTimes(1);
+    const raw = decodeRawMessage(send.mock.calls[0][0]);
+    expect(raw).not.toContain("krisbraun@gmail.com");
+    expect(raw).toContain("hilary.collier@example.com");
+  });
+});
+
 /** Build a GmailMessagePart, encoding `data` as base64url like the real API. */
 function part(
   mimeType: string,

connectors/google/src/mail/sync.ts

@@ -47,6 +47,7 @@ import {
   buildForwardMessage,
   buildNewEmailMessage,
   buildReplyMessage,
+  canonicalizeGmailAddress,
   classifyCalendarThread,
   collectAttachments,
   extractBody,
@@ -1694,6 +1695,18 @@ export async function onNoteCreatedFn(
   )?.email;
   if (authorEmail) selfEmails.add(authorEmail.toLowerCase());
 
+  // Gmail ignores dots and anything after "+" in the local part, so a header
+  // may address the user via a variant that never string-matches selfEmails
+  // (e.g. "krisbraun@gmail.com" vs the connected "kris.braun@gmail.com").
+  // Compare header candidates against the canonical form of every self
+  // address, in addition to the exact-match `selfEmails` set the shared
+  // helper below still uses for the access-contact/reply-all cases.
+  const selfCanonical = new Set(
+    Array.from(selfEmails, canonicalizeGmailAddress)
+  );
+  const isSelfAddress = (email: string) =>
+    selfEmails.has(email) || selfCanonical.has(canonicalizeGmailAddress(email));
+
   // Fallback access constraint (used only when the runtime didn't resolve
   // note.recipients): resolve the note's access list to lowercased emails.
   let accessContactEmails: Set<string> | null = null;
@@ -1707,7 +1720,9 @@ export async function onNoteCreatedFn(
     }
   }
 
-  // Original-message participants: From ∪ To → To, Cc → Cc.
+  // Original-message participants: From ∪ To → To, Cc → Cc. Self-address
+  // variants (see isSelfAddress above) are dropped here so they never reach
+  // the shared recipient resolver below.
   const fromToCandidates = new Set<string>();
   for (const email of parseEmailAddresses(fromHeader)) {
     fromToCandidates.add(email.toLowerCase());
@@ -1720,7 +1735,7 @@ export async function onNoteCreatedFn(
     ccCandidates.add(email.toLowerCase());
   }
   const toCandidates = Array.from(fromToCandidates).filter(
-    (email) => !ccCandidates.has(email)
+    (email) => !ccCandidates.has(email) && !isSelfAddress(email)
   );
 
   // Resolve the outbound recipients via the shared helper: prefer the runtime's
@@ -1731,7 +1746,7 @@ export async function onNoteCreatedFn(
     recipients: note.recipients ?? null,
     accessContactEmails,
     headerTo: toCandidates,
-    headerCc: Array.from(ccCandidates),
+    headerCc: Array.from(ccCandidates).filter((email) => !isSelfAddress(email)),
     selfEmails,
   });