@mulmoclaude/core 5.1.0 → 5.3.0

package/dist/feeds/server/index.cjs

@@ -4,8 +4,8 @@ const require_dist = require("../../dist-Gj7ygaW2.cjs");
 const require_root = require("../../root-BvwBUcol.cjs");
 const require_itemId = require("../../itemId-CGT2J7YK.cjs");
 const require_project = require("../../project-C1ep9pvo.cjs");
-const require_discovery = require("../../discovery-DCMW05Bp.cjs");
-const require_server = require("../../server-rA9FSkl2.cjs");
+const require_discovery = require("../../discovery-CDXYswtw.cjs");
+const require_server = require("../../server-DfYwSX8b.cjs");
 const require_feeds_paths = require("../paths.cjs");
 const require_ingestTypes = require("../../ingestTypes-DsVH9BYy.cjs");
 const require_notifier = require("../../notifier-B65Mvngb.cjs");

package/dist/feeds/server/index.js

@@ -2,8 +2,8 @@ import { a as isErrorWithCode, l as isUnknownArray, s as isRecord$1 } from "../.
 import { t as canonicalRoot } from "../../root-BcS4-Kge.js";
 import { G as INGEST_KINDS, W as FEED_SCHEDULES } from "../../itemId-4P9S_ehz.js";
 import { t as mergeIntoExisting } from "../../project-B0j_Vf_Q.js";
-import { W as resolveDataDir, _t as createForwardingLogger, d as storeFor, k as listItems, n as discoverCollections, q as safeSlugName, vt as createHostSlot } from "../../discovery-CBjI1lx9.js";
-import { F as buildCollectionActionSeedPrompt, I as promptPathsFor, z as readSkillTemplate } from "../../server-BMZ_BcPH.js";
+import { W as resolveDataDir, _t as createForwardingLogger, d as storeFor, k as listItems, n as discoverCollections, q as safeSlugName, vt as createHostSlot } from "../../discovery-B_64PBZU.js";
+import { F as buildCollectionActionSeedPrompt, I as promptPathsFor, z as readSkillTemplate } from "../../server-7POrhHKv.js";
 import { FEEDS_DIR, feedDir, feedStatePath, feedsRoot, ingestStateDir, ingestStatePath } from "../paths.js";
 import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-GkG7bJdB.js";
 import { d as publish, n as clear } from "../../notifier-vAp5t6wL.js";

package/dist/google/calendar.d.ts

@@ -1,3 +1,8 @@
+/** A GET or DELETE on an event that is not there. Exported because the push's
+ *  delete sweep has to read "already gone" as success, not as a failure to
+ *  retry — a retained baseline would announce the same phantom deletion on
+ *  every run. */
+export declare const EVENT_ABSENT_STATUSES: readonly number[];
 /** An `If-Match` write whose etag no longer matches — someone else changed the
  *  event since it was read. */
 export declare const HTTP_PRECONDITION_FAILED = 412;
