@mulmoclaude/core 1.2.1 → 1.3.0

package/dist/google/collectionSync.d.ts

@@ -48,6 +48,10 @@ export declare function classifyDelete(eventId: string, kind: DeleteItemResult["
  *  those events forever. Fetch once, apply to all, then advance the token.
  *  (Codex + CodeRabbit review on #2184.) */
 export declare function syncCalendarGroup(calendarId: string | undefined, collections: readonly LoadedCollection[], workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
+/** Liveness of the collections a sync just wrote to, checked against the skill
+ *  dir `deleteCollection` removes. `exists` is injected so the rule is testable
+ *  without a filesystem. An empty group has no survivor by definition. */
+export declare function anySyncedCollectionSurvives(collections: readonly Pick<LoadedCollection, "skillDir">[], exists?: (absPath: string) => Promise<boolean>): Promise<boolean>;
 /** Group the declaring collections by the calendar they read, so each calendar
  *  is fetched exactly once.
  *
@@ -57,6 +61,32 @@ export declare function syncCalendarGroup(calendarId: string | undefined, collec
  *  from under the other — the very loss this grouping exists to prevent
  *  (Codex review #2184). */
 export declare function groupByCalendar(collections: readonly LoadedCollection[]): Map<string, LoadedCollection[]>;
+/** The minimum a value needs for the orphan check: just the calendar it reads.
+ *  Structural so the rule can be exercised without building a LoadedCollection. */
+export interface CalendarDeclaring {
+    googleCalendar?: {
+        calendarId?: string;
+    };
+}
+/** The canonical calendar whose sync token nothing needs any more, or null.
+ *
+ *  Sync tokens are keyed by calendar, NOT by collection, so a deleted
+ *  collection's token outlives it. Recreating a collection on the same calendar
+ *  then resumes from that token and receives only the delta — the new
+ *  collection never gets the history (#2428).
+ *
+ *  Returns null while ANY remaining collection still reads that calendar:
+ *  clearing a live calendar's token costs a full re-walk on the next sync. The
+ *  comparison is on the CANONICAL id for the same reason `groupByCalendar` is —
+ *  an omitted `calendarId` and an explicit `"primary"` are one calendar. */
+export declare function orphanedCalendarId(deleted: CalendarDeclaring, remaining: readonly CalendarDeclaring[]): string | null;
+/** Drop the sync token of a just-deleted collection's calendar, unless another
+ *  collection still reads it. Call AFTER the delete lands — the check reads the
+ *  collections that survive it.
+ *
+ *  Returns the cleared calendar id, or null when nothing was cleared. Never
+ *  throws: a failed cleanup must not fail the delete it follows. */
+export declare function releaseOrphanedCalendarToken(deleted: CalendarDeclaring, workspaceRoot: string): Promise<string | null>;
 /** Sync every collection that declares `googleCalendar`. Failures are isolated
  *  per calendar — one unreachable calendar (or a revoked grant) must not stop
  *  the others. */

package/dist/google/index.cjs

@@ -906,13 +906,47 @@ async function syncCalendarGroup(calendarId, collections, workspaceRoot) {
 		unwritable
 	});
 	const failed = results.flatMap((entry) => entry.errors);
-	if (result.nextSyncToken && failed.length === 0) await saveCalendarSyncToken(calendarId, result.nextSyncToken, workspaceRoot);
-	else if (failed.length > 0) log.warn("google", "holding back calendar sync token after failed writes", {
-		calendarId,
-		failed: failed.length
-	});
+	if (failed.length > 0) {
+		log.warn("google", "holding back calendar sync token after failed writes", {
+			calendarId,
+			failed: failed.length
+		});
+		return results;
+	}
+	if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
 	return results;
 }
+/** Save the window's token unless every collection that consumed it was deleted
+*  while the sync was in flight.
+*
+*  The sync opens with a `discoverCollections()` snapshot, so a delete landing
+*  mid-run has already cleared this calendar's token by the time we get here
+*  (`releaseOrphanedCalendarToken`). Saving anyway would resurrect exactly the
+*  orphan the delete removed, and the next collection on this calendar would
+*  resume from a token describing records it never received (#2428).
+*
+*  One survivor is enough: it still needs the incremental position. */
+async function advanceToken(calendarId, nextSyncToken, collections, workspaceRoot) {
+	if (!await anySyncedCollectionSurvives(collections)) {
+		log.info("google", "not advancing the sync token — every collection on this calendar was deleted mid-sync", { calendarId });
+		return;
+	}
+	await saveCalendarSyncToken(calendarId, nextSyncToken, workspaceRoot);
+}
+async function pathExists(absPath) {
+	try {
+		await (0, node_fs_promises.stat)(absPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Liveness of the collections a sync just wrote to, checked against the skill
+*  dir `deleteCollection` removes. `exists` is injected so the rule is testable
+*  without a filesystem. An empty group has no survivor by definition. */
+async function anySyncedCollectionSurvives(collections, exists = pathExists) {
+	return (await Promise.all(collections.map((collection) => exists(collection.skillDir)))).some(Boolean);
+}
 async function applyEventsToCollection(collection, events, workspaceRoot) {
 	const outcomes = [];
 	for (const event of events) outcomes.push(await applyEvent(collection, event, workspaceRoot));
@@ -945,6 +979,41 @@ function groupByCalendar(collections) {
 	}
 	return groups;
 }
+/** The canonical calendar whose sync token nothing needs any more, or null.
+*
+*  Sync tokens are keyed by calendar, NOT by collection, so a deleted
+*  collection's token outlives it. Recreating a collection on the same calendar
+*  then resumes from that token and receives only the delta — the new
+*  collection never gets the history (#2428).
+*
+*  Returns null while ANY remaining collection still reads that calendar:
+*  clearing a live calendar's token costs a full re-walk on the next sync. The
+*  comparison is on the CANONICAL id for the same reason `groupByCalendar` is —
+*  an omitted `calendarId` and an explicit `"primary"` are one calendar. */
+function orphanedCalendarId(deleted, remaining) {
+	if (!deleted.googleCalendar) return null;
+	const key = canonicalCalendarId(deleted.googleCalendar.calendarId);
+	return remaining.some((other) => other.googleCalendar && canonicalCalendarId(other.googleCalendar.calendarId) === key) ? null : key;
+}
+/** Drop the sync token of a just-deleted collection's calendar, unless another
+*  collection still reads it. Call AFTER the delete lands — the check reads the
+*  collections that survive it.
+*
+*  Returns the cleared calendar id, or null when nothing was cleared. Never
+*  throws: a failed cleanup must not fail the delete it follows. */
+async function releaseOrphanedCalendarToken(deleted, workspaceRoot) {
+	try {
+		if (!deleted.googleCalendar) return null;
+		const orphaned = orphanedCalendarId(deleted, (await require_discovery.discoverCollections({ workspaceRoot })).map((collection) => collection.schema));
+		if (orphaned === null) return null;
+		await clearCalendarSyncToken(orphaned, workspaceRoot);
+		log.info("google", "cleared the sync token of a calendar no collection reads any more", { calendarId: orphaned });
+		return orphaned;
+	} catch (error) {
+		log.warn("google", "could not release the deleted collection's calendar sync token", { error: String(error) });
+		return null;
+	}
+}
 /** Sync every collection that declares `googleCalendar`. Failures are isolated
 *  per calendar — one unreachable calendar (or a revoked grant) must not stop
 *  the others. */
@@ -1147,6 +1216,7 @@ exports.GOOGLE_SCOPES = GOOGLE_SCOPES;
 exports.GOOGLE_TASKS_SCOPE = GOOGLE_TASKS_SCOPE;
 exports.GoogleApiError = GoogleApiError;
 exports.MAX_LIST_RESULTS = MAX_LIST_RESULTS;
+exports.anySyncedCollectionSurvives = anySyncedCollectionSurvives;
 exports.assertSafeMimeType = assertSafeMimeType;
 exports.authorizeGoogle = authorizeGoogle;
 exports.brokerBaseUrl = brokerBaseUrl;
@@ -1195,8 +1265,10 @@ exports.loadCalendarSyncToken = loadCalendarSyncToken;
 exports.loadClientSecret = loadClientSecret;
 exports.loadGoogleTokens = loadGoogleTokens;
 exports.mergeGoogleTokens = mergeGoogleTokens;
+exports.orphanedCalendarId = orphanedCalendarId;
 exports.pickBoundary = pickBoundary;
 exports.readDriveFile = readDriveFile;
+exports.releaseOrphanedCalendarToken = releaseOrphanedCalendarToken;
 exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
 exports.syncCalendarEvents = syncCalendarEvents;