@mulmoclaude/core 1.2.0 → 1.3.0

package/dist/feeds/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_ids = require("../ids-BJ7rdrDN.cjs");
-const require_ingestTypes = require("../ingestTypes-CkbM-zrO.cjs");
+const require_ids = require("../ids-BnTh3Hl0.cjs");
+const require_ingestTypes = require("../ingestTypes-xX8VpQqh.cjs");
 exports.AGENT_INGEST_KIND = require_ingestTypes.AGENT_INGEST_KIND;
 exports.DEFAULT_FEED_MAX_ITEMS = require_ingestTypes.DEFAULT_FEED_MAX_ITEMS;
 exports.FEED_SCHEDULES = require_ids.FEED_SCHEDULES;

package/dist/feeds/index.js

@@ -1,3 +1,3 @@
-import { c as FEED_SCHEDULES, l as INGEST_KINDS } from "../ids-Bv6AOW9Z.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-DuCiZqye.js";
+import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../ids-s4GfmE93.js";
+import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../ingestTypes-L59cIGgX.js";
 export { AGENT_INGEST_KIND, DEFAULT_FEED_MAX_ITEMS, FEED_SCHEDULES, INGEST_KINDS, isFeedSchedule };

package/dist/feeds/server/index.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../../rolldown-runtime-D6vf50IK.cjs");
-const require_ids = require("../../ids-BJ7rdrDN.cjs");
-const require_discovery = require("../../discovery-UxkvBxV-.cjs");
-const require_server = require("../../server-DFo3zFYB.cjs");
-const require_ingestTypes = require("../../ingestTypes-CkbM-zrO.cjs");
+const require_ids = require("../../ids-BnTh3Hl0.cjs");
+const require_discovery = require("../../discovery--kRUWed0.cjs");
+const require_server = require("../../server-gEOeV_Nv.cjs");
 const require_feeds_paths = require("../paths.cjs");
