fix(google): keep a retried response's unread state matching the first pass

The retry omitted `unread` entirely, so a response folded late defaulted to
unread — including an acceptance, which the first pass deliberately leaves
read, and including responses first seen during the initial backfill, where
nothing should be marked unread at all. A late fold was therefore noisier
than a timely one.

Carry the originating pass's `initialSync` on the pending entry and run the
same `shouldMarkUnread` rule on retry.

Author: KrisBraun

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

@@ -1223,6 +1223,50 @@ describe("drainPendingRsvpsFn — retract once the event arrives", () => {
     expect(store.has("pending-rsvp:rsvp-late")).toBe(false);
   });
 
+  it("applies the same unread rule the first pass would have", async () => {
+    const { host, store } = makeHost();
+    const { notes } = captureSaves(host, { noteId: "N" });
+    const declined = rsvpThread("rsvp-late", replyIcs("DECLINED"));
+    store.set("pending-rsvp:rsvp-late", {
+      threadId: "rsvp-late",
+      channelId: "INBOX",
+      initialSync: false,
+      firstSeen: new Date().toISOString(),
+    });
+    (host.tools.store.list as ReturnType<typeof vi.fn>).mockImplementation(
+      async (prefix: string) =>
+        [...store.keys()].filter((k) => k.startsWith(prefix))
+    );
+    vi.spyOn(GmailApi.prototype, "getThread").mockResolvedValue(declined);
+
+    await drainPendingRsvpsFn(host);
+
+    // A decline is worth surfacing; an acceptance is not. Retrying must not
+    // change that, or a late fold is noisier than a timely one.
+    expect(notes[0]).toMatchObject({ unread: true });
+  });
+
+  it("leaves a response first seen during the initial backfill read", async () => {
+    const { host, store } = makeHost();
+    const { notes } = captureSaves(host, { noteId: "N" });
+    const declined = rsvpThread("rsvp-late", replyIcs("DECLINED"));
+    store.set("pending-rsvp:rsvp-late", {
+      threadId: "rsvp-late",
+      channelId: "INBOX",
+      initialSync: true,
+      firstSeen: new Date().toISOString(),
+    });
+    (host.tools.store.list as ReturnType<typeof vi.fn>).mockImplementation(
+      async (prefix: string) =>
+        [...store.keys()].filter((k) => k.startsWith(prefix))
+    );
+    vi.spyOn(GmailApi.prototype, "getThread").mockResolvedValue(declined);
+
+    await drainPendingRsvpsFn(host);
+
+    expect(notes[0].unread).toBeUndefined();
+  });
+
   it("keeps the entry and archives nothing while the event is still missing", async () => {
     const { host, store } = makeHost();
     captureSaves(host, { noteId: null });

connectors/google/src/mail/sync.ts

@@ -1518,6 +1518,12 @@ type PendingRsvp = {
    */
   threadId: string;
   channelId: string;
+  /**
+   * Whether the response was first seen during the initial backfill. Carried
+   * so the retry applies the same unread rule the first pass would have — a
+   * late fold must not be noisier than a timely one.
+   */
+  initialSync: boolean;
   /** ISO timestamp of the first failed fold, for {@link PENDING_RSVP_TTL_MS}. */
   firstSeen: string;
 };
@@ -1577,6 +1583,9 @@ export async function drainPendingRsvpsFn(host: GmailSyncHost): Promise<void> {
             email: reply.attendeeEmail,
             ...(reply.attendeeName ? { name: reply.attendeeName } : {}),
           },
+          ...(shouldMarkUnread(reply, pending.initialSync)
+            ? { unread: true }
+            : {}),
         });
         if (!noteId) allFolded = false;
       }
@@ -1695,6 +1704,7 @@ async function saveTransformedThread(
         await host.set(key, {
           threadId: thread.id,
           channelId,
+          initialSync,
           // Preserved across passes so the retry window measures from the
           // first failure, not from the most recent re-sync of the thread.
           firstSeen: existing?.firstSeen ?? new Date().toISOString(),