@@ -74,6 +79,12 @@ export interface UpdateCalendarEventInput {
 export interface DeleteCalendarEventInput {
     eventId: string;
     calendarId?: string | undefined;
+    /** Etag of the version this decision was made against. Sent as `If-Match`, so
+     *  Google answers 412 rather than removing an event that changed after it was
+     *  read — the same guard `updateCalendarEvent` takes, and it matters more
+     *  here: a delete cannot be undone from this side. Omit for an unconditional
+     *  delete. */
+    ifMatch?: string | undefined;
 }
 export interface ListEventsInput {
     timeMin?: string | undefined;
@@ -117,6 +128,14 @@ export interface CalendarEventSummary {
     eventType: string;
     /** Google Meet URL, "" when nothing is attached. */
     hangoutLink: string;
+    /** The signed-in user's own `responseStatus`, folded out of `attendees`.
+     *  `""` when Google reported none — which is every event that HAS no
+     *  attendees, so it reads as "nothing said", never as "not going". */
+    selfResponseStatus: string;
+    /** The URL that joins this event's meeting, folded out of
+     *  `conferenceData.entryPoints`. Covers the conferences `hangoutLink` does
+     *  not: Zoom, Teams, anything attached as conference data. */
+    conferenceVideoUri: string;
 }
 export interface CalendarSummary {
     id: string;
@@ -166,6 +185,11 @@ export interface FetchedCalendarEvent {
     /** Google's `etag` for this version, `""` when absent. Sent back as
      *  `If-Match` so a PATCH cannot overwrite a version we never read. */
     etag: string;
+    /** How many people the event lists, `0` for a solo one. Carried here rather
+     *  than on the summary because only the delete guard reads it, and it is the
+     *  one thing that guard cannot get from the record — by then the record is
+     *  gone (`deletePlan.ts`). */
+    attendeeCount: number;
 }
 /** Read ONE event, or null when it is gone (404 / 410).
  *

package/dist/google/collectionPush.d.ts

@@ -1,6 +1,6 @@
 import { LoadedCollection } from '../collection/server/discoveredCollection.js';
 import { CollectionFieldSpec, CollectionItem } from '../collection/core/schema.js';
-import { CalendarEventSummary } from './calendar.js';
+import { deleteCalendarEvent, getCalendarEvent, CalendarEventSummary } from './calendar.js';
 import { ShadowEvent } from './calendarPushState.js';
 import { PushableSourceField } from './pushPlan.js';
 /** What the up-front writability gate knows about the target calendar. */
@@ -31,8 +31,12 @@ export interface CalendarCollectionPushResult {
     updated: number;
     /** Edited on both sides; skipped so neither version is destroyed. */
     conflicts: number;
-    /** Records deleted locally. Reported only — v1 never deletes in Google. */
+    /** Records deleted locally. Reported whether or not the deletion carried, so
+     *  the count still answers "how many rows went away here". */
     localDeletes: number;
+    /** Of those, how many were deleted in Google too. Always `0` unless the
+     *  collection opted in with `propagateDeletes` (#3234). */
+    deletedInGoogle: number;
     /** Records that cannot be pushed as they stand, each with the reason. */
     skipped: string[];
     errors: string[];
@@ -72,6 +76,15 @@ export interface CalendarPushDeps {
     isLinked: () => Promise<boolean>;
     accessToken: () => Promise<string>;
     calendarMeta: (accessToken: string, calendarId: string | undefined) => Promise<CalendarWriteTarget>;
+    /** Read and write for the delete guard. Injected like the rest so a test can
+     *  exercise "this event has attendees" without a grant (#3234).
+     *
+     *  OPTIONAL, unlike the rest: `CalendarPushDeps` is an exported type, and a
+     *  deps object written before these existed must keep satisfying it — the
+     *  more so because a collection that never opted into `propagateDeletes`
+     *  cannot reach either of them. Absent means the live implementation. */
+    fetchEvent?: typeof getCalendarEvent;
+    deleteEvent?: typeof deleteCalendarEvent;
 }
 type PushOutcome = {
     kind: "created";
@@ -114,6 +127,36 @@ export declare function locallyEditedIds(records: readonly CollectionItem[], sha
  *  from the stored baseline alone, so it works precisely when Google is the
  *  thing that is unreachable. */
 export declare function unsentLocalEdits(collection: LoadedCollection, workspaceRoot: string): Promise<string[]>;
+/** What one run's deletions did. `seen` counts every record that went away
+ *  locally, whether or not the deletion carried — so the count means the same
+ *  thing with the feature off as it always did. */
+export interface DeleteSweep {
+    seen: number;
+    deleted: string[];
+    skipped: string[];
+    errors: string[];
+}
+/** What `sweepDeletes` needs, narrowed to the three effects it has. Taken as an
+ *  argument rather than reached for, so the guard can be exercised against
+ *  "this event has attendees" with no grant and no workspace. */
+export interface DeleteSweepDeps {
+    /** What Google currently holds for the event, or null when it is gone. The
+     *  `etag` is the version the decision was made against. */
+    fetchEvent: (eventId: string) => Promise<{
+        attendeeCount: number;
+        etag: string;
+    } | null>;
+    /** Delete it, conditional on that version. */
+    deleteEvent: (eventId: string, ifMatch: string) => Promise<void>;
+    /** Drop the event's baseline entry. */
+    forget: (eventId: string) => Promise<void>;
+}
+/** Carry every local deletion, when the collection opted in.
+ *
+ *  Sequential rather than concurrent: each one writes the shared baseline file,
+ *  and an interrupted run has to leave a state the next run resumes from rather
+ *  than a partially applied batch. */
+export declare function sweepDeletes(eventIds: readonly string[], propagate: boolean, deps: DeleteSweepDeps): Promise<DeleteSweep>;
 /** Push one collection WITHOUT taking the calendar lock.
  *
  *  The caller must already hold it. The scheduled push→pull cycle

package/dist/google/deletePlan.d.ts

@@ -0,0 +1,32 @@
+/** Why an event was left in Google although its record is gone. */
+export type DeleteRefusal = {
+    kind: "has-attendees";
+} | {
+    kind: "already-gone";
+};
+/** An approval carries the version it was made against, so the delete can be
+ *  conditional on it. Keeping the two together is what stops a caller deleting
+ *  against a version the guard never saw. */
+export type DeleteDecision = {
+    ok: true;
+    etag: string;
+} | ({
+    ok: false;
+} & DeleteRefusal);
+/** The message the push reports for a refusal, with the event named. */
+export declare const deleteRefusalMessage: (eventId: string, refusal: DeleteRefusal) => string;
+/** Decide one deletion against what Google currently holds.
+ *
+ *  `null` means the event is already absent — a 404/410 on the read. Nothing to
+ *  delete, and reported apart from a refusal so "we chose not to" never reads
+ *  as "we could not".
+ *
+ *  ANY attendee refuses, including the entry Google adds for the organiser. A
+ *  rule that tried to exclude "only me" would have to work out which entry is
+ *  the user from a payload that may not say, and being wrong there withdraws a
+ *  real invitation. Solo events — the ones this feature exists for — carry no
+ *  attendees at all, so the blunt rule costs them nothing. */
+export declare function planDelete(fetched: {
+    attendeeCount: number;
+    etag: string;
+} | null): DeleteDecision;

package/dist/google/eventDerived.d.ts

@@ -0,0 +1,19 @@
+/** The signed-in user's own `responseStatus` on this event, `""` when Google
+ *  reported none.
+ *
+ *  `""` is the common case, not an edge one: an event with no attendees has no
+ *  entry to mark `self`, which is most of a personal calendar. So it means
+ *  "Google said nothing", never "not going" — filter with `!= "declined"`, not
+ *  with `== "accepted"`, or every solo event disappears too.
+ *
+ *  Google's values: `needsAction`, `declined`, `tentative`, `accepted`. */
+export declare function selfResponseStatus(attendees: unknown): string;
+/** The URL that joins this event's meeting, `""` when it has none.
+ *
+ *  Only the `video` entry point. The others are a phone number and a dial-in
+ *  PIN page, and a column named for joining that sometimes holds `tel:` would
+ *  be worse than one that is empty — the caller can see empty and fall back.
+ *
+ *  `hangoutLink` (#3229) already carries this for Google Meet; this is what
+ *  reaches the events whose conference is Zoom or Teams. */
+export declare function conferenceVideoUri(conferenceData: unknown): string;

package/dist/google/index.cjs

@@ -7,7 +7,7 @@ const require_root = require("../root-BvwBUcol.cjs");
 const require_utils_fetch = require("../utils/fetch.cjs");
 const require_itemId = require("../itemId-CGT2J7YK.cjs");
 const require_project = require("../project-C1ep9pvo.cjs");
-const require_discovery = require("../discovery-DCMW05Bp.cjs");
+const require_discovery = require("../discovery-CDXYswtw.cjs");
 const require_paths = require("../paths-C8-jxR0s.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -45,6 +45,74 @@ var isIsoDateTimeWithOffset = (value) => {
 	return isRealCalendarDate(year, month, day) && timeInRange && offsetInRange;
 };
 //#endregion
+//#region src/google/deletePlan.ts
+var ATTENDEES_REASON = "it carries attendees — deleting an invited event withdraws it from their calendars too";
+var ALREADY_GONE_REASON = "it is no longer in Google";
+/** The message the push reports for a refusal, with the event named. */
+var deleteRefusalMessage = (eventId, refusal) => `${eventId}: left in Google because ${refusal.kind === "has-attendees" ? ATTENDEES_REASON : ALREADY_GONE_REASON}`;
+/** Decide one deletion against what Google currently holds.
+*
+*  `null` means the event is already absent — a 404/410 on the read. Nothing to
+*  delete, and reported apart from a refusal so "we chose not to" never reads
+*  as "we could not".
+*
+*  ANY attendee refuses, including the entry Google adds for the organiser. A
+*  rule that tried to exclude "only me" would have to work out which entry is
+*  the user from a payload that may not say, and being wrong there withdraws a
+*  real invitation. Solo events — the ones this feature exists for — carry no
+*  attendees at all, so the blunt rule costs them nothing. */
+function planDelete(fetched) {
+	if (fetched === null) return {
+		ok: false,
+		kind: "already-gone"
+	};
+	return fetched.attendeeCount > 0 ? {
+		ok: false,
+		kind: "has-attendees"
+	} : {
+		ok: true,
+		etag: fetched.etag
+	};
+}
+//#endregion
+//#region src/google/util.ts
+var ONE_SECOND_MS = 1e3;
+var ONE_MINUTE_MS = 6e4;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/google/eventDerived.ts
+var stringAt = (record, key) => typeof record[key] === "string" ? record[key] : "";
+var recordsIn = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+/** The signed-in user's own `responseStatus` on this event, `""` when Google
+*  reported none.
+*
+*  `""` is the common case, not an edge one: an event with no attendees has no
+*  entry to mark `self`, which is most of a personal calendar. So it means
+*  "Google said nothing", never "not going" — filter with `!= "declined"`, not
+*  with `== "accepted"`, or every solo event disappears too.
+*
+*  Google's values: `needsAction`, `declined`, `tentative`, `accepted`. */
+function selfResponseStatus(attendees) {
+	const self = recordsIn(attendees).find((attendee) => attendee.self === true);
+	return self === void 0 ? "" : stringAt(self, "responseStatus");
+}
+var VIDEO_ENTRY_POINT = "video";
+/** The URL that joins this event's meeting, `""` when it has none.
+*
+*  Only the `video` entry point. The others are a phone number and a dial-in
+*  PIN page, and a column named for joining that sometimes holds `tel:` would
+*  be worse than one that is empty — the caller can see empty and fall back.
+*
+*  `hangoutLink` (#3229) already carries this for Google Meet; this is what
+*  reaches the events whose conference is Zoom or Teams. */
+function conferenceVideoUri(conferenceData) {
+	if (!isRecord(conferenceData)) return "";
+	const video = recordsIn(conferenceData.entryPoints).find((entry) => entry.entryPointType === VIDEO_ENTRY_POINT);
+	return video === void 0 ? "" : stringAt(video, "uri");
+}
+//#endregion
 //#region src/google/eventSpanInput.ts
 var DATE_ONLY_RE$1 = /^\d{4}-\d{2}-\d{2}$/;
 /** Whether `value` is a bare calendar day — the all-day spelling of an event
@@ -160,13 +228,6 @@ function googleSecretsDir(home) {
 	return (0, node_path.join)(home ?? (0, node_os.homedir)(), ".secrets");
 }
 //#endregion
-//#region src/google/util.ts
-var ONE_SECOND_MS = 1e3;
-var ONE_MINUTE_MS = 6e4;
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
 //#region src/google/clientSecret.ts
 var isNonEmptyString = (value) => typeof value === "string" && value !== "";
 var isInstalledClientSecret = (value) => {
@@ -697,6 +758,10 @@ var EVENT_SYNC_PAGE_SIZE = 2500;
 var MAX_EVENT_SYNC_PAGES = 200;
 var CALENDAR_META_PAGE_SIZE = 1;
 var HTTP_GONE = 410;
+/** A GET or DELETE on an event that is not there. Exported because the push's
+*  delete sweep has to read "already gone" as success, not as a failure to
+*  retry — a retained baseline would announce the same phantom deletion on
+*  every run. */
 var EVENT_ABSENT_STATUSES = [404, HTTP_GONE];
 /** An `If-Match` write whose etag no longer matches — someone else changed the
 *  event since it was read. */
@@ -714,6 +779,10 @@ var CANCELLED_EVENT_STATUS = "cancelled";
 *  apart while they share a sync token silently loses events (#2184). */
 var canonicalCalendarId = (calendarId) => calendarId || DEFAULT_CALENDAR_ID;
 var eventsUrl = (calendarId) => `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(canonicalCalendarId(calendarId))}/events`;
+/** People Google lists on the event, `0` when it carries none. Counts EVERY
+*  entry, including the one Google adds for the organiser: see `deletePlan.ts`
+*  for why the guard is not cleverer than that. */
+var attendeeCount = (record) => Array.isArray(record.attendees) ? record.attendees.length : 0;
 var eventTime$1 = (value) => {
 	if (!isRecord(value)) return "";
 	if (typeof value.dateTime === "string") return value.dateTime;
@@ -737,7 +806,9 @@ var toEventSummary = (value) => {
 		updated: stringField(record, "updated"),
 		transparency: stringField(record, "transparency"),
 		eventType: stringField(record, "eventType"),
-		hangoutLink: stringField(record, "hangoutLink")
+		hangoutLink: stringField(record, "hangoutLink"),
+		selfResponseStatus: selfResponseStatus(record.attendees),
+		conferenceVideoUri: conferenceVideoUri(record.conferenceData)
 	};
 };
 var toCalendarSummary = (value) => {
@@ -828,9 +899,11 @@ async function updateCalendarEvent(accessToken, input) {
 async function getCalendarEvent(accessToken, input) {
 	try {
 		const fetched = await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId));
+		const record = asRecord(fetched);
 		return {
 			event: toEventSummary(fetched),
-			etag: stringField(asRecord(fetched), "etag")
+			etag: stringField(record, "etag"),
+			attendeeCount: attendeeCount(record)
 		};
 	} catch (error) {
 		if (isGoogleApiError(error) && EVENT_ABSENT_STATUSES.includes(error.status)) return null;
@@ -841,7 +914,10 @@ async function getCalendarEvent(accessToken, input) {
 *  return; a second delete of the same id answers 410, which surfaces as a
 *  GoogleApiError rather than being swallowed. */
 async function deleteCalendarEvent(accessToken, input) {
-	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), { method: "DELETE" });
+	await googleRequest(CALENDAR_API_LABEL, accessToken, eventUrl(input.calendarId, input.eventId), {
+		method: "DELETE",
+		...input.ifMatch ? { extraHeaders: { "If-Match": input.ifMatch } } : {}
+	});
 }
 async function listCalendarEvents(accessToken, input = {}) {
 	const params = new URLSearchParams({
@@ -1623,7 +1699,9 @@ var UNPUSHABLE_EVENT_FIELDS = {
 	updated: "",
 	transparency: "",
 	eventType: "",
-	hangoutLink: ""
+	hangoutLink: "",
+	selfResponseStatus: "",
+	conferenceVideoUri: ""
 };
 /** A baseline shaped as the event it came from, so the comparison can run
 *  through the very projection that wrote the record. */
@@ -1744,7 +1822,9 @@ var liveDeps = {
 	findCollection: findCalendarCollection,
 	isLinked: async () => Boolean((await loadGoogleTokens())?.refresh_token),
 	accessToken: getGoogleAccessToken,
-	calendarMeta: liveCalendarMeta
+	calendarMeta: liveCalendarMeta,
+	fetchEvent: getCalendarEvent,
+	deleteEvent: deleteCalendarEvent
 };
 var localValue = (ctx, record, source) => {
 	const field = ctx.bySource[source];
@@ -1954,7 +2034,7 @@ var UNPUSHED_KINDS = ["conflict", "error"];
 /** Whether this outcome leaves a local edit that only exists locally, so the
 *  pull must not overwrite the record and the baseline must not advance. */
 var isUnpushed = (kind) => UNPUSHED_KINDS.includes(kind);
-function tally(slug, attempts, localDeletes) {
+function tally(slug, attempts, deletes) {
 	const outcomes = attempts.map((attempt) => attempt.outcome);
 	const count = (kind) => outcomes.filter((outcome) => outcome.kind === kind).length;
 	return {
@@ -1962,9 +2042,10 @@ function tally(slug, attempts, localDeletes) {
 		created: count("created"),
 		updated: count("updated"),
 		conflicts: count("conflict"),
-		localDeletes,
-		skipped: outcomes.flatMap((outcome) => outcome.kind === "skipped" ? [outcome.message] : []),
-		errors: outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : []),
+		localDeletes: deletes.seen,
+		deletedInGoogle: deletes.deleted.length,
+		skipped: [...outcomes.flatMap((outcome) => outcome.kind === "skipped" ? [outcome.message] : []), ...deletes.skipped],
+		errors: [...outcomes.flatMap((outcome) => outcome.kind === "error" ? [outcome.message] : []), ...deletes.errors],
 		unpushedIds: attempts.filter((attempt) => isUnpushed(attempt.outcome.kind)).map((attempt) => attempt.eventId)
 	};
 }
@@ -1993,6 +2074,69 @@ async function unsentLocalEdits(collection, workspaceRoot) {
 	const shadow = await loadCalendarShadow(schema.googleCalendar?.calendarId, workspaceRoot);
 	return locallyEditedIds(await require_discovery.storeFor(collection, { workspaceRoot }).list(), shadow, pushableMap(schema.googleCalendar?.map ?? {}), schema.primaryKey, schema.fields);
 }
+var noDeletes = (seen) => ({
+	seen,
+	deleted: [],
+	skipped: [],
+	errors: []
+});
+/** A delete whose event changed in Google between the guard reading it and the
+*  delete landing. Reported rather than retried: what changed may be the very
+*  thing the guard refuses, and re-reading in a loop would race the same way. */
+var staleDeleteMessage = (eventId) => `${eventId}: left in Google because it changed there while this push was checking it — press Push again to re-check`;
+/** Delete ONE event and forget its baseline, or say why it was left alone.
+*
+*  The baseline entry goes only after Google confirms, and it must go: the
+*  baseline is what `locallyDeletedIds` reads, so a kept entry would re-report
+*  the same deletion on every run forever. A refusal keeps its entry on
+*  purpose — the event IS still standing in Google, and the report is the only
+*  thing saying so.
+*
+*  The delete carries the etag the guard read. Without it, an attendee added
+*  between the two requests would be withdrawn by a decision taken before they
+*  existed — the same race `updateCalendarEvent` already guards, and it costs
+*  more here because a delete cannot be undone from this side. */
+async function propagateOneDelete(eventId, deps) {
+	const decision = planDelete(await deps.fetchEvent(eventId));
+	if (!decision.ok) {
+		if (decision.kind === "already-gone") {
+			await deps.forget(eventId);
+			return {};
+		}
+		return { skipped: [deleteRefusalMessage(eventId, decision)] };
+	}
+	try {
+		await deps.deleteEvent(eventId, decision.etag);
+	} catch (error) {
+		if (!isGoogleApiError(error)) throw error;
+		if (EVENT_ABSENT_STATUSES.includes(error.status)) {
+			await deps.forget(eventId);
+			return {};
+		}
+		if (error.status !== 412) throw error;
+		return { skipped: [staleDeleteMessage(eventId)] };
+	}
+	await deps.forget(eventId);
+	log.info("google", "calendar event deleted by push", { id: eventId });
+	return { deleted: [eventId] };
+}
+/** Carry every local deletion, when the collection opted in.
+*
+*  Sequential rather than concurrent: each one writes the shared baseline file,
+*  and an interrupted run has to leave a state the next run resumes from rather
+*  than a partially applied batch. */
+async function sweepDeletes(eventIds, propagate, deps) {
+	if (!propagate || eventIds.length === 0) return noDeletes(eventIds.length);
+	const sweep = noDeletes(eventIds.length);
+	for (const eventId of eventIds) try {
+		const one = await propagateOneDelete(eventId, deps);
+		sweep.deleted.push(...one.deleted ?? []);
+		sweep.skipped.push(...one.skipped ?? []);
+	} catch (error) {
+		sweep.errors.push(`${eventId}: could not be deleted in Google — ${require_dist.errorMessage(error)}`);
+	}
+	return sweep;
+}
 /** Push one collection WITHOUT taking the calendar lock.
 *
 *  The caller must already hold it. The scheduled push→pull cycle
@@ -2031,7 +2175,18 @@ async function pushCollectionNow(collection, workspaceRoot, deps = liveDeps) {
 		});
 		await saveCalendarShadow(calendarId, pushedShadow([outcome]), workspaceRoot);
 	}
-	const result = tally(slug, attempts, locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))).length);
+	const result = tally(slug, attempts, await sweepDeletes(locallyDeletedIds(shadow, records.map((record) => fieldText(record[schema.primaryKey]))), schema.googleCalendar?.propagateDeletes === true, {
+		fetchEvent: (eventId) => (deps.fetchEvent ?? getCalendarEvent)(accessToken, {
+			calendarId,
+			eventId
+		}),
+		deleteEvent: (eventId, ifMatch) => (deps.deleteEvent ?? deleteCalendarEvent)(accessToken, {
+			calendarId,
+			eventId,
+			ifMatch
+		}),
+		forget: (eventId) => saveCalendarShadow(calendarId, { [eventId]: null }, workspaceRoot)
+	}));
 	if (result.errors.length > 0) log.warn("google", "calendar push finished with errors", {
 		slug,
 		errors: result.errors.length
@@ -2992,6 +3147,7 @@ async function deleteDriveFile(accessToken, input) {
 exports.ALL_DAY_END_HINT = ALL_DAY_END_HINT;
 exports.CANCELLED_EVENT_STATUS = CANCELLED_EVENT_STATUS;
 exports.DEFAULT_LIST_MAX_RESULTS = DEFAULT_LIST_MAX_RESULTS;
+exports.EVENT_ABSENT_STATUSES = EVENT_ABSENT_STATUSES;
 exports.EVENT_TIME_HINT = EVENT_TIME_HINT;
 exports.GOOGLE_AUTH_CANCELLED = GOOGLE_AUTH_CANCELLED;
 exports.GOOGLE_CALENDARLIST_SCOPE = GOOGLE_CALENDARLIST_SCOPE;
@@ -3042,6 +3198,7 @@ exports.collectCalendarPages = collectCalendarPages;
 exports.collectionsNeedingBackfill = collectionsNeedingBackfill;
 exports.commitLinkedTokens = commitLinkedTokens;
 exports.completeTask = completeTask;
+exports.conferenceVideoUri = conferenceVideoUri;
 exports.configureGoogleHost = configureGoogleHost;
 exports.conflictingFields = conflictingFields;
 exports.createCalendarEvent = createCalendarEvent;
@@ -3051,6 +3208,7 @@ exports.createTask = createTask;
 exports.deleteCalendarEvent = deleteCalendarEvent;
 exports.deleteDriveFile = deleteDriveFile;
 exports.deleteGoogleTokens = deleteGoogleTokens;
+exports.deleteRefusalMessage = deleteRefusalMessage;
 exports.deleteTask = deleteTask;
 exports.eventTimeHint = eventTimeHint;
 exports.fieldText = fieldText;
@@ -3099,6 +3257,7 @@ exports.mergeShadow = mergeShadow;
 exports.needsCalendarBackfill = needsCalendarBackfill;
 exports.orphanedCalendarId = orphanedCalendarId;
 exports.pickBoundary = pickBoundary;
+exports.planDelete = planDelete;
 exports.planRecord = planRecord;
 exports.pullProtectionFor = pullProtectionFor;
 exports.pullableEvents = pullableEvents;
@@ -3116,8 +3275,10 @@ exports.resumableToken = resumableToken;
 exports.saveCalendarShadow = saveCalendarShadow;
 exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
+exports.selfResponseStatus = selfResponseStatus;
 exports.shadowUpdates = shadowUpdates;
 exports.stateLockPath = stateLockPath;
+exports.sweepDeletes = sweepDeletes;
 exports.syncCalendarEvents = syncCalendarEvents;
 exports.syncCalendarForCollection = syncCalendarForCollection;
 exports.syncCalendarGroup = syncCalendarGroup;