@mulmoclaude/core 3.2.0 → 3.4.0

package/dist/feeds/server/index.cjs

@@ -4,8 +4,8 @@ const require_dist = require("../../dist-CsgSfWwR.cjs");
 const require_root = require("../../root-rPH6FGDT.cjs");
 const require_calendarGrid = require("../../calendarGrid-p8K-7cuB.cjs");
 const require_project = require("../../project-C1ep9pvo.cjs");
-const require_discovery = require("../../discovery-CDOjfctD.cjs");
-const require_server = require("../../server-WU35UYlF.cjs");
+const require_discovery = require("../../discovery-CrA_EqUJ.cjs");
+const require_server = require("../../server-CorfPQVQ.cjs");
 const require_feeds_paths = require("../paths.cjs");
 const require_ingestTypes = require("../../ingestTypes-CPR-h-OZ.cjs");
 const require_notifier = require("../../notifier-DZJj0sOh.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-BMroU_mB.js";
 import { C as FEED_SCHEDULES, w as INGEST_KINDS } from "../../calendarGrid-Csy2rpjp.js";
 import { t as mergeIntoExisting } from "../../project-B0j_Vf_Q.js";
-import { B as resolveDataDir, N as listItems, U as safeSlugName, at as createHostSlot, d as storeFor, it as createForwardingLogger, n as discoverCollections } from "../../discovery-CC7kuwHf.js";
-import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-AA2kfDfk.js";
+import { B as resolveDataDir, N as listItems, U as safeSlugName, at as createHostSlot, d as storeFor, it as createForwardingLogger, n as discoverCollections } from "../../discovery-D7LCN8gJ.js";
+import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-D6QY853r.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-F2IJhOLJ.js";
 import { d as publish, n as clear } from "../../notifier-DhnwR82U.js";

package/dist/google/calendar.d.ts

@@ -175,6 +175,17 @@ export interface CalendarSyncResult {
     /** The stored token had expired (410) — the caller must drop it and re-sync
      *  from scratch; no events are returned in that case. */
     fullResyncRequired: boolean;
+    /** The page guard fired with pages still pending, so `events` is a PARTIAL
+     *  window and `nextSyncToken` is absent.
+     *
+     *  Reported rather than left implicit because a truncated walk is otherwise
+     *  byte-identical to a completed one: the caller would apply the partial set,
+     *  report success, and — since only Google's last page carries the token —
+     *  repeat the same truncated walk on every later run, silently (#2850).
+     *  Google states a page "may be less than this value, or none at all, even if
+     *  there are more events matching the query", so this is reachable on a real
+     *  calendar, the more so with `singleEvents` expanding unbounded recurrences. */
+    pagesExhausted: boolean;
 }
 /** Incremental sync over the events of one calendar (#2095).
  *
@@ -186,6 +197,10 @@ export interface CalendarSyncResult {
  *
  *  `nextSyncToken` is only present on the LAST page, so every page must be
  *  walked before the token is worth storing. */
+/** The query for one page of the walk. `showDeleted` must stay true or
+ *  deletions would be invisible; `pageToken` is sent ALONGSIDE `syncToken`,
+ *  which is what Google requires to page an incremental sync. */
+export declare function syncPageParams(input: SyncEventsInput, pageToken: string | undefined): URLSearchParams;
 export declare function syncCalendarEvents(accessToken: string, input?: SyncEventsInput): Promise<CalendarSyncResult>;
 export interface CalendarListPage {
     items: unknown[];

package/dist/google/calendarBackfillState.d.ts

@@ -0,0 +1,19 @@
+/** `<dataDir>/.calendar-sync.json` */
+export declare const calendarBackfillPath: (dataDir: string) => string;
+/** Whether these records still need the whole calendar walked into them.
+ *
+ *  Compared against the calendar the marker NAMES, not merely its presence: a
+ *  schema repointed at another calendar holds a backfill of the wrong one, and
+ *  resuming that calendar's cursor would leave the same silent gap this exists
+ *  to close.
+ *
+ *  Unreadable, absent or INCOMPLETE all answer "yes" — every field must be
+ *  there, not just the one being compared. A redundant full walk costs API
+ *  calls and rewrites records that already match; skipping a needed one loses
+ *  the history silently, which is the failure being fixed, so the bias only
+ *  ever goes one way (CodeRabbit review #2853). */
+export declare function needsCalendarBackfill(dataDir: string, calendarId: string | undefined): Promise<boolean>;
+/** Record that these records now cover the whole calendar. Never throws: the
+ *  marker is an optimisation over re-walking, so a workspace that cannot write
+ *  it syncs correctly and simply walks in full again next time. */
+export declare function markCalendarBackfilled(dataDir: string, calendarId: string | undefined, walkedAt: string): Promise<void>;

package/dist/google/calendarSyncStore.d.ts

@@ -1,5 +1,20 @@
 /** `<workspace>/data/calendar/.sync-state.json` */
 export declare function calendarSyncStatePath(workspaceRoot?: string): string;
+/** The key for a consumer that reads a calendar without KEEPING what it reads.
+ *
+ *  A sync token is a claim about which events the consumer already holds, but
+ *  the key above names only the calendar — so every consumer of one calendar
+ *  shares one cursor. That is right for the collections bound to it (one fetch
+ *  fans out to all of them in the same pass) and wrong for the standalone
+ *  `google` tool's `calendarSync`, which walks the calendar, reports a summary
+ *  to the LLM and discards the events.
+ *
+ *  Sharing it lost data both ways (#2850): the tool consumed windows the
+ *  collections then never received, and a collection created afterwards resumed
+ *  from the tool's cursor — so its "first sync" was a delta of a window it had
+ *  never held, and the calendar's history never arrived. Same file, separate
+ *  keyspace. Idempotent through `calendarKey`, since the result is non-empty. */
+export declare const toolCalendarSyncKey: (calendarId: string | undefined) => string;
 export declare function loadCalendarSyncToken(calendarId?: string, workspaceRoot?: string): Promise<string | null>;
 export declare function saveCalendarSyncToken(calendarId: string | undefined, syncToken: string, workspaceRoot?: string): Promise<void>;
 /** Drop one calendar's token — used when Google answers 410, so the next run

package/dist/google/collectionSync.d.ts

@@ -158,6 +158,68 @@ export declare function syncCalendarGroup(calendarId: string | undefined, collec
  *  would advance the baseline past a record the pull deliberately left holding a
  *  local edit, which is the silent overwrite this whole path exists to stop. */
 export declare const heldBack: (unpushed: UnpushedBySlug, results: readonly CalendarCollectionSyncResult[]) => ReadonlySet<string>;
+/** The collections in this group that have never received the whole calendar,
+ *  by slug. Asked of each collection's OWN records (`calendarBackfillState.ts`),
+ *  because the sync token cannot answer it — it is keyed by calendar and shared
+ *  by every consumer of that calendar (#2850). */
+export declare function collectionsNeedingBackfill(collections: readonly LoadedCollection[]): Promise<string[]>;
+/** The token this run may resume from — none while any collection in the group
+ *  still needs the whole calendar.
+ *
+ *  A stored token says how far THE CALENDAR has been read, by whoever read it:
+ *  the standalone `google` tool's `calendarSync`, or a sibling collection that
+ *  synced before this one existed. Resuming from it hands a brand-new collection
+ *  a delta of a window it never received — a handful of records, reported as a
+ *  success with no error, and never the history the docs promise (#2850).
+ *
+ *  The full walk fans out to the whole group, which is free: writes are upserts,
+ *  so the collections that were already current simply rewrite what they hold. */
+export declare function resumableToken(calendarId: string | undefined, collections: readonly LoadedCollection[], workspaceRoot: string): Promise<string | undefined>;
+/** What a partial window reports. Names the cause the user can actually act on:
+ *  a page guard is reached when Google has to expand an enormous number of
+ *  recurring instances, and one series with no end date is enough. */
+export declare const PARTIAL_CALENDAR_WINDOW: string;
+/** A truncated walk must not read as a completed one (#2850).
+ *
+ *  Added AFTER the token/baseline gate, not through it. A short fetch is not a
+ *  failed write: the events that did arrive are Google's own and landed
+ *  correctly, so their baseline is true and holding it back would freeze them —
+ *  a record with no baseline reads as an unsent local edit, which the next pull
+ *  then refuses to touch (#2683). What must not happen is the walk claiming
+ *  completeness, and that is covered without the gate: `nextSyncToken` only
+ *  appears on Google's last page, so a truncated walk has no token to advance,
+ *  and the backfill marker is withheld separately. */
+export declare const withPartialWindowError: (results: readonly CalendarCollectionSyncResult[], pagesExhausted: boolean) => CalendarCollectionSyncResult[];
+/** What a finished window is allowed to advance.
+ *
+ *  One pure rule rather than three conditions spread through the write-back,
+ *  because the three answers genuinely differ and each wrong one is a SILENT
+ *  data bug rather than a visible failure: a baseline held back freezes the
+ *  records it describes (#2683), a baseline advanced past a failed write hides
+ *  a conflict (#2620), a backfill marker set on a partial walk re-creates the
+ *  #2850 gap, and a token advanced past either loses the window for good. */
+export interface WindowAdvance {
+    /** Record what Google now says, so the next push can tell a local edit from a pull. */
+    baseline: boolean;
+    /** Claim these records now hold the WHOLE calendar. */
+    backfill: boolean;
+    /** Move the shared cursor past this window. */
+    token: boolean;
+}
+/** `landed` is the write-side verdict (`windowFullyLanded`); the rest describe
+ *  the window Google returned.
+ *
+ *  A page-capped walk (`pagesExhausted`) keeps its baseline — the events that
+ *  arrived are Google's own and were written correctly — but must NOT claim the
+ *  backfill, or the collection would stop asking for the rest of its calendar.
+ *  Its token is refused too, though Google makes that moot by sending
+ *  `nextSyncToken` only on the last page. */
+export declare function windowAdvance(window: {
+    landed: boolean;
+    walkedInFull: boolean;
+    pagesExhausted: boolean;
+    nextSyncToken?: string | undefined;
+}): WindowAdvance;
 /** The baseline this window establishes: what Google now says per event, and
  *  `null` for a cancelled one so a recreate cannot resume from a dead baseline.
  *
@@ -225,17 +287,22 @@ export declare function releaseOrphanedCalendarToken(deleted: CalendarDeclaring,
  *  evaluated where the marker is written, so the answer cannot go stale between
  *  deciding and claiming (Codex review #2680). */
 export declare function syncDueCalendarCollections(workspaceRoot: string, intervalMs?: number): Promise<CalendarCollectionSyncResult[]>;
-/** The groups whose calendar has never synced. A missing token IS the "created
- *  since the last sync" signal — nothing else distinguishes a new collection
- *  from an edited one on the write path this feeds (#2427).
- *
- *  Self-silencing by construction: the first sync stores a token, so a calendar
- *  matches at most once. `loadToken` is injected so the rule is testable without
- *  a workspace on disk. */
-export declare function unsyncedGroups<T>(groups: Map<string, T>, loadToken: (calendarId: string) => Promise<string | null>): Promise<Map<string, T>>;
-/** Sync only the calendars that have never synced — the first sync for a
- *  just-created collection, which otherwise stays empty until the hourly
- *  scheduler run (#2427). Cheap and safe to call on every config write. */
+/** The groups holding a collection that still needs the whole calendar.
+ *
+ *  This used to ask whether the CALENDAR had a stored token, which is not the
+ *  same question and is why the trigger silently did nothing for the #2850
+ *  reporter: their calendar already had a token — from the standalone `google`
+ *  tool, and on later attempts from the collection they had just deleted by
+ *  hand — so the brand-new collection matched nothing and its first sync never
+ *  ran at all. `pending` is injected so the rule is testable without a
+ *  workspace on disk.
+ *
+ *  Still self-silencing: a landed full walk marks its collections, so a group
+ *  stops matching once every collection in it holds the history. */
+export declare function groupsNeedingBackfill<T>(groups: Map<string, T>, pending: (value: T) => Promise<boolean>): Promise<Map<string, T>>;
+/** Sync only the calendars a collection has never received in full — the first
+ *  sync for a just-created collection, which otherwise stays empty until the
+ *  hourly scheduler run (#2427). Cheap and safe to call on every config write. */
 export declare function syncNewCalendarCollections(workspaceRoot: string): Promise<CalendarCollectionSyncResult[]>;
 /** A user-triggered sync's outcome. `not-a-calendar` and `not-linked` are
  *  states the caller must report rather than swallow: a Refresh click that

package/dist/google/index.cjs

@@ -6,7 +6,7 @@ const require_root = require("../root-rPH6FGDT.cjs");
 const require_utils_fetch = require("../utils/fetch.cjs");
 const require_calendarGrid = require("../calendarGrid-p8K-7cuB.cjs");
 const require_project = require("../project-C1ep9pvo.cjs");
-const require_discovery = require("../discovery-CDOjfctD.cjs");
+const require_discovery = require("../discovery-CrA_EqUJ.cjs");
 const require_paths = require("../paths-ClV946_f.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
@@ -766,33 +766,42 @@ async function fetchSyncPage(accessToken, calendarId, params) {
 *
 *  `nextSyncToken` is only present on the LAST page, so every page must be
 *  walked before the token is worth storing. */
+/** The query for one page of the walk. `showDeleted` must stay true or
+*  deletions would be invisible; `pageToken` is sent ALONGSIDE `syncToken`,
+*  which is what Google requires to page an incremental sync. */
+function syncPageParams(input, pageToken) {
+	const params = new URLSearchParams({
+		singleEvents: "true",
+		showDeleted: "true",
+		maxResults: String(input.maxResults ?? EVENT_SYNC_PAGE_SIZE)
+	});
+	if (input.syncToken) params.set("syncToken", input.syncToken);
+	if (pageToken) params.set("pageToken", pageToken);
+	return params;
+}
 async function syncCalendarEvents(accessToken, input = {}) {
 	const events = [];
 	let pageToken;
 	let nextSyncToken;
 	for (let page = 0; page < MAX_EVENT_SYNC_PAGES; page += 1) {
-		const params = new URLSearchParams({
-			singleEvents: "true",
-			showDeleted: "true",
-			maxResults: String(input.maxResults ?? EVENT_SYNC_PAGE_SIZE)
-		});
-		if (input.syncToken) params.set("syncToken", input.syncToken);
-		if (pageToken) params.set("pageToken", pageToken);
-		const payload = await fetchSyncPage(accessToken, input.calendarId, params);
+		const payload = await fetchSyncPage(accessToken, input.calendarId, syncPageParams(input, pageToken));
 		if (payload === GONE) return {
 			events: [],
-			fullResyncRequired: true
+			fullResyncRequired: true,
+			pagesExhausted: false
 		};
 		const record = asRecord(payload);
 		events.push(...itemsOf(payload).map(toEventSummary));
 		nextSyncToken = stringField(record, "nextSyncToken") || void 0;
 		pageToken = stringField(record, "nextPageToken") || void 0;
 		if (!pageToken) break;
+		nextSyncToken = void 0;
 	}
 	return {
 		events,
 		nextSyncToken,
-		fullResyncRequired: false
+		fullResyncRequired: false,
+		pagesExhausted: pageToken !== void 0
 	};
 }
 /** Pagination loop for CalendarList.list, extracted so it can be tested without
@@ -1017,6 +1026,21 @@ function calendarSyncStatePath(workspaceRoot) {
 	return node_path.default.join(workspaceRoot ?? require_discovery.getWorkspaceRoot(), "data", "calendar", ".sync-state.json");
 }
 var calendarKey = canonicalCalendarId;
+/** The key for a consumer that reads a calendar without KEEPING what it reads.
+*
+*  A sync token is a claim about which events the consumer already holds, but
+*  the key above names only the calendar — so every consumer of one calendar
+*  shares one cursor. That is right for the collections bound to it (one fetch
+*  fans out to all of them in the same pass) and wrong for the standalone
+*  `google` tool's `calendarSync`, which walks the calendar, reports a summary
+*  to the LLM and discards the events.
+*
+*  Sharing it lost data both ways (#2850): the tool consumed windows the
+*  collections then never received, and a collection created afterwards resumed
+*  from the tool's cursor — so its "first sync" was a delta of a window it had
+*  never held, and the calendar's history never arrived. Same file, separate
+*  keyspace. Idempotent through `calendarKey`, since the result is non-empty. */
+var toolCalendarSyncKey = (calendarId) => `tool:${canonicalCalendarId(calendarId)}`;
 /** Read one map out of whatever is on disk. Tolerant on purpose: a file written
 *  before `lastSyncedAt` existed simply lacks the key, and a hand-edited one may
 *  hold anything. A dropped entry costs a full re-walk or a duplicate run, never
@@ -1142,6 +1166,46 @@ function isCalendarSyncDue(lastSyncedAt, windowMs, now = Date.now()) {
 	return elapsed >= windowMs;
 }
 //#endregion
+//#region src/google/calendarBackfillState.ts
+var BACKFILL_STATE_MODE = 384;
+var BACKFILL_FILE = ".calendar-sync.json";
+/** `<dataDir>/.calendar-sync.json` */
+var calendarBackfillPath = (dataDir) => node_path.default.join(dataDir, BACKFILL_FILE);
+/** Whether these records still need the whole calendar walked into them.
+*
+*  Compared against the calendar the marker NAMES, not merely its presence: a
+*  schema repointed at another calendar holds a backfill of the wrong one, and
+*  resuming that calendar's cursor would leave the same silent gap this exists
+*  to close.
+*
+*  Unreadable, absent or INCOMPLETE all answer "yes" — every field must be
+*  there, not just the one being compared. A redundant full walk costs API
+*  calls and rewrites records that already match; skipping a needed one loses
+*  the history silently, which is the failure being fixed, so the bias only
+*  ever goes one way (CodeRabbit review #2853). */
+async function needsCalendarBackfill(dataDir, calendarId) {
+	const stored = await readJsonOrNull(calendarBackfillPath(dataDir));
+	if (typeof stored?.walkedAt !== "string" || stored.walkedAt === "") return true;
+	return stored.calendarId !== canonicalCalendarId(calendarId);
+}
+/** Record that these records now cover the whole calendar. Never throws: the
+*  marker is an optimisation over re-walking, so a workspace that cannot write
+*  it syncs correctly and simply walks in full again next time. */
+async function markCalendarBackfilled(dataDir, calendarId, walkedAt) {
+	const state = {
+		calendarId: canonicalCalendarId(calendarId),
+		walkedAt
+	};
+	try {
+		await writeJsonAtomicWithMode(calendarBackfillPath(dataDir), state, BACKFILL_STATE_MODE);
+	} catch (error) {
+		log.warn("google", "could not record the calendar backfill marker — the next sync will walk the calendar again", {
+			dataDir,
+			error: String(error)
+		});
+	}
+}
+//#endregion
 //#region src/google/calendarPushState.ts
 var PUSH_STATE_MODE = 384;
 /** `<workspace>/data/calendar/.push-state.json` */
@@ -2187,21 +2251,114 @@ async function releaseCalendarSyncClaim(calendarId, workspaceRoot) {
 *  would advance the baseline past a record the pull deliberately left holding a
 *  local edit, which is the silent overwrite this whole path exists to stop. */
 var heldBack = (unpushed, results) => /* @__PURE__ */ new Set([...allUnpushed(unpushed), ...results.flatMap((result) => result.withheld)]);
-async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
-	const unpushed = await pushAndProtect(collections, workspaceRoot);
-	const baseline = await loadCalendarShadow(calendarId, workspaceRoot);
+/** The collections in this group that have never received the whole calendar,
+*  by slug. Asked of each collection's OWN records (`calendarBackfillState.ts`),
+*  because the sync token cannot answer it — it is keyed by calendar and shared
+*  by every consumer of that calendar (#2850). */
+async function collectionsNeedingBackfill(collections) {
+	return (await Promise.all(collections.map(async (collection) => {
+		return await needsCalendarBackfill(collection.dataDir, collection.schema.googleCalendar?.calendarId) ? collection.slug : null;
+	}))).filter((slug) => slug !== null);
+}
+/** The token this run may resume from — none while any collection in the group
+*  still needs the whole calendar.
+*
+*  A stored token says how far THE CALENDAR has been read, by whoever read it:
+*  the standalone `google` tool's `calendarSync`, or a sibling collection that
+*  synced before this one existed. Resuming from it hands a brand-new collection
+*  a delta of a window it never received — a handful of records, reported as a
+*  success with no error, and never the history the docs promise (#2850).
+*
+*  The full walk fans out to the whole group, which is free: writes are upserts,
+*  so the collections that were already current simply rewrite what they hold. */
+async function resumableToken(calendarId, collections, workspaceRoot) {
+	const pending = await collectionsNeedingBackfill(collections);
+	if (pending.length === 0) return await loadCalendarSyncToken(calendarId, workspaceRoot) ?? void 0;
+	log.info("google", "walking the whole calendar — these collections have never received it", {
+		calendarId,
+		collections: pending
+	});
+}
+/** Record the backfill for every collection the window landed in. Called only
+*  after a FULL walk that fully landed: marking one after an incremental window
+*  would claim a history the records do not hold. */
+async function markGroupBackfilled(calendarId, collections) {
+	const walkedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await Promise.all(collections.map((collection) => markCalendarBackfilled(collection.dataDir, collection.schema.googleCalendar?.calendarId, walkedAt)));
+}
+/** What a partial window reports. Names the cause the user can actually act on:
+*  a page guard is reached when Google has to expand an enormous number of
+*  recurring instances, and one series with no end date is enough. */
+var PARTIAL_CALENDAR_WINDOW = "Google returned more pages of events than one sync pass walks, so only part of the calendar was copied. Give any recurring event with no end date a finite end date, then sync again.";
+/** A truncated walk must not read as a completed one (#2850).
+*
+*  Added AFTER the token/baseline gate, not through it. A short fetch is not a
+*  failed write: the events that did arrive are Google's own and landed
+*  correctly, so their baseline is true and holding it back would freeze them —
+*  a record with no baseline reads as an unsent local edit, which the next pull
+*  then refuses to touch (#2683). What must not happen is the walk claiming
+*  completeness, and that is covered without the gate: `nextSyncToken` only
+*  appears on Google's last page, so a truncated walk has no token to advance,
+*  and the backfill marker is withheld separately. */
+var withPartialWindowError = (results, pagesExhausted) => pagesExhausted ? results.map((result) => ({
+	...result,
+	errors: [...result.errors, PARTIAL_CALENDAR_WINDOW]
+})) : [...results];
+/** `landed` is the write-side verdict (`windowFullyLanded`); the rest describe
+*  the window Google returned.
+*
+*  A page-capped walk (`pagesExhausted`) keeps its baseline — the events that
+*  arrived are Google's own and were written correctly — but must NOT claim the
+*  backfill, or the collection would stop asking for the rest of its calendar.
+*  Its token is refused too, though Google makes that moot by sending
+*  `nextSyncToken` only on the last page. */
+function windowAdvance(window) {
+	if (!window.landed) return {
+		baseline: false,
+		backfill: false,
+		token: false
+	};
+	const complete = !window.pagesExhausted;
+	return {
+		baseline: true,
+		backfill: window.walkedInFull && complete,
+		token: complete && window.nextSyncToken !== void 0
+	};
+}
+/** The window this run should read, and whether it was a full walk. A 410
+*  restart is a full walk too, so it backfills just as well as a forced one. */
+async function readWindow(calendarId, collections, workspaceRoot) {
 	const accessToken = await getGoogleAccessToken();
+	const resumeFrom = await resumableToken(calendarId, collections, workspaceRoot);
 	const first = await syncCalendarEvents(accessToken, {
 		calendarId,
-		syncToken: await loadCalendarSyncToken(calendarId, workspaceRoot) ?? void 0
+		syncToken: resumeFrom
 	});
 	const result = first.fullResyncRequired ? await restartFullSync(accessToken, calendarId, workspaceRoot) : first;
-	const results = await applyWindowToGroup(collections, result.events, workspaceRoot, unpushed, baseline);
-	if (windowFullyLanded(calendarId, results)) {
-		await saveCalendarShadow(calendarId, shadowUpdates(result.events, heldBack(unpushed, results), baseline), workspaceRoot);
-		if (result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
-	}
-	return results;
+	if (result.pagesExhausted) log.warn("google", "the calendar walk ran out of pages — only part of it was copied", {
+		calendarId,
+		events: result.events.length
+	});
+	return {
+		result,
+		walkedInFull: resumeFrom === void 0 || first.fullResyncRequired
+	};
+}
+async function syncCalendarGroupNow(calendarId, collections, workspaceRoot) {
+	const unpushed = await pushAndProtect(collections, workspaceRoot);
+	const baseline = await loadCalendarShadow(calendarId, workspaceRoot);
+	const { result, walkedInFull } = await readWindow(calendarId, collections, workspaceRoot);
+	const applied = await applyWindowToGroup(collections, result.events, workspaceRoot, unpushed, baseline);
+	const advance = windowAdvance({
+		landed: windowFullyLanded(calendarId, applied),
+		walkedInFull,
+		pagesExhausted: result.pagesExhausted,
+		nextSyncToken: result.nextSyncToken
+	});
+	if (advance.baseline) await saveCalendarShadow(calendarId, shadowUpdates(result.events, heldBack(unpushed, applied), baseline), workspaceRoot);
+	if (advance.backfill) await markGroupBackfilled(calendarId, collections);
+	if (advance.token && result.nextSyncToken) await advanceToken(calendarId, result.nextSyncToken, collections, workspaceRoot);
+	return withPartialWindowError(applied, result.pagesExhausted);
 }
 /** Apply one window to every collection on the calendar, honouring what each
 *  one's own push protected. A collection whose protection could not be worked
@@ -2437,24 +2594,29 @@ async function syncDueCalendarCollections(workspaceRoot, intervalMs = DEFAULT_SY
 	const windowMs = calendarSyncDueWindowMs(intervalMs);
 	return await runCalendarGroups(groups, workspaceRoot, (lastSyncedAt) => isCalendarSyncDue(lastSyncedAt, windowMs));
 }
-/** The groups whose calendar has never synced. A missing token IS the "created
-*  since the last sync" signal — nothing else distinguishes a new collection
-*  from an edited one on the write path this feeds (#2427).
+/** The groups holding a collection that still needs the whole calendar.
+*
+*  This used to ask whether the CALENDAR had a stored token, which is not the
+*  same question and is why the trigger silently did nothing for the #2850
+*  reporter: their calendar already had a token — from the standalone `google`
+*  tool, and on later attempts from the collection they had just deleted by
+*  hand — so the brand-new collection matched nothing and its first sync never
+*  ran at all. `pending` is injected so the rule is testable without a
+*  workspace on disk.
 *
-*  Self-silencing by construction: the first sync stores a token, so a calendar
-*  matches at most once. `loadToken` is injected so the rule is testable without
-*  a workspace on disk. */
-async function unsyncedGroups(groups, loadToken) {
-	const checked = await Promise.all([...groups].map(async (entry) => await loadToken(entry[0]) === null ? entry : null));
+*  Still self-silencing: a landed full walk marks its collections, so a group
+*  stops matching once every collection in it holds the history. */
+async function groupsNeedingBackfill(groups, pending) {
+	const checked = await Promise.all([...groups].map(async (entry) => await pending(entry[1]) ? entry : null));
 	return new Map(checked.filter((entry) => entry !== null));
 }
-/** Sync only the calendars that have never synced — the first sync for a
-*  just-created collection, which otherwise stays empty until the hourly
-*  scheduler run (#2427). Cheap and safe to call on every config write. */
+/** Sync only the calendars a collection has never received in full — the first
+*  sync for a just-created collection, which otherwise stays empty until the
+*  hourly scheduler run (#2427). Cheap and safe to call on every config write. */
 async function syncNewCalendarCollections(workspaceRoot) {
-	const pending = await unsyncedGroups(await declaringGroups(workspaceRoot), (calendarId) => loadCalendarSyncToken(calendarId, workspaceRoot));
+	const pending = await groupsNeedingBackfill(await declaringGroups(workspaceRoot), async (collections) => (await collectionsNeedingBackfill(collections)).length > 0);
 	if (!await backgroundSyncAllowed(pending)) return [];
-	log.info("google", "running the first sync for newly declared calendars", { calendars: [...pending.keys()] });
+	log.info("google", "running the first sync for calendars a collection has never received in full", { calendars: [...pending.keys()] });
 	return await runCalendarGroups(pending, workspaceRoot);
 }
 var liveManualSyncDeps = {
@@ -2717,6 +2879,7 @@ exports.HTTP_CONFLICT = HTTP_CONFLICT;
 exports.HTTP_FORBIDDEN = HTTP_FORBIDDEN;
 exports.HTTP_PRECONDITION_FAILED = HTTP_PRECONDITION_FAILED;
 exports.MAX_LIST_RESULTS = MAX_LIST_RESULTS;
+exports.PARTIAL_CALENDAR_WINDOW = PARTIAL_CALENDAR_WINDOW;
 exports.PROTECTION_UNKNOWN = PROTECTION_UNKNOWN;
 exports.PUSHABLE_SOURCE_FIELDS = PUSHABLE_SOURCE_FIELDS;
 exports.allUnpushed = allUnpushed;
@@ -2734,6 +2897,7 @@ exports.buildMultipartBody = buildMultipartBody;
 exports.buildTaskPatch = buildTaskPatch;
 exports.bySourceField = bySourceField;
 exports.calendarApiError = calendarApiError;
+exports.calendarBackfillPath = calendarBackfillPath;
 exports.calendarPushStatePath = calendarPushStatePath;
 exports.calendarSyncDueWindowMs = calendarSyncDueWindowMs;
 exports.calendarSyncStatePath = calendarSyncStatePath;
@@ -2747,6 +2911,7 @@ exports.clearCalendarShadow = clearCalendarShadow;
 exports.clearCalendarSyncToken = clearCalendarSyncToken;
 exports.clientSecretPresence = clientSecretPresence;
 exports.collectCalendarPages = collectCalendarPages;
+exports.collectionsNeedingBackfill = collectionsNeedingBackfill;
 exports.commitLinkedTokens = commitLinkedTokens;
 exports.completeTask = completeTask;
 exports.configureGoogleHost = configureGoogleHost;
@@ -2772,6 +2937,7 @@ exports.googleConfigDir = googleConfigDir;
 exports.googleSecretsDir = googleSecretsDir;
 exports.googleTokenPath = googleTokenPath;
 exports.groupByCalendar = groupByCalendar;
+exports.groupsNeedingBackfill = groupsNeedingBackfill;
 exports.heldBack = heldBack;
 exports.isCalendarSyncDue = isCalendarSyncDue;
 exports.isClientSettableEventId = isClientSettableEventId;
@@ -2795,10 +2961,12 @@ exports.loadGoogleTokens = loadGoogleTokens;
 exports.locallyChangedFields = locallyChangedFields;
 exports.locallyDeletedIds = locallyDeletedIds;
 exports.locallyEditedIds = locallyEditedIds;
+exports.markCalendarBackfilled = markCalendarBackfilled;
 exports.mayAdoptExisting = mayAdoptExisting;
 exports.mergeGoogleTokens = mergeGoogleTokens;
 exports.mergeIntoExisting = require_project.mergeIntoExisting;
 exports.mergeShadow = mergeShadow;
+exports.needsCalendarBackfill = needsCalendarBackfill;
 exports.orphanedCalendarId = orphanedCalendarId;
 exports.pickBoundary = pickBoundary;
 exports.planRecord = planRecord;
@@ -2812,6 +2980,7 @@ exports.readDriveFile = readDriveFile;
 exports.releaseOrphanedCalendarToken = releaseOrphanedCalendarToken;
 exports.reportedAccessRole = reportedAccessRole;
 exports.resolveEventSpan = resolveEventSpan;
+exports.resumableToken = resumableToken;
 exports.saveCalendarShadow = saveCalendarShadow;
 exports.saveCalendarSyncToken = saveCalendarSyncToken;
 exports.saveGoogleTokens = saveGoogleTokens;
@@ -2822,6 +2991,7 @@ exports.syncCalendarForCollection = syncCalendarForCollection;
 exports.syncCalendarGroup = syncCalendarGroup;
 exports.syncDueCalendarCollections = syncDueCalendarCollections;
 exports.syncNewCalendarCollections = syncNewCalendarCollections;
+exports.syncPageParams = syncPageParams;
 exports.toCalendarMeta = toCalendarMeta;
 exports.toCalendarSummary = toCalendarSummary;
 exports.toCollectionDateTime = toCollectionDateTime;
@@ -2832,18 +3002,20 @@ exports.toGoogleEventTime = toGoogleEventTime;
 exports.toShadowEvent = toShadowEvent;
 exports.toTaskListSummary = toTaskListSummary;
 exports.toTaskSummary = toTaskSummary;
+exports.toolCalendarSyncKey = toolCalendarSyncKey;
 exports.uncompleteTask = uncompleteTask;
 exports.unlinkGoogle = unlinkGoogle;
 exports.unpushedFor = unpushedFor;
 exports.unsentEditGuard = unsentEditGuard;
 exports.unsentLocalEdits = unsentLocalEdits;
-exports.unsyncedGroups = unsyncedGroups;
 exports.updateCalendarEvent = updateCalendarEvent;
 exports.updateTask = updateTask;
 exports.waitForAuthCode = waitForAuthCode;
+exports.windowAdvance = windowAdvance;
 exports.withCalendarLock = withCalendarLock;
 exports.withCalendarStateLock = withCalendarStateLock;
 exports.withKeyedLock = withKeyedLock;
+exports.withPartialWindowError = withPartialWindowError;
 exports.zoneSuffixOf = zoneSuffixOf;
 
 //# sourceMappingURL=index.cjs.map