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

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.
  *

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.
  *

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.
  *

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.
  *

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.
  *

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.
  *

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.
  *

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.
  *