@plinth-music/cli 0.23.0 → 0.23.1

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 Notable changes to `@plinth-music/cli`. Grouped by what a user notices, not by PR.
 
+## 0.23.1 - 2026-09-29
+
+Two code PRs since `0.23.0` (`v0.23.0..0dd34dc`: #212, #213; #209, #210 and #211 docs).
+A patch: fixes only, no new command or sync surface.
+
+⚠️ **A file you delete from the mirror stays deleted** (#213). A poll landing in the
+second or so between your `rm` and the daemon's delete hold could write the file back,
+and the delete was then dropped; four of seven documents came back this way on 26 Sept.
+The daemon now leaves a path it saw you remove alone for five minutes, and waits one
+poll before restoring a file that is missing for a reason it has not seen yet. A file
+missing for any other reason is still restored, about one poll later than before.
+
+⚠️ **One slow calendar no longer freezes every calendar view** (#212). A calendar whose
+read fails or times out now shows as not read, with no entries, until the next refresh.
+Before, the whole refresh failed and every `views/calendar/` file kept its old contents.
+A read that did not complete is described as incomplete, not as Google refusing access.
+
+**The daemon stops re-downloading what has not changed** (#213). Since 0.22.0 every
+poll fetched every memory fact in full, left `_freshness.md` reporting memory as
+`unknown` / `incomplete_apply`, and re-fetched the extracted text of every PDF. Both now
+happen once. Feeds ask from the server's high-water mark instead of re-reading their
+last page; a full read from the cursor still runs at boot, on `plinth sync` and once an
+hour, so nothing is missed. On the release commit, over 47 minutes after the first pass:
+no full memory-fact downloads, no text re-fetches, no inconsistent trails.
+
+**Each calendar view says what it covers** (#212). A view holds only its window and now
+says so, naming the Plinth tool `list_calendar_events` for any other date. A truncated
+read says why it was cut short.
+
+**What is not proven.**
+
+- The delete fix was driven live on the release commit (a delete inside a poll, and a
+  held batch left 13 minutes past the window: neither came back). A delete within about
+  1.6 s of the lid closing has one exposed poll on wake.
+- The calendar changes were not exercised live: the test workspace has no mapped
+  calendar. They are covered by tests and are checked on a real workspace after release.
+- A sync request that hangs can still stall the poll loop for minutes (seen once, 4 min
+  7 s, in the release check). Pre-existing; not fixed here.
+
 ## 0.23.0 - 2026-09-23
 
 One code PR since `0.22.0` (`v0.22.0..f3334fb`, #207; #204, #205 and #206 docs). A

package/dist/build-stamp.json

@@ -1,5 +1,5 @@
 {
-  "sha": "38edb48dcebc2bbe3f1609c939e93143a8946037",
+  "sha": "9dd9f6493dc707acce22c95ce564d8b189dbf27d",
   "dirty": false,
-  "built_at": "2026-09-23T22:08:55.967Z"
+  "built_at": "2026-09-29T22:26:55.840Z"
 }

package/dist/cli.js

@@ -7584,7 +7584,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "@plinth-music/cli",
-  version: "0.23.0",
+  version: "0.23.1",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -22168,7 +22168,8 @@ var TombstoneSchema = exports_external.object({
 function makePageResponseSchema(responseKey, liveSchema) {
   return exports_external.object({
     [responseKey]: exports_external.array(exports_external.union([liveSchema, TombstoneSchema])),
-    next_cursor: exports_external.string().nullable()
+    next_cursor: exports_external.string().nullable(),
+    high_water: exports_external.string().nullable().optional()
   });
 }
 function makeParsePageResponse(schema, responseKey) {
@@ -22176,7 +22177,8 @@ function makeParsePageResponse(schema, responseKey) {
     const parsed = schema.parse(json2);
     return {
       rows: parsed[responseKey],
-      next_cursor: parsed.next_cursor
+      next_cursor: parsed.next_cursor,
+      high_water: parsed.high_water ?? null
     };
   };
 }
@@ -25345,7 +25347,8 @@ var WorkspaceEntrySchema = exports_external.object({
   last_synced_at: exports_external.string().datetime({ offset: true }).nullable(),
   workspace_name: exports_external.string().min(1).optional(),
   member: MemberPrincipalSchema.optional(),
-  sync_cursors: SyncCursorsSchema.optional()
+  sync_cursors: SyncCursorsSchema.optional(),
+  sync_high_water: SyncCursorsSchema.optional()
 });
 var ConfigFileSchema = exports_external.object({
   version: exports_external.literal(1),
@@ -25407,7 +25410,8 @@ function carryForwardSyncState(prior, entry) {
   return {
     ...entry,
     last_synced_at: prior.last_synced_at,
-    ...prior.sync_cursors !== undefined ? { sync_cursors: prior.sync_cursors } : {}
+    ...prior.sync_cursors !== undefined ? { sync_cursors: prior.sync_cursors } : {},
+    ...prior.sync_high_water !== undefined ? { sync_high_water: prior.sync_high_water } : {}
   };
 }
 function upsertWorkspace(slug, entry, options2 = {}) {
@@ -25448,6 +25452,23 @@ function updateSyncCursor(slug, entityType, cursor) {
   writeAtomic(next);
   return next;
 }
+function updateSyncHighWater(slug, entityType, mark) {
+  const existing = loadConfig();
+  if (!existing) {
+    throw new Error(`No config. Run \`plinth login --workspace ${slug}\` first.`);
+  }
+  const entry = requireWorkspace(existing, slug);
+  if ((entry.sync_high_water?.[entityType] ?? null) === mark)
+    return;
+  const nextEntry = {
+    ...entry,
+    sync_high_water: { ...entry.sync_high_water, [entityType]: mark }
+  };
+  writeAtomic({
+    ...existing,
+    workspaces: { ...existing.workspaces, [slug]: nextEntry }
+  });
+}
 function setMemberPrincipal(slug, member) {
   const existing = loadConfig();
   if (!existing)
@@ -26735,7 +26756,7 @@ function allFileEntries(state) {
   return Object.values(state.files ?? {});
 }
 function fileEntriesEqual(a, b) {
-  return a.id === b.id && a.path === b.path && a.content_hash === b.content_hash && a.size_bytes === b.size_bytes && a.mime_type === b.mime_type && a.updated_at === b.updated_at && a.inode === b.inode;
+  return a.id === b.id && a.path === b.path && a.content_hash === b.content_hash && a.size_bytes === b.size_bytes && a.mime_type === b.mime_type && a.updated_at === b.updated_at && a.inode === b.inode && a.text_hash === b.text_hash;
 }
 function clearFrontmatterIdBackfillMarker(state) {
   if (state.frontmatter_id_backfill_version === undefined) {
@@ -30195,7 +30216,8 @@ var FileTombstoneSchema = exports_external.object({
 var FileRowSchema = exports_external.union([FileLiveSchema, FileTombstoneSchema]);
 var FilesPageSchema = exports_external.object({
   files: exports_external.array(FileRowSchema),
-  next_cursor: exports_external.string().nullable()
+  next_cursor: exports_external.string().nullable(),
+  high_water: exports_external.string().nullable().optional()
 });
 var FileWithDownloadSchema = FileLiveSchema.extend({
   download_url: exports_external.string().url().nullable()
@@ -30248,7 +30270,11 @@ async function syncFilesPage(args) {
   if (!parsed.success) {
     throw new ApiError(res.status, `sync files response did not match the expected shape: ${parsed.error.message}`);
   }
-  return { rows: parsed.data.files, next_cursor: parsed.data.next_cursor };
+  return {
+    rows: parsed.data.files,
+    next_cursor: parsed.data.next_cursor,
+    high_water: parsed.data.high_water ?? null
+  };
 }
 async function getFile(args) {
   const { baseUrl, pat, id, fetchImpl = fetch } = args;
@@ -30519,6 +30545,12 @@ function fileDeleteSuppressedLine(f) {
 function entityDeleteSuppressedLine(f) {
   return `[ENTITY_DELETE_SUPPRESSED entityType=${f.entityType} slug=${f.slug} reason=${f.reason}]`;
 }
+function entityRestoreDeferredLine(f) {
+  return `[ENTITY_RESTORE_DEFERRED entityType=${f.entityType} slug=${f.slug} wait_s=${f.waitSeconds}]`;
+}
+function fileRestoreDeferredLine(f) {
+  return `[FILE_RESTORE_DEFERRED path=${f.path} wait_s=${f.waitSeconds}]`;
+}
 function fileOverCapLine(f) {
   return `[FILE_OVER_CAP path=${f.path} size=${f.size} max=${f.max} max_from=${f.source}]`;
 }
@@ -38054,7 +38086,7 @@ function unknownBecause(reason) {
     case "no_watermark":
       return "The last download carried no freshness marker, so there is nothing to compare against.";
     case "incomplete_apply":
-      return "The last download did not fully land, so this copy is not the one the freshness marker describes.";
+      return "The last download either did not fully land or carried a correction trail this copy could not use, so this copy is not one the freshness marker can vouch for.";
     case "check_failed":
       return "The freshness check did not complete.";
     default:
@@ -38211,6 +38243,9 @@ function resolveTrail(row, slugById) {
       consistent: true
     };
   }
+  if (outcome === "current" && successor === row.id) {
+    return { trail: "current", consistent: true };
+  }
   if (successor !== null)
     return { trail: UNKNOWN, consistent: false };
   return { trail: outcome, consistent: true };
@@ -40675,7 +40710,12 @@ function startWatcher(opts, handler) {
   });
   watcher.on("add", (p) => classifier.onAdd(p));
   watcher.on("change", (p) => classifier.onChange(p));
-  watcher.on("unlink", (p) => classifier.onUnlink(p));
+  watcher.on("unlink", (p) => {
+    try {
+      opts.onUnlink?.(p);
+    } catch {}
+    classifier.onUnlink(p);
+  });
   return {
     async stop() {
       classifier.shutdown();
@@ -42799,6 +42839,109 @@ class PullLoop {
   }
 }
 
+// src/lib/high-water.ts
+var HIGH_WATER_BASE_READ_MS = 60 * 60 * 1000;
+function baseReadIntervalMs(env2 = process.env) {
+  const raw = Number(env2.PLINTH_HIGH_WATER_BASE_READ_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : HIGH_WATER_BASE_READ_MS;
+}
+function provenMark(args) {
+  if (!args.clean)
+    return null;
+  return args.finalHighWater ?? args.advancedTo;
+}
+function createBaseReadSchedule(bootMs, intervalMs = HIGH_WATER_BASE_READ_MS) {
+  let lastBaseReadMs = bootMs;
+  let restoresWaiting = false;
+  let lastUsedHighWater = false;
+  return {
+    useHighWater(nowMs) {
+      if (restoresWaiting)
+        return lastUsedHighWater;
+      return nowMs - lastBaseReadMs < intervalMs;
+    },
+    completed(nowMs, usedHighWater, ok, restoresDeferred = 0) {
+      if (!ok)
+        return;
+      if (!usedHighWater)
+        lastBaseReadMs = nowMs;
+      restoresWaiting = restoresDeferred > 0;
+      lastUsedHighWater = usedHighWater;
+    }
+  };
+}
+
+// src/lib/restore-deferral.ts
+var RESTORE_DEFERRAL_MS = 5 * 60000;
+var UNEXPLAINED_GRACE_MS = 5000;
+function keyOf(absolutePath) {
+  return absolutePath.normalize("NFC");
+}
+function sightingKey(key, version2) {
+  return `${key}\x00${version2}`;
+}
+function forgetSightings(recent, key) {
+  const prefix = `${key}\x00`;
+  for (const k of recent.keys())
+    if (k.startsWith(prefix))
+      recent.delete(k);
+}
+function noteUnlink(recent, absolutePath, nowMs) {
+  forgetExpired(recent, nowMs);
+  const key = keyOf(absolutePath);
+  forgetSightings(recent, key);
+  recent.set(key, { kind: "unlink", at: nowMs, logged: false });
+}
+function deferRestore(recent, absolutePath, version2, nowMs) {
+  if (!recent)
+    return { defer: false, first: false };
+  forgetExpired(recent, nowMs);
+  const key = keyOf(absolutePath);
+  const unlinked = recent.get(key);
+  if (unlinked?.kind === "unlink") {
+    if (unlinked.logged)
+      return { defer: true, first: false };
+    recent.set(key, { ...unlinked, logged: true });
+    return { defer: true, first: true };
+  }
+  const sighting = sightingKey(key, version2);
+  const seen = recent.get(sighting);
+  if (seen === undefined) {
+    recent.set(sighting, { kind: "missing", at: nowMs });
+    return { defer: true, first: false };
+  }
+  if (nowMs - seen.at < UNEXPLAINED_GRACE_MS)
+    return { defer: true, first: false };
+  recent.delete(sighting);
+  return { defer: false, first: false };
+}
+function presentAgain(recent, absolutePath) {
+  if (recent)
+    forgetSightings(recent, keyOf(absolutePath));
+}
+function forgetExpired(recent, nowMs) {
+  for (const [key, seen] of recent) {
+    if (seen.kind === "unlink" && nowMs - seen.at >= RESTORE_DEFERRAL_MS)
+      recent.delete(key);
+  }
+}
+
+// src/lib/ambient-poll.ts
+function createAmbientPollWiring(opts) {
+  const recentUnlinks = new Map;
+  const baseReads = createBaseReadSchedule(opts.now(), opts.baseReadIntervalMs);
+  return {
+    onUnlink: (absolutePath) => noteUnlink(recentUnlinks, absolutePath, opts.now()),
+    async poll(run) {
+      const startMs = opts.now();
+      const useHighWater = baseReads.useHighWater(startMs);
+      const result = await run({ useHighWater, recentUnlinks });
+      baseReads.completed(startMs, useHighWater, result.exitCode === 0, result.restoresDeferred ?? 0);
+      return result;
+    }
+  };
+}
+
 // src/lib/calendar-loop.ts
 var DEFAULT_CALENDAR_INTERVAL_MS = 900000;
 var CALENDAR_BACKOFF_CAP_MS = 3600000;
@@ -42959,6 +43102,12 @@ var CALENDAR_STATUSES = [
   "token-expired",
   "google-error"
 ];
+var KNOWN_TRUNCATED_REASONS = ["page_limit", "time_limit"];
+var TruncatedReasonSchema = exports_external.string().nullish().transform((v) => {
+  if (v === null || v === undefined)
+    return null;
+  return KNOWN_TRUNCATED_REASONS.includes(v) ? v : "other";
+});
 var CalendarRowSchema = exports_external.object({
   artist_id: exports_external.string().nullable(),
   artist_slug: exports_external.string().nullable(),
@@ -42967,8 +43116,13 @@ var CalendarRowSchema = exports_external.object({
   calendar_name: exports_external.string(),
   status: exports_external.enum(CALENDAR_STATUSES),
   events: exports_external.array(CalendarEventSchema).nullable(),
-  error: exports_external.object({ upstream_status: exports_external.number(), message: exports_external.string() }).nullish().transform((v) => v ?? null),
-  truncated: exports_external.boolean().optional().default(false)
+  error: exports_external.object({
+    upstream_status: exports_external.number().nullable(),
+    message: exports_external.string()
+  }).nullish().transform((v) => v ?? null),
+  truncated: exports_external.boolean().optional().default(false),
+  truncated_reason: TruncatedReasonSchema,
+  resume_from: exports_external.string().nullish().transform((v) => v ?? null)
 });
 var CalendarResponseSchema = exports_external.object({
   generated_at: exports_external.string().min(1),
@@ -43156,6 +43310,62 @@ function readAsOf(text, today) {
   return { parts, yearInferred: first.yearInferred };
 }
 
+// src/lib/calendar/limits.ts
+var CALENDAR_RANGE_TOOL = "list_calendar_events";
+function spanPhrase(timeMin, timeMax) {
+  const ms = Date.parse(timeMax) - Date.parse(timeMin);
+  if (!Number.isFinite(ms) || ms <= 0)
+    return null;
+  const weeks = ms / (7 * DAY_MS);
+  if (Number.isInteger(weeks))
+    return `${weeks} ${weeks === 1 ? "week" : "weeks"}`;
+  const days = ms / DAY_MS;
+  if (Number.isInteger(days))
+    return `${days} ${days === 1 ? "day" : "days"}`;
+  return null;
+}
+function coverageLine(timeMin, timeMax) {
+  const span = spanPhrase(timeMin, timeMax);
+  return `**This file holds only the window above${span ? ` (${span})` : ""}.** ` + `When a question needs a date outside it, past or future, call the Plinth ` + `tool \`${CALENDAR_RANGE_TOOL}\` for just that range.`;
+}
+var TRUNCATION_CAUSE = {
+  page_limit: "Google had more entries in this window than one refresh reads.",
+  time_limit: "The read from Google ran out of time.",
+  other: "The read stopped before the end of the window."
+};
+var TRUNCATION_SHORT = {
+  page_limit: "stopped at the page limit",
+  time_limit: "ran out of time",
+  other: "stopped before the end of the window"
+};
+var OFFSET_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})$/i;
+function resumeRange(resumeFrom, window2) {
+  if (resumeFrom === null || !OFFSET_TIMESTAMP_RE.test(resumeFrom))
+    return null;
+  if (!OFFSET_TIMESTAMP_RE.test(window2.time_min) || !OFFSET_TIMESTAMP_RE.test(window2.time_max)) {
+    return null;
+  }
+  const at = Date.parse(resumeFrom);
+  const min = Date.parse(window2.time_min);
+  const max = Date.parse(window2.time_max);
+  if (!(at > min && at < max))
+    return null;
+  return { from: new Date(at).toISOString(), to: new Date(max).toISOString() };
+}
+function incompleteLine(args) {
+  const { stamp: stamp2, eventCount, reason, resumeFrom, window: window2 } = args;
+  const kept = eventCount === 0 ? "No entries were collected before the read stopped, so this is NOT a clear diary." : `${eventCount} ${eventCount === 1 ? "entry was" : "entries were"} collected before the read stopped.`;
+  const range = resumeRange(resumeFrom, window2);
+  const pointer = range ? ` For the rest, call the Plinth tool \`${CALENDAR_RANGE_TOOL}\` from ` + `\`${range.from}\` to \`${range.to}\` (a few entries repeat).` : ` For the rest, call the Plinth tool \`${CALENDAR_RANGE_TOOL}\` for a ` + `narrower range inside the window.`;
+  return `**Read as of ${stamp2}, but this list is INCOMPLETE.** ` + `${TRUNCATION_CAUSE[reason ?? "other"]} ${kept} ` + `The rest of the window is not included: unknown, not absent.${pointer}`;
+}
+function sentence(text) {
+  return /[.!?\u2026]$/.test(text) ? text : `${text}.`;
+}
+function truncationShort(reason) {
+  return TRUNCATION_SHORT[reason ?? "other"];
+}
+
 // src/lib/calendar/render.ts
 var CALENDAR_BODY_MARKER = "<!-- PLINTH:CALENDAR-BODY -->";
 var OWNERSHIP_NOTE2 = [
@@ -43259,37 +43469,61 @@ function windowLine(timeMin, timeMax) {
     return `${timeMin} to ${timeMax}`;
   return `${formatDay(from, -1)} to ${formatDay(to, -1)}`;
 }
+function isRefusal(error52) {
+  return error52.upstream_status !== null && error52.upstream_status >= 400;
+}
+function googleErrorLine(error52) {
+  if (error52 !== null && !isRefusal(error52)) {
+    return `**NOT READ - the read from Google did not complete.** ` + `${sentence(oneLine2(error52.message, 300))} The next refresh retries; until then ` + `nothing below is current, so treat this calendar as unknown rather than empty. ` + `For a date on it you need now, call the Plinth tool \`${CALENDAR_RANGE_TOOL}\` ` + `for a narrower range.`;
+  }
+  return `**NOT READ - Google refused the request` + `${error52 ? ` (HTTP ${error52.upstream_status})` : ""}.** ` + `${error52 ? sentence(oneLine2(error52.message, 300)) : "No detail was returned."} ` + `A calendar that was unshared or deleted in Google reads exactly like this. ` + `Nothing below is current; treat this calendar as unknown rather than empty.`;
+}
 function statusLine(args) {
   const { status, eventCount, error: error52, truncated, stamp: stamp2, userLabel } = args;
   switch (status) {
     case "fetched": {
+      if (truncated) {
+        return incompleteLine({
+          stamp: stamp2,
+          eventCount,
+          reason: args.truncatedReason,
+          resumeFrom: args.resumeFrom,
+          window: args.window
+        });
+      }
       if (eventCount === 0) {
         return `**Read fine as of ${stamp2}. Nothing in this window.** The diary really ` + `is clear across the dates above. This is a successful read of an empty ` + `calendar, not a failed read - if it had failed, this line would say so.`;
       }
-      const truncatedNote = truncated ? " **This list is INCOMPLETE**: Google had more entries than one page and the rest were not collected." : "";
-      return `**Read fine as of ${stamp2}.** ${eventCount} ` + `${eventCount === 1 ? "entry" : "entries"} in the window.${truncatedNote}`;
+      return `**Read fine as of ${stamp2}.** ${eventCount} ` + `${eventCount === 1 ? "entry" : "entries"} in the window.`;
     }
     case "no-token":
       return `**NOT READ - Google is not connected for ${userLabel}.** Nothing is listed ` + `below because Plinth could not look, NOT because the diary is clear. ` + `Connect Google in Plinth to fill this in, and until then treat this ` + `calendar as unknown rather than empty.`;
     case "token-expired":
       return `**NOT READ - the Google connection for ${userLabel} has expired.** Plinth ` + `still holds a connection but could not refresh it, so nothing below is ` + `current. Reconnect Google in Plinth. Treat this calendar as unknown ` + `rather than empty.`;
     case "google-error":
-      return `**NOT READ - Google refused the request` + `${error52 ? ` (HTTP ${error52.upstream_status})` : ""}.** ` + `${error52 ? oneLine2(error52.message, 300) : "No detail was returned."} ` + `A calendar that was unshared or deleted in Google reads exactly like this. ` + `Nothing below is current; treat this calendar as unknown rather than empty.`;
+      return googleErrorLine(error52);
   }
 }
 function shortStatus(row) {
   switch (row.status) {
     case "fetched": {
       const n = row.events?.length ?? 0;
+      const count = `${n} ${n === 1 ? "entry" : "entries"}`;
+      if (row.truncated) {
+        return `read, ${count}, INCOMPLETE (${truncationShort(row.truncated_reason)}); ` + `the rest of the window is unknown, not empty`;
+      }
       if (n === 0)
         return "read fine, nothing in this window";
-      return `read fine, ${n} ${n === 1 ? "entry" : "entries"}${row.truncated ? " (INCOMPLETE - more than one page)" : ""}`;
+      return `read fine, ${count}`;
     }
     case "no-token":
       return "NOT READ - Google is not connected; unknown, not empty";
     case "token-expired":
       return "NOT READ - the Google connection has expired; unknown, not empty";
     case "google-error":
+      if (row.error !== null && !isRefusal(row.error)) {
+        return `NOT READ - the read from Google did not complete: ` + `${oneLine2(row.error.message, 120)}; the next refresh retries; unknown, not empty`;
+      }
       return `NOT READ - Google refused` + `${row.error ? ` (HTTP ${row.error.upstream_status}): ${oneLine2(row.error.message, 120)}` : ""}` + `; unknown, not empty`;
   }
 }
@@ -43347,21 +43581,25 @@ function renderArtistCalendar(args) {
       eventCount: events.length,
       error: row.error,
       truncated: row.truncated,
+      truncatedReason: row.truncated_reason,
+      resumeFrom: row.resume_from,
+      window: window2,
       stamp: stamp2,
       userLabel
     }),
     "",
     `**Window:** ${windowLine(window2.time_min, window2.time_max)}.`,
     "",
+    ...row.status === "fetched" ? [coverageLine(window2.time_min, window2.time_max), ""] : [],
     "**Dates are read here and changed in Plinth's calendar view, by a person.** If something below needs moving, say what the change is and hand it over.",
     "",
-    renderBands(events, generatedAt, referenceYear, "")
+    renderBands(events, generatedAt, referenceYear, "", row.truncated)
   ].join(`
 `);
   return `${header}${CALENDAR_BODY_MARKER}
 ${body}`;
 }
-function renderBands(events, generatedAt, referenceYear, artistPrefix) {
+function renderBands(events, generatedAt, referenceYear, artistPrefix, truncated) {
   if (events.length === 0)
     return "";
   const { full, rest } = splitBands(events, generatedAt);
@@ -43375,7 +43613,7 @@ function renderBands(events, generatedAt, referenceYear, artistPrefix) {
   }
   out.push("", "## Rest of the window", "");
   if (rest.length === 0) {
-    out.push("_Nothing further in the window._");
+    out.push(truncated ? "_Nothing further was collected: the read stopped before the end of the window._" : "_Nothing further in the window._");
   } else {
     for (const e of rest)
       out.push(compactLine(e, referenceYear, artistPrefix));
@@ -43384,6 +43622,9 @@ function renderBands(events, generatedAt, referenceYear, artistPrefix) {
   return out.join(`
 `);
 }
+function lacksConnection(row) {
+  return row.status === "no-token" || row.status === "token-expired";
+}
 function renderUpcoming(args) {
   const {
     rows,
@@ -43399,6 +43640,7 @@ function renderUpcoming(args) {
   const fetched = rows.filter((r) => r.status === "fetched");
   const failed = rows.filter((r) => r.status !== "fetched");
   const truncatedAnywhere = rows.some((r) => r.truncated);
+  const cutShort = fetched.filter((r) => r.truncated).length;
   const merged = fetched.flatMap((row) => (row.events ?? []).map((event) => ({ event, row }))).sort((a, b) => sortInstant(a.event) - sortInstant(b.event));
   const { full, rest } = splitBands(merged.map((m) => m.event), generatedAt);
   const fullSet = new Set(full);
@@ -43429,7 +43671,12 @@ function renderUpcoming(args) {
     "",
     `**As of ${stamp2}.** Window ${windowLine(window2.time_min, window2.time_max)}.`,
     "",
+    ...rows.length > 0 && !rows.every(lacksConnection) ? [coverageLine(window2.time_min, window2.time_max), ""] : [],
     failed.length === 0 ? `**All ${fetched.length} mapped ${fetched.length === 1 ? "calendar was" : "calendars were"} read.**` : `**${fetched.length} of ${rows.length} mapped ${rows.length === 1 ? "calendar" : "calendars"} read; ${failed.length} could NOT be read.**` + ` Anything on an unread calendar is missing from the lists below - unknown, not absent.`,
+    ...cutShort === 0 ? [] : [
+      "",
+      `**${cutShort} of the calendars read ${cutShort === 1 ? "was" : "were"} cut short** before the end ` + `of the window, so entries past the point where ${cutShort === 1 ? "it" : "each"} stopped are ` + `missing from the lists below - unknown, not absent. The status list says which.`
+    ],
     "",
     `${artistCount} ${artistCount === 1 ? "artist" : "artists"} in the roster; ` + `${mappedArtistCount} ${mappedArtistCount === 1 ? "has" : "have"} a calendar mapped in Plinth.`,
     "",
@@ -43446,7 +43693,7 @@ function renderUpcoming(args) {
   body.push(`## Next ${FULL_BAND_DAYS} days`, "", "_Links are in the per-artist file named beside each calendar above._", "");
   const fullMerged = merged.filter((m) => fullSet.has(m.event));
   if (fullMerged.length === 0) {
-    body.push(fetched.length === 0 ? `_No calendar could be read, so nothing can be listed for the next ${FULL_BAND_DAYS} days._` : `_Nothing in the next ${FULL_BAND_DAYS} days on any calendar that was read._`);
+    body.push(fetched.length === 0 ? `_No calendar could be read, so nothing can be listed for the next ${FULL_BAND_DAYS} days._` : cutShort > 0 ? `_Nothing collected for the next ${FULL_BAND_DAYS} days on any calendar that was read; the ones cut short may be missing entries._` : `_Nothing in the next ${FULL_BAND_DAYS} days on any calendar that was read._`);
   } else {
     for (const { event, row } of fullMerged) {
       body.push(fullLine(event, referenceYear, `**${rowDisplayName(row)}**`, false));
@@ -43455,7 +43702,7 @@ function renderUpcoming(args) {
   body.push("", "## Rest of the window", "");
   const restMerged = merged.filter((m) => restSet.has(m.event));
   if (restMerged.length === 0) {
-    body.push(fetched.length === 0 ? "_No calendar could be read, so nothing can be listed._" : "_Nothing further in the window on any calendar that was read._");
+    body.push(fetched.length === 0 ? "_No calendar could be read, so nothing can be listed._" : cutShort > 0 ? "_Nothing further was collected on any calendar that was read; the ones cut short may be missing entries past where they stopped._" : "_Nothing further in the window on any calendar that was read._");
   } else {
     for (const { event, row } of restMerged) {
       body.push(compactLine(event, referenceYear, `**${rowDisplayName(row)}**`));
@@ -46061,7 +46308,8 @@ async function replayPermanentFiles(args, markers) {
   const now = args.now ?? (() => new Date);
   const rows = [];
   let cursor = null;
-  let resultingCursor = args.cursor;
+  const savedCursor = args.baseCursor === undefined ? args.cursor : args.baseCursor;
+  let resultingCursor = savedCursor;
   while (true) {
     const page = await syncFilesPage({
       baseUrl: args.baseUrl,
@@ -46084,6 +46332,7 @@ async function replayPermanentFiles(args, markers) {
   let pointerRows = 0;
   let symlinkRefused = 0;
   let stashFailed = 0;
+  let restoresDeferred = 0;
   let completePass = true;
   let lastCommittedState = args.state;
   const completed = [];
@@ -46172,7 +46421,8 @@ async function replayPermanentFiles(args, markers) {
       isFileFrozen: args.isFileFrozen,
       loggedTombstoneSkips: args.loggedTombstoneSkips,
       forceTextRewalk: args.forceTextRewalk,
-      loggedStashNotices: args.loggedStashNotices
+      loggedStashNotices: args.loggedStashNotices,
+      recentUnlinks: args.recentUnlinks
     });
     state = outcome.state;
     if (outcome.action === "written")
@@ -46189,11 +46439,15 @@ async function replayPermanentFiles(args, markers) {
       symlinkRefused++;
       completePass = false;
     }
-    if (outcome.stashFailed || outcome.textFailed) {
+    if (outcome.stashFailed || outcome.textFailed || outcome.integrityFailed) {
       if (outcome.stashFailed)
         stashFailed++;
       completePass = false;
     }
+    if (outcome.restoreDeferred) {
+      restoresDeferred++;
+      completePass = false;
+    }
   }
   if (args.commit && state !== lastCommittedState)
     state = args.commit(lastCommittedState, state);
@@ -46208,7 +46462,8 @@ async function replayPermanentFiles(args, markers) {
     pointerRows,
     symlinkRefused,
     stashFailed,
-    lastCursor: completePass ? resultingCursor : args.cursor,
+    lastCursor: completePass ? resultingCursor : savedCursor,
+    restoresDeferred,
     permanentRefreshes: completed,
     permanentReplayComplete: completePass
   };
@@ -46232,12 +46487,27 @@ async function pullFiles(args) {
   let pointerRows = 0;
   let symlinkRefused = 0;
   let stashFailed = 0;
+  let restoresDeferred = 0;
   let permanentEncountered = false;
+  const baseCursor = args.baseCursor === undefined ? args.cursor : args.baseCursor;
   let cursor = args.cursor;
   let lastCursor = args.cursor;
+  let finalHighWater = null;
+  let markRefused = false;
   let cursorBlocked = permanentJournalBlocked;
   while (true) {
-    const page = await syncFilesPage({ baseUrl, pat, cursor, fetchImpl });
+    let page;
+    try {
+      page = await syncFilesPage({ baseUrl, pat, cursor, fetchImpl });
+    } catch (err) {
+      if (!markRefused && cursor === args.cursor && args.cursor !== baseCursor && err instanceof ApiError && err.status === 400) {
+        markRefused = true;
+        cursor = baseCursor;
+        lastCursor = baseCursor;
+        continue;
+      }
+      throw err;
+    }
     const pageBase = state;
     let pageTextFailed = false;
     for (const row of page.rows) {
@@ -46271,7 +46541,8 @@ async function pullFiles(args) {
         isFileFrozen: args.isFileFrozen,
         loggedTombstoneSkips: args.loggedTombstoneSkips,
         forceTextRewalk: args.forceTextRewalk,
-        loggedStashNotices: args.loggedStashNotices
+        loggedStashNotices: args.loggedStashNotices,
+        recentUnlinks: args.recentUnlinks
       });
       state = outcome.state;
       if (!outcome.symlinkRefused) {
@@ -46297,13 +46568,21 @@ async function pullFiles(args) {
         stashFailed++;
         pageTextFailed = true;
       }
+      if (outcome.integrityFailed)
+        pageTextFailed = true;
+      if (outcome.restoreDeferred) {
+        restoresDeferred++;
+        pageTextFailed = true;
+      }
     }
     if (args.commit && state !== pageBase)
       state = args.commit(pageBase, state);
     if (pageTextFailed)
       cursorBlocked = true;
-    if (page.next_cursor === null)
+    if (page.next_cursor === null) {
+      finalHighWater = page.high_water ?? null;
       break;
+    }
     if (!cursorBlocked)
       lastCursor = page.next_cursor;
     cursor = page.next_cursor;
@@ -46340,7 +46619,14 @@ async function pullFiles(args) {
     pointerRows,
     symlinkRefused,
     stashFailed,
-    lastCursor
+    lastCursor,
+    highWater: provenMark({
+      clean: !cursorBlocked && textUnknown === 0,
+      finalHighWater,
+      advancedTo: lastCursor !== (markRefused ? baseCursor : args.cursor) ? lastCursor : null
+    }),
+    markRefused,
+    restoresDeferred
   };
 }
 async function applyExtractedText(args) {
@@ -46501,6 +46787,17 @@ async function applyFileRow(args) {
       output
     });
   }
+  if (existing && existing.content_hash === row.content_hash && !existsSync8(abs)) {
+    const verdict = deferRestore(args.recentUnlinks, abs, row.updated_at, now().getTime());
+    if (verdict.defer) {
+      if (verdict.first) {
+        output?.log(fileRestoreDeferredLine({ path: relPath, waitSeconds: RESTORE_DEFERRAL_MS / 1000 }));
+      }
+      return { state, action: "noop", textUnknown, restoreDeferred: true };
+    }
+  } else {
+    presentAgain(args.recentUnlinks, abs);
+  }
   if (existing && existing.content_hash === row.content_hash && existsSync8(abs)) {
     if (!args.forceTextRewalk && textIsCurrent(existing, row, workspaceSlug, relPath)) {
       return { state, action: "noop", textUnknown };
@@ -46553,7 +46850,7 @@ async function applyFileRow(args) {
   const bytes = await downloadBytes(got.row.download_url, fetchImpl);
   if (sha256Bytes(bytes) !== row.content_hash) {
     output?.warn(`Integrity check failed for files/${relPath} (hash mismatch) — skipped this pull.`);
-    return { state, action: "skipped" };
+    return { state, action: "skipped", integrityFailed: true };
   }
   const stashFailure = stashUnpushedLocalEdit({
     workspaceSlug,
@@ -46712,6 +47009,8 @@ function textIsCurrent(existing, row, workspaceSlug, relPath) {
   }
   if (existing.text_hash === undefined)
     return false;
+  if (existing.updated_at !== row.updated_at)
+    return false;
   const onDisk = readExtractedText(workspaceSlug, relPath);
   if (onDisk === null)
     return false;
@@ -47023,6 +47322,7 @@ async function replayPermanentDocuments(args) {
   let state = args.state;
   const completed = [];
   let completePass = true;
+  let restoresDeferred = 0;
   for (const marker of args.markers) {
     const candidates = rows.filter((row) => row.deleted_at !== null && row.slug === marker.logical_key && row.permanent_delete === true && typeof row.purge_generation === "string" && typeof row.retirement_sequence === "number");
     candidates.sort((a, b) => b.retirement_sequence - a.retirement_sequence);
@@ -47092,7 +47392,7 @@ async function replayPermanentDocuments(args) {
   for (const row of rows) {
     if (row.deleted_at !== null && row.permanent_delete === true)
       continue;
-    const outcome = applyRow(args.workspaceSlug, args.strategy, row, state, args.output, args.suppressor, args.now, args.isFrozen, args.loggedTombstoneSkips);
+    const outcome = applyRow(args.workspaceSlug, args.strategy, row, state, args.output, args.suppressor, args.now, args.isFrozen, args.loggedTombstoneSkips, args.recentUnlinks);
     state = outcome.state;
     if (outcome.action === "written")
       counters.written++;
@@ -47103,9 +47403,12 @@ async function replayPermanentDocuments(args) {
     else if (outcome.action === "slug_refused") {
       counters.refused = (counters.refused ?? 0) + 1;
       completePass = false;
+    } else if (outcome.action === "restore_deferred") {
+      restoresDeferred++;
+      completePass = false;
     }
   }
-  return { state, counters, cursor: resultingCursor, completed, completePass };
+  return { state, counters, cursor: resultingCursor, completed, completePass, restoresDeferred };
 }
 async function runSync(workspaceSlug, deps = {}) {
   const out = new Output({
@@ -47226,6 +47529,7 @@ async function runSync(workspaceSlug, deps = {}) {
     committed = state;
   };
   const counters = {};
+  let restoresDeferred = 0;
   try {
     for (const entityType of allEntityTypes()) {
       const strategy = requireStrategy(entityType);
@@ -47247,6 +47551,7 @@ async function runSync(workspaceSlug, deps = {}) {
             now,
             isFrozen: deps.isFrozen,
             loggedTombstoneSkips: deps.loggedTombstoneSkips,
+            recentUnlinks: deps.recentUnlinks,
             commit: (before, after) => {
               const next = commitState(before, after);
               committed = next;
@@ -47256,8 +47561,10 @@ async function runSync(workspaceSlug, deps = {}) {
           state = replay.state;
           commitPending();
           counters[entityType] = replay.counters;
+          restoresDeferred += replay.restoresDeferred;
           if (replay.completePass) {
             updateSyncCursor(slug, entityType, replay.cursor);
+            updateSyncHighWater(slug, entityType, null);
             for (const item of replay.completed) {
               clearFeedRefresh({
                 workspaceSlug: slug,
@@ -47270,8 +47577,11 @@ async function runSync(workspaceSlug, deps = {}) {
           continue;
         }
       }
-      let cursor = startCursor;
-      let lastAdvancedCursor = startCursor;
+      const storedMark = entry2.sync_high_water?.[entityType] ?? null;
+      let walkStart = deps.useHighWater === true && storedMark !== null ? storedMark : startCursor;
+      let cursor = walkStart;
+      let lastAdvancedCursor = walkStart;
+      let finalHighWater = null;
       let cursorBlocked = false;
       let permanentEncountered = false;
       const permanentJournalBlocked = entityType === "documents" && dueDocumentRefreshMarkers(slug, now()) === null;
@@ -47287,13 +47597,26 @@ async function runSync(workspaceSlug, deps = {}) {
         refused: 0
       };
       while (true) {
-        const page = await syncEntity({
-          strategy,
-          baseUrl: entry2.api_base_url,
-          pat,
-          cursor,
-          fetchImpl
-        });
+        let page;
+        try {
+          page = await syncEntity({
+            strategy,
+            baseUrl: entry2.api_base_url,
+            pat,
+            cursor,
+            fetchImpl
+          });
+        } catch (err) {
+          if (cursor === walkStart && walkStart !== startCursor && err instanceof ApiError && err.status === 400) {
+            updateSyncHighWater(slug, entityType, null);
+            out.warn(`${entityType}: the stored high-water mark was refused; reading from the cursor instead.`);
+            walkStart = startCursor;
+            cursor = startCursor;
+            lastAdvancedCursor = startCursor;
+            continue;
+          }
+          throw err;
+        }
         for (const row of page.rows) {
           ctr.fetched++;
           if (entityType === "documents" && row.deleted_at !== null && row.permanent_delete === true && row.purge_generation !== undefined) {
@@ -47314,7 +47637,7 @@ async function runSync(workspaceSlug, deps = {}) {
           }
           let outcome;
           try {
-            outcome = applyRow(slug, strategy, row, state, out, deps.suppressor, now, deps.isFrozen, deps.loggedTombstoneSkips);
+            outcome = applyRow(slug, strategy, row, state, out, deps.suppressor, now, deps.isFrozen, deps.loggedTombstoneSkips, deps.recentUnlinks);
           } catch (err) {
             if (!(err instanceof MirrorSymlinkError))
               throw err;
@@ -47337,14 +47660,19 @@ async function runSync(workspaceSlug, deps = {}) {
             ctr.deleted++;
           else if (outcome.action === "moved")
             ctr.moved = (ctr.moved ?? 0) + 1;
-          else if (outcome.action === "slug_refused") {
+          else if (outcome.action === "restore_deferred") {
+            cursorBlocked = true;
+            restoresDeferred++;
+          } else if (outcome.action === "slug_refused") {
             ctr.refused = (ctr.refused ?? 0) + 1;
             cursorBlocked = true;
           }
         }
         commitPending();
-        if (page.next_cursor === null)
+        if (page.next_cursor === null) {
+          finalHighWater = page.high_water ?? null;
           break;
+        }
         if (!cursorBlocked)
           lastAdvancedCursor = page.next_cursor;
         cursor = page.next_cursor;
@@ -47368,6 +47696,7 @@ async function runSync(workspaceSlug, deps = {}) {
           now,
           isFrozen: deps.isFrozen,
           loggedTombstoneSkips: deps.loggedTombstoneSkips,
+          recentUnlinks: deps.recentUnlinks,
           commit: (before, after) => {
             const next = commitState(before, after);
             committed = next;
@@ -47377,8 +47706,10 @@ async function runSync(workspaceSlug, deps = {}) {
         state = replay.state;
         commitPending();
         counters[entityType] = replay.counters;
+        restoresDeferred += replay.restoresDeferred;
         if (replay.completePass) {
           updateSyncCursor(slug, entityType, replay.cursor);
+          updateSyncHighWater(slug, entityType, null);
           for (const item of replay.completed) {
             clearFeedRefresh({
               workspaceSlug: slug,
@@ -47390,12 +47721,21 @@ async function runSync(workspaceSlug, deps = {}) {
         }
         continue;
       }
-      if (lastAdvancedCursor !== startCursor) {
+      if (walkStart === startCursor && lastAdvancedCursor !== walkStart) {
         updateSyncCursor(slug, entityType, lastAdvancedCursor);
       }
+      const mark = provenMark({
+        clean: !cursorBlocked,
+        finalHighWater,
+        advancedTo: lastAdvancedCursor !== walkStart ? lastAdvancedCursor : null
+      });
+      if (mark !== null)
+        updateSyncHighWater(slug, entityType, mark);
     }
     const needsDerivedTextRewalk = state.derived_text_version !== DERIVED_TEXT_VERSION;
-    const filesStartCursor = needsDerivedTextRewalk ? null : entry2.sync_cursors?.["files"] ?? null;
+    const filesBaseCursor = needsDerivedTextRewalk ? null : entry2.sync_cursors?.["files"] ?? null;
+    const filesMark = entry2.sync_high_water?.["files"] ?? null;
+    const filesStartCursor = !needsDerivedTextRewalk && deps.useHighWater === true && filesMark !== null ? filesMark : filesBaseCursor;
     if (needsDerivedTextRewalk) {
       out.info("Re-reading the file index once to refresh extracted text (template changed).");
     }
@@ -47405,6 +47745,8 @@ async function runSync(workspaceSlug, deps = {}) {
       pat,
       state,
       cursor: filesStartCursor,
+      baseCursor: filesBaseCursor,
+      recentUnlinks: deps.recentUnlinks,
       fetchImpl,
       now,
       output: out,
@@ -47418,7 +47760,8 @@ async function runSync(workspaceSlug, deps = {}) {
     if (filesResult.state !== state) {
       state = filesResult.state;
     }
-    if (needsDerivedTextRewalk && filesResult.textUnknown === 0) {
+    restoresDeferred += filesResult.restoresDeferred ?? 0;
+    if (needsDerivedTextRewalk && filesResult.textUnknown === 0 && (filesResult.restoresDeferred ?? 0) === 0) {
       state = { ...state, derived_text_version: DERIVED_TEXT_VERSION };
     }
     counters["files"] = {
@@ -47427,10 +47770,19 @@ async function runSync(workspaceSlug, deps = {}) {
       deleted: filesResult.deleted + filesResult.textDeleted
     };
     commitPending();
-    if (filesResult.lastCursor !== filesStartCursor) {
+    const filesWalkStart = filesResult.markRefused ? filesBaseCursor : filesStartCursor;
+    const filesWalkedFromCursor = filesWalkStart === filesBaseCursor || filesResult.permanentReplayComplete === true;
+    if (filesWalkedFromCursor && filesResult.lastCursor !== filesBaseCursor) {
       updateSyncCursor(slug, "files", filesResult.lastCursor);
     }
+    if (filesResult.markRefused) {
+      updateSyncHighWater(slug, "files", null);
+      out.warn("files: the stored high-water mark was refused; reading from the cursor instead.");
+    }
+    if (filesResult.highWater)
+      updateSyncHighWater(slug, "files", filesResult.highWater);
     if (filesResult.permanentReplayComplete) {
+      updateSyncHighWater(slug, "files", null);
       for (const item of filesResult.permanentRefreshes ?? []) {
         clearFeedRefresh({
           workspaceSlug: slug,
@@ -47618,7 +47970,7 @@ async function runSync(workspaceSlug, deps = {}) {
   const totalRefused = Object.values(counters).reduce((sum, c) => sum + (c.refused ?? 0), 0);
   if (totalWritten === 0 && totalDeleted === 0 && totalMoved === 0 && totalRefused === 0) {
     out.success("Already up to date.");
-    return { exitCode: 0, applied: 0 };
+    return { exitCode: 0, applied: 0, restoresDeferred };
   }
   const elapsed = ((now().getTime() - startedAt.getTime()) / 1000).toFixed(1);
   for (const [type, c] of Object.entries(counters)) {
@@ -47636,9 +47988,9 @@ async function runSync(workspaceSlug, deps = {}) {
     out.info(`  ${type}: ${parts.join(", ")}`);
   }
   out.success(`Done in ${elapsed}s.`);
-  return { exitCode: 0, applied: totalWritten + totalMoved + totalDeleted };
+  return { exitCode: 0, applied: totalWritten + totalMoved + totalDeleted, restoresDeferred };
 }
-function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = () => new Date, isFrozen, loggedTombstoneSkips) {
+function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = () => new Date, isFrozen, loggedTombstoneSkips, recentUnlinks) {
   if (isFrozen?.(strategy.type, row.id)) {
     return { state, action: "skipped" };
   }
@@ -47750,7 +48102,22 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   const writeSlug = relocation.writeSlug;
   if (existingEntry && existingEntry.updated_at === live.updated_at && relocation.kind === "not_needed") {
     const path5 = entityFilePath(workspaceSlug, strategy.type, live.slug);
-    if (existsSync9(path5)) {
+    const present2 = existsSync9(path5);
+    if (!present2) {
+      const verdict = deferRestore(recentUnlinks, path5, live.updated_at, now().getTime());
+      if (verdict.defer) {
+        if (verdict.first) {
+          out.log(entityRestoreDeferredLine({
+            entityType: strategy.type,
+            slug: live.slug,
+            waitSeconds: RESTORE_DEFERRAL_MS / 1000
+          }));
+        }
+        return { state, action: "restore_deferred" };
+      }
+    }
+    if (present2) {
+      presentAgain(recentUnlinks, path5);
       if (strategy.type === "artists") {
         const artistLive = live;
         state = applyArtistMemoryOnPull({
@@ -49187,13 +49554,18 @@ async function runStart(workspaceSlug, deps = {}) {
     return { exitCode: 0 };
   }
   writeDaemonPid(slug, process.pid, (deps.now ?? (() => new Date))());
-  const watcher = startWatcher({ workspaceSlug: slug, getStateEntry, classifyPath }, handler);
+  const ambient = createAmbientPollWiring({
+    now: () => (deps.now?.() ?? new Date).getTime(),
+    baseReadIntervalMs: baseReadIntervalMs()
+  });
+  const watcher = startWatcher({ workspaceSlug: slug, getStateEntry, classifyPath, onUnlink: ambient.onUnlink }, handler);
   const quietSink = discardSink();
   let draining = false;
   let lastHeartbeatMs = 0;
   const pullLoop = new PullLoop({
     runOnce: async () => {
-      const result = await runSync(slug, {
+      const result = await ambient.poll((sc2) => runSync(slug, {
+        ...sc2,
         fetchImpl,
         keychain,
         now: deps.now,
@@ -49205,7 +49577,7 @@ async function runStart(workspaceSlug, deps = {}) {
         isFileFrozen,
         loggedTombstoneSkips,
         loggedStashNotices
-      });
+      }));
       if (result.exitCode === 0) {
         const applied = result.applied ?? 0;
         if (applied > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plinth-music/cli",
-  "version": "0.23.0",
+  "version": "0.23.1",
   "description": "Plinth capstone sync daemon and CLI",
   "type": "module",
   "private": false,