+const require_ingestTypes = require("../../ingestTypes-xX8VpQqh.cjs");
 const require_notifier = require("../../notifier-tMsAXyXp.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);

package/dist/feeds/server/index.js

@@ -1,8 +1,8 @@
-import { c as FEED_SCHEDULES, l as INGEST_KINDS } from "../../ids-Bv6AOW9Z.js";
-import { N as listItems, V as resolveDataDir, W as safeSlugName, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../../discovery-DYlEOa9a.js";
-import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-CnwgECW-.js";
-import { n as DEFAULT_FEED_MAX_ITEMS, r as isFeedSchedule, t as AGENT_INGEST_KIND } from "../../ingestTypes-DuCiZqye.js";
+import { l as FEED_SCHEDULES, u as INGEST_KINDS } from "../../ids-s4GfmE93.js";
+import { N as listItems, V as resolveDataDir, W as safeSlugName, d as storeFor, et as createForwardingLogger, n as discoverCollections, tt as createHostSlot } from "../../discovery-CKR4TOX3.js";
+import { A as buildCollectionActionSeedPrompt, P as readSkillTemplate, j as promptPathsFor } from "../../server-D_6FLygK.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-L59cIGgX.js";
 import { d as publish, n as clear } from "../../notifier-BdA5qzhe.js";
 import path from "node:path";
 import { createHash } from "node:crypto";

package/dist/files/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("../rolldown-runtime-D6vf50IK.cjs");
 const require_atomic = require("../atomic-C_7YpMiM.cjs");
+const require_relPath = require("../relPath-CgGi4-Nv.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -39,7 +40,9 @@ function realpathOrNull(absPath) {
 }
 //#endregion
 exports.isEnoent = isEnoent;
+exports.joinPosixRelPath = require_relPath.joinPosixRelPath;
 exports.resolveWithinRoot = resolveWithinRoot;
+exports.toPosixRelPath = require_relPath.toPosixRelPath;
 exports.writeFileAtomic = require_atomic.writeFileAtomic;
 exports.writeFileAtomicSync = require_atomic.writeFileAtomicSync;
 exports.writeJsonAtomic = writeJsonAtomic;

package/dist/files/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/files/json.ts","../../src/files/safe.ts"],"sourcesContent":["import { writeFileAtomic, type WriteAtomicOptions } from \"./atomic.js\";\n\nconst JSON_INDENT = 2;\n\n/** Atomic JSON write (2-space indent) — serialize then write through the atomic\n *  tmp-file + rename seam so a reader never sees a half-written document. */\nexport async function writeJsonAtomic(filePath: string, data: unknown, opts: WriteAtomicOptions = {}): Promise<void> {\n  await writeFileAtomic(filePath, JSON.stringify(data, null, JSON_INDENT), opts);\n}\n","import { realpathSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/** True for a `not found` filesystem error (ENOENT) — lets callers treat a\n *  missing file as an empty/default result instead of a thrown error. */\nexport function isEnoent(err: unknown): boolean {\n  return typeof err === \"object\" && err !== null && \"code\" in err && err.code === \"ENOENT\";\n}\n\n/** Realpath-based read-time containment: resolve `relPath` against the root's\n *  realpath and require the target's realpath to stay inside it. Returns null\n *  on ENOENT or traversal (symlink escapes included). `rootReal` MUST already\n *  be a realpath. The one implementation for host and plugins (#2461) — this\n *  security-critical primitive must not drift per consumer. */\nexport function resolveWithinRoot(rootReal: string, relPath: string): string | null {\n  const normalized = path.normalize(relPath || \"\");\n  const resolved = path.resolve(rootReal, normalized);\n  const resolvedReal = realpathOrNull(resolved);\n  if (resolvedReal === null) return null;\n  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + path.sep)) {\n    return null;\n  }\n  return resolvedReal;\n}\n\nfunction realpathOrNull(absPath: string): string | null {\n  try {\n    return realpathSync(absPath);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;;;AAEA,IAAM,cAAc;;;AAIpB,eAAsB,gBAAgB,UAAkB,MAAe,OAA2B,CAAC,GAAkB;CACnH,MAAM,eAAA,gBAAgB,UAAU,KAAK,UAAU,MAAM,MAAM,WAAW,GAAG,IAAI;AAC/E;;;;;ACHA,SAAgB,SAAS,KAAuB;CAC9C,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,IAAI,SAAS;AAClF;;;;;;AAOA,SAAgB,kBAAkB,UAAkB,SAAgC;CAClF,MAAM,aAAa,UAAA,QAAK,UAAU,WAAW,EAAE;CAE/C,MAAM,eAAe,eADJ,UAAA,QAAK,QAAQ,UAAU,UACJ,CAAQ;CAC5C,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,iBAAiB,YAAY,CAAC,aAAa,WAAW,WAAW,UAAA,QAAK,GAAG,GAC3E,OAAO;CAET,OAAO;AACT;AAEA,SAAS,eAAe,SAAgC;CACtD,IAAI;EACF,QAAA,GAAA,QAAA,aAAA,CAAoB,OAAO;CAC7B,QAAQ;EACN,OAAO;CACT;AACF"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/files/json.ts","../../src/files/safe.ts"],"sourcesContent":["import { writeFileAtomic, type WriteAtomicOptions } from \"./atomic.js\";\n\nconst JSON_INDENT = 2;\n\n/** Atomic JSON write (2-space indent) — serialize then write through the atomic\n *  tmp-file + rename seam so a reader never sees a half-written document. */\nexport async function writeJsonAtomic(filePath: string, data: unknown, opts: WriteAtomicOptions = {}): Promise<void> {\n  await writeFileAtomic(filePath, JSON.stringify(data, null, JSON_INDENT), opts);\n}\n","import { realpathSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/** True for a `not found` filesystem error (ENOENT) — lets callers treat a\n *  missing file as an empty/default result instead of a thrown error. */\nexport function isEnoent(err: unknown): boolean {\n  return typeof err === \"object\" && err !== null && \"code\" in err && err.code === \"ENOENT\";\n}\n\n/** Realpath-based read-time containment: resolve `relPath` against the root's\n *  realpath and require the target's realpath to stay inside it. Returns null\n *  on ENOENT or traversal (symlink escapes included). `rootReal` MUST already\n *  be a realpath. The one implementation for host and plugins (#2461) — this\n *  security-critical primitive must not drift per consumer. */\nexport function resolveWithinRoot(rootReal: string, relPath: string): string | null {\n  const normalized = path.normalize(relPath || \"\");\n  const resolved = path.resolve(rootReal, normalized);\n  const resolvedReal = realpathOrNull(resolved);\n  if (resolvedReal === null) return null;\n  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + path.sep)) {\n    return null;\n  }\n  return resolvedReal;\n}\n\nfunction realpathOrNull(absPath: string): string | null {\n  try {\n    return realpathSync(absPath);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;;;;AAEA,IAAM,cAAc;;;AAIpB,eAAsB,gBAAgB,UAAkB,MAAe,OAA2B,CAAC,GAAkB;CACnH,MAAM,eAAA,gBAAgB,UAAU,KAAK,UAAU,MAAM,MAAM,WAAW,GAAG,IAAI;AAC/E;;;;;ACHA,SAAgB,SAAS,KAAuB;CAC9C,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,IAAI,SAAS;AAClF;;;;;;AAOA,SAAgB,kBAAkB,UAAkB,SAAgC;CAClF,MAAM,aAAa,UAAA,QAAK,UAAU,WAAW,EAAE;CAE/C,MAAM,eAAe,eADJ,UAAA,QAAK,QAAQ,UAAU,UACJ,CAAQ;CAC5C,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,iBAAiB,YAAY,CAAC,aAAa,WAAW,WAAW,UAAA,QAAK,GAAG,GAC3E,OAAO;CAET,OAAO;AACT;AAEA,SAAS,eAAe,SAAgC;CACtD,IAAI;EACF,QAAA,GAAA,QAAA,aAAA,CAAoB,OAAO;CAC7B,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/files/index.d.ts

@@ -1,3 +1,4 @@
 export { writeFileAtomic, writeFileAtomicSync, type WriteAtomicOptions } from './atomic.js';
 export { writeJsonAtomic } from './json.js';
 export { isEnoent, resolveWithinRoot } from './safe.js';
+export { toPosixRelPath, joinPosixRelPath } from './relPath.js';

package/dist/files/index.js

@@ -1,4 +1,5 @@
 import { n as writeFileAtomicSync, t as writeFileAtomic } from "../atomic-DPpdrJzO.js";
+import { n as toPosixRelPath, t as joinPosixRelPath } from "../relPath-DW8MC8VO.js";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 //#region src/files/json.ts
@@ -35,6 +36,6 @@ function realpathOrNull(absPath) {
 	}
 }
 //#endregion
-export { isEnoent, resolveWithinRoot, writeFileAtomic, writeFileAtomicSync, writeJsonAtomic };
+export { isEnoent, joinPosixRelPath, resolveWithinRoot, toPosixRelPath, writeFileAtomic, writeFileAtomicSync, writeJsonAtomic };
 
 //# sourceMappingURL=index.js.map

package/dist/files/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/files/json.ts","../../src/files/safe.ts"],"sourcesContent":["import { writeFileAtomic, type WriteAtomicOptions } from \"./atomic.js\";\n\nconst JSON_INDENT = 2;\n\n/** Atomic JSON write (2-space indent) — serialize then write through the atomic\n *  tmp-file + rename seam so a reader never sees a half-written document. */\nexport async function writeJsonAtomic(filePath: string, data: unknown, opts: WriteAtomicOptions = {}): Promise<void> {\n  await writeFileAtomic(filePath, JSON.stringify(data, null, JSON_INDENT), opts);\n}\n","import { realpathSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/** True for a `not found` filesystem error (ENOENT) — lets callers treat a\n *  missing file as an empty/default result instead of a thrown error. */\nexport function isEnoent(err: unknown): boolean {\n  return typeof err === \"object\" && err !== null && \"code\" in err && err.code === \"ENOENT\";\n}\n\n/** Realpath-based read-time containment: resolve `relPath` against the root's\n *  realpath and require the target's realpath to stay inside it. Returns null\n *  on ENOENT or traversal (symlink escapes included). `rootReal` MUST already\n *  be a realpath. The one implementation for host and plugins (#2461) — this\n *  security-critical primitive must not drift per consumer. */\nexport function resolveWithinRoot(rootReal: string, relPath: string): string | null {\n  const normalized = path.normalize(relPath || \"\");\n  const resolved = path.resolve(rootReal, normalized);\n  const resolvedReal = realpathOrNull(resolved);\n  if (resolvedReal === null) return null;\n  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + path.sep)) {\n    return null;\n  }\n  return resolvedReal;\n}\n\nfunction realpathOrNull(absPath: string): string | null {\n  try {\n    return realpathSync(absPath);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;AAEA,IAAM,cAAc;;;AAIpB,eAAsB,gBAAgB,UAAkB,MAAe,OAA2B,CAAC,GAAkB;CACnH,MAAM,gBAAgB,UAAU,KAAK,UAAU,MAAM,MAAM,WAAW,GAAG,IAAI;AAC/E;;;;;ACHA,SAAgB,SAAS,KAAuB;CAC9C,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,IAAI,SAAS;AAClF;;;;;;AAOA,SAAgB,kBAAkB,UAAkB,SAAgC;CAClF,MAAM,aAAa,KAAK,UAAU,WAAW,EAAE;CAE/C,MAAM,eAAe,eADJ,KAAK,QAAQ,UAAU,UACJ,CAAQ;CAC5C,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,iBAAiB,YAAY,CAAC,aAAa,WAAW,WAAW,KAAK,GAAG,GAC3E,OAAO;CAET,OAAO;AACT;AAEA,SAAS,eAAe,SAAgC;CACtD,IAAI;EACF,OAAO,aAAa,OAAO;CAC7B,QAAQ;EACN,OAAO;CACT;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/files/json.ts","../../src/files/safe.ts"],"sourcesContent":["import { writeFileAtomic, type WriteAtomicOptions } from \"./atomic.js\";\n\nconst JSON_INDENT = 2;\n\n/** Atomic JSON write (2-space indent) — serialize then write through the atomic\n *  tmp-file + rename seam so a reader never sees a half-written document. */\nexport async function writeJsonAtomic(filePath: string, data: unknown, opts: WriteAtomicOptions = {}): Promise<void> {\n  await writeFileAtomic(filePath, JSON.stringify(data, null, JSON_INDENT), opts);\n}\n","import { realpathSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/** True for a `not found` filesystem error (ENOENT) — lets callers treat a\n *  missing file as an empty/default result instead of a thrown error. */\nexport function isEnoent(err: unknown): boolean {\n  return typeof err === \"object\" && err !== null && \"code\" in err && err.code === \"ENOENT\";\n}\n\n/** Realpath-based read-time containment: resolve `relPath` against the root's\n *  realpath and require the target's realpath to stay inside it. Returns null\n *  on ENOENT or traversal (symlink escapes included). `rootReal` MUST already\n *  be a realpath. The one implementation for host and plugins (#2461) — this\n *  security-critical primitive must not drift per consumer. */\nexport function resolveWithinRoot(rootReal: string, relPath: string): string | null {\n  const normalized = path.normalize(relPath || \"\");\n  const resolved = path.resolve(rootReal, normalized);\n  const resolvedReal = realpathOrNull(resolved);\n  if (resolvedReal === null) return null;\n  if (resolvedReal !== rootReal && !resolvedReal.startsWith(rootReal + path.sep)) {\n    return null;\n  }\n  return resolvedReal;\n}\n\nfunction realpathOrNull(absPath: string): string | null {\n  try {\n    return realpathSync(absPath);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;AAEA,IAAM,cAAc;;;AAIpB,eAAsB,gBAAgB,UAAkB,MAAe,OAA2B,CAAC,GAAkB;CACnH,MAAM,gBAAgB,UAAU,KAAK,UAAU,MAAM,MAAM,WAAW,GAAG,IAAI;AAC/E;;;;;ACHA,SAAgB,SAAS,KAAuB;CAC9C,OAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,UAAU,OAAO,IAAI,SAAS;AAClF;;;;;;AAOA,SAAgB,kBAAkB,UAAkB,SAAgC;CAClF,MAAM,aAAa,KAAK,UAAU,WAAW,EAAE;CAE/C,MAAM,eAAe,eADJ,KAAK,QAAQ,UAAU,UACJ,CAAQ;CAC5C,IAAI,iBAAiB,MAAM,OAAO;CAClC,IAAI,iBAAiB,YAAY,CAAC,aAAa,WAAW,WAAW,KAAK,GAAG,GAC3E,OAAO;CAET,OAAO;AACT;AAEA,SAAS,eAAe,SAAgC;CACtD,IAAI;EACF,OAAO,aAAa,OAAO;CAC7B,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/files/relPath.d.ts

@@ -0,0 +1,23 @@
+/** Convert a host-shaped workspace-relative path to the POSIX form.
+ *
+ *  Splits on the host separator rather than rewriting every `\` — on POSIX a
+ *  backslash is a legal filename character, so a blanket replace would turn the
+ *  single directory `we\ird` into the two segments `we/ird` and send the write
+ *  somewhere else. Splitting on `path.sep` is a no-op on POSIX and correct on
+ *  Windows.
+ *
+ *  `sep` is a parameter so the Windows rule is assertable from a POSIX runner:
+ *  bound to the host's own separator, the whole rule is invisible outside
+ *  Windows CI, which is how the backslash form reached main twice (#2540).
+ *
+ *  Separator shape only — it neither validates nor contains. A traversal or a
+ *  drive-absolute input survives as one, deliberately, so `resolveWithinRoot`
+ *  downstream can still see the escape it has to refuse. */
+export declare function toPosixRelPath(hostRelPath: string, sep?: string): string;
+/** Append a single path segment to a POSIX workspace-relative path.
+ *
+ *  Separate from `toPosixRelPath` because the inputs differ: this one joins
+ *  segments that are ALREADY POSIX-shaped (a parent rel path plus one
+ *  `Dirent.name`), so it must not touch the characters inside them. Use
+ *  `toPosixRelPath` first when the parent came out of `node:path`. */
+export declare function joinPosixRelPath(dirRelPosix: string, segment: string): string;

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

@@ -4,7 +4,7 @@ const require_dist = require("../dist-pWpC-b04.cjs");
 const require_text = require("../text-CaAh9ZSO.cjs");
 const require_atomic = require("../atomic-C_7YpMiM.cjs");
 const require_utils_fetch = require("../utils/fetch.cjs");
-const require_discovery = require("../discovery-UxkvBxV-.cjs");
+const require_discovery = require("../discovery--kRUWed0.cjs");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -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;