fix(google-calendar): cancelling an event now actually cancels it

Setting an event link's status to "Cancelled" only updated the local
status field — the event stayed live on Google Calendar and kept
appearing in the agenda, since Google's next sync would just report it
as confirmed again.

Add onLinkUpdated to delete the event via the Calendar API when its
status changes to "Cancelled" (covers both a standalone event and a
single occurrence of a recurring series). The resulting cancellation
then flows back through the existing incremental-sync path the same
way an externally-cancelled event does.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: KrisBraun

connectors/google-calendar/src/google-calendar.ts

@@ -3,6 +3,7 @@ import {
   type Actor,
   type ActorId,
   Connector,
+  type Link,
   type Thread,
   type ToolBuilder,
 } from "@plotday/twister";
@@ -27,6 +28,7 @@ import {
 } from "./channels";
 import {
   SYNC_LOCK_TTL_MS,
+  cancelEventWithApiFn,
   clearBuffersFn,
   extractRSVPParamsFn,
   getApiFn,
@@ -642,6 +644,38 @@ export class GoogleCalendar extends Connector<GoogleCalendar> {
       });
     }
   }
+
+  /**
+   * Called when a user changes an event link's status in Plot. Only
+   * "Cancelled" write-backs here: "Confirmed"/"Tentative" just mirror
+   * Google's own `event.status` and aren't meaningfully user-settable for
+   * events you organize. Deleting the event (rather than PATCHing
+   * status=cancelled, which Google only documents as reliable for
+   * recurring instance exceptions) mirrors how a real cancellation arrives
+   * from Google, so the next incremental sync's already-tested
+   * cancellation path archives the schedule and removes it from the
+   * agenda. Best-effort: a failed write-back is reconciled by the user
+   * retrying the status change.
+   */
+  async onLinkUpdated(link: Link): Promise<void> {
+    if (link.status !== "Cancelled") return;
+
+    const calendarId = link.channelId;
+    const eventId = (link.meta as Record<string, unknown> | null)?.id as
+      | string
+      | undefined;
+    if (!calendarId || !eventId) return;
+
+    try {
+      const api = await this.getApi(calendarId);
+      await cancelEventWithApiFn(api, calendarId, eventId);
+    } catch (error) {
+      console.error("[GoogleCalendar] onLinkUpdated write-back failed:", {
+        event_id: eventId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
 }
 
 export default GoogleCalendar;

connectors/google-calendar/src/sync.test.ts

@@ -10,6 +10,7 @@ import type { NewLinkWithNotes } from "@plotday/twister";
 import type { Thread } from "@plotday/twister";
 import type { CalendarSyncHost } from "./sync";
 import {
+  cancelEventWithApiFn,
   cancellationWasSelfInitiatedFn,
   extractRSVPParamsFn,
   getWatchRenewalScheduleFn,
@@ -780,6 +781,45 @@ describe("updateEventRSVPWithApiFn", () => {
   });
 });
 
+describe("cancelEventWithApiFn", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it("issues a DELETE against the event's own calendar/eventId", async () => {
+    const calendarId = "user@example.com";
+    const eventId = "event-abc";
+
+    const fetchSpy = vi.fn(async (url: string, init?: RequestInit) => {
+      if (
+        url ===
+          `https://www.googleapis.com/calendar/v3/calendars/${calendarId}/events/${eventId}` &&
+        init?.method === "DELETE"
+      ) {
+        return new Response(null, { status: 204 });
+      }
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+    vi.stubGlobal("fetch", fetchSpy);
+
+    const api = new GoogleApi("fake-token");
+    await cancelEventWithApiFn(api, calendarId, eventId);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("is a no-op (doesn't throw) when the event is already gone", async () => {
+    const calendarId = "user@example.com";
+    const eventId = "event-already-deleted";
+
+    const fetchSpy = vi.fn(async () => new Response(null, { status: 410 }));
+    vi.stubGlobal("fetch", fetchSpy);
+
+    const api = new GoogleApi("fake-token");
+    await expect(
+      cancelEventWithApiFn(api, calendarId, eventId)
+    ).resolves.toBeUndefined();
+  });
+});
+
 describe("setupCalendarWatchFn", () => {
   afterEach(() => vi.unstubAllGlobals());
 

connectors/google-calendar/src/sync.ts

@@ -1603,6 +1603,24 @@ export async function updateEventRSVPWithApiFn(
   );
 }
 
+/**
+ * Cancels a Google Calendar event by deleting it. Works uniformly for a
+ * standalone/master event and a single occurrence of a recurring series —
+ * both are addressed by their own `eventId`, and Google reports a deleted
+ * occurrence as a cancelled exception on the next sync rather than removing
+ * the series. `GoogleApi.call` treats 410 (already gone) as a no-op.
+ */
+export async function cancelEventWithApiFn(
+  api: GoogleApi,
+  calendarId: string,
+  eventId: string
+): Promise<void> {
+  await api.call(
+    "DELETE",
+    `https://www.googleapis.com/calendar/v3/calendars/${calendarId}/events/${eventId}`
+  );
+}
+
 /**
  * Parameters extracted from a thread for an RSVP write-back.
  *