@plinth-music/cli 0.23.0 → 0.23.2

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.2",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -7843,8 +7843,48 @@ function emptyCorpusCounts() {
   return { nonMarkdown: 0, unreadable: 0 };
 }
 
+// src/lib/matter.ts
+var import_gray_matter = __toESM(require_gray_matter(), 1);
+var FRONTMATTER_IS_CODE = "it is marked as code, which Plinth never runs";
+var PATCHED = Symbol.for("plinth.matter.engines-before-patch");
+var marked = (table) => table[PATCHED];
+var refuse = {
+  parse() {
+    throw new Error(FRONTMATTER_IS_CODE);
+  },
+  stringify() {
+    throw new Error(FRONTMATTER_IS_CODE);
+  }
+};
+var engines = import_gray_matter.default.engines;
+if (marked(engines) === undefined) {
+  const before = Object.keys(engines).sort();
+  const safeLoad = engines.yaml.parse;
+  Object.assign(engines, {
+    javascript: refuse,
+    coffee: refuse,
+    yaml: { parse: (input) => safeLoad(input), stringify: engines.yaml.stringify }
+  });
+  Object.defineProperty(engines, PATCHED, { value: before });
+}
+var ENGINES_BEFORE_PATCH = marked(engines);
+function matter(input, read) {
+  return read === undefined ? import_gray_matter.default(input) : import_gray_matter.default(input, { cache: false });
+}
+function stringifyFrontmatter(body, data) {
+  const out = import_gray_matter.default.stringify({ content: body }, data);
+  const bodyOnly = body.endsWith(`
+`) ? body : `${body}
+`;
+  if (out === bodyOnly && import_gray_matter.default.test(body.replace(/^/, ""))) {
+    return `---
+---
+${bodyOnly}`;
+  }
+  return out;
+}
+
 // src/lib/backlinks/scan.ts
-var import_gray_matter4 = __toESM(require_gray_matter(), 1);
 import { readFileSync as readFileSync2 } from "node:fs";
 import { relative, sep as sep2 } from "node:path";
 
@@ -7860,9 +7900,6 @@ import {
 } from "node:fs";
 import { dirname, join as join2, resolve, sep } from "node:path";
 
-// src/lib/entities/_helpers.ts
-var import_gray_matter = __toESM(require_gray_matter(), 1);
-
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -22168,7 +22205,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 +22214,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
     };
   };
 }
@@ -22187,7 +22226,7 @@ function buildFrontmatter(doc2, projectionKeys) {
   return { ...doc2.frontmatter, ...projection };
 }
 function serialiseRow(doc2, projectionKeys, bodyAccessor) {
-  const out = import_gray_matter.default.stringify(bodyAccessor(doc2), buildFrontmatter(doc2, projectionKeys));
+  const out = stringifyFrontmatter(bodyAccessor(doc2), buildFrontmatter(doc2, projectionKeys));
   return out.endsWith(`
 `) ? out : out + `
 `;
@@ -22827,7 +22866,6 @@ var documentsStrategy = {
 };
 
 // src/lib/entities/meetings.ts
-var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 var MeetingLiveSchema = exports_external.object({
   ...BASE_ROW,
   deleted_at: exports_external.null(),
@@ -22982,7 +23020,7 @@ function serialise(doc2) {
     decisions: doc2.decisions,
     follow_up_summary: doc2.follow_up_summary
   });
-  const out = import_gray_matter2.default.stringify(body, fm);
+  const out = stringifyFrontmatter(body, fm);
   return out.endsWith(`
 `) ? out : out + `
 `;
@@ -24473,7 +24511,6 @@ function readContextFile(workspaceSlug, relativePath) {
 }
 
 // src/lib/backlinks/parse.ts
-var import_gray_matter3 = __toESM(require_gray_matter(), 1);
 var RENDERED_BLOCKS = [
   { name: "tasks", begin: TASKS_BLOCK_BEGIN, end: TASKS_BLOCK_END },
   { name: "comments", begin: COMMENTS_BLOCK_BEGIN, end: COMMENTS_BLOCK_END },
@@ -24555,7 +24592,7 @@ function frontmatterLinks(body) {
     return null;
   let data;
   try {
-    data = import_gray_matter3.default(body).data;
+    data = matter(body).data;
   } catch {
     return null;
   }
@@ -24823,7 +24860,7 @@ function buildArtistIndex(relPaths, root, readFile) {
     const slug = m[1];
     let name = null;
     try {
-      const raw = import_gray_matter4.default(readFile(`${root}${sep2}${rel}`)).data;
+      const raw = matter(readFile(`${root}${sep2}${rel}`)).data;
       if (typeof raw.name === "string" && raw.name.trim().length > 0) {
         name = raw.name.trim();
       }
@@ -25345,7 +25382,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 +25445,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 +25487,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)
@@ -25613,7 +25669,8 @@ var TripReasonSchema = exports_external.object({
   entityType: exports_external.string().optional(),
   typeCount: exports_external.number().int().nonnegative().optional(),
   typePopulation: exports_external.number().int().nonnegative().optional(),
-  pct: exports_external.number().optional()
+  pct: exports_external.number().optional(),
+  loneRemoved: exports_external.number().int().nonnegative().optional()
 });
 var PendingBatchFileSchema = exports_external.object({
   version: exports_external.literal(1),
@@ -25722,6 +25779,9 @@ function describeTrip(reason) {
     const pct = reason.pct !== undefined ? ` (${Math.round(reason.pct * 100)}%)` : "";
     return `${reason.typeCount}/${reason.typePopulation} ${reason.entityType}${pct} — proportion threshold`;
   }
+  if (reason.loneRemoved !== undefined) {
+    return reason.count === 1 ? "1 large overwrite — size threshold" : `${reason.count} destructive ops, including a large overwrite — size threshold`;
+  }
   return `${reason.count} destructive ops — count threshold`;
 }
 function formatBytes(n) {
@@ -26735,7 +26795,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) {
@@ -27609,7 +27669,6 @@ function decideRegen(input) {
 }
 
 // src/lib/context/roster.ts
-var import_gray_matter5 = __toESM(require_gray_matter(), 1);
 import { readdirSync as readdirSync3, readFileSync as readFileSync8 } from "node:fs";
 import { join as join7 } from "node:path";
 function readRoster(workspaceSlug) {
@@ -27634,7 +27693,7 @@ function readRoster(workspaceSlug) {
       continue;
     }
     try {
-      const fm = import_gray_matter5.default(raw).data;
+      const fm = matter(raw).data;
       const name = typeof fm.name === "string" && fm.name.length > 0 ? fm.name : slug;
       const status = typeof fm.status === "string" ? fm.status : null;
       roster.push({ slug, name, status });
@@ -29024,7 +29083,6 @@ var SKILL_LOCATIONS = [
 var SECURITY_NOTE = "Scoped to a single Plinth workspace: do not read or write across " + "workspace folders; each has its own token and isolation boundary.";
 
 // src/lib/context/artist-data.ts
-var import_gray_matter6 = __toESM(require_gray_matter(), 1);
 import { readFileSync as readFileSync10 } from "node:fs";
 function artistUuidBySlug(state) {
   const map2 = new Map;
@@ -29151,7 +29209,7 @@ function readEntityFrontmatter(workspaceSlug, entityType, slug) {
     return null;
   }
   try {
-    return import_gray_matter6.default(raw).data;
+    return matter(raw).data;
   } catch {
     return null;
   }
@@ -30195,7 +30253,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 +30307,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 +30582,15 @@ function fileDeleteSuppressedLine(f) {
 function entityDeleteSuppressedLine(f) {
   return `[ENTITY_DELETE_SUPPRESSED entityType=${f.entityType} slug=${f.slug} reason=${f.reason}]`;
 }
+function entityPushHeldLine(f) {
+  return `[PUSH_HELD 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}]`;
 }
@@ -30707,6 +30779,34 @@ function recordEntityRejected(args) {
     rejected_at: args.now().toISOString()
   }));
 }
+var FRONTMATTER_UNREADABLE_REASON = "frontmatter_unreadable";
+function frontmatterUnreadableSentence(why) {
+  const reason = why.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+  return `not synced, because its frontmatter could not be read (${reason}). ` + `Fix the frontmatter and it syncs.`;
+}
+function recordEntityFrontmatterUnreadable(args) {
+  let path;
+  try {
+    path = relative4(workspaceMirrorPath(args.workspaceSlug), args.absolutePath);
+  } catch {
+    path = args.absolutePath;
+  }
+  const message = frontmatterUnreadableSentence(args.why);
+  const withoutStale = removeUnsynced(args.state, "entity", path);
+  const existing = listRejected(args.state).find((o) => o.target === "entity" && o.path === path);
+  if (!withoutStale.changed && existing?.reason === FRONTMATTER_UNREADABLE_REASON && existing.message === message) {
+    return args.state;
+  }
+  return commitState(args.state, upsertRejected(withoutStale.state, {
+    target: "entity",
+    op: "upsert",
+    path,
+    status: 0,
+    reason: FRONTMATTER_UNREADABLE_REASON,
+    message,
+    rejected_at: args.now().toISOString()
+  }).state);
+}
 function recordFileRejected(args) {
   const cat = categorizeError(args.err);
   const withoutStale = removeUnsynced(args.state, "file", args.relPath).state;
@@ -34287,8 +34387,7 @@ var sessionCommand = defineCommand({
 });
 
 // src/commands/start.ts
-var import_gray_matter14 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync10, readFileSync as readFileSync30, statSync as statSync18 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync31, statSync as statSync18 } from "node:fs";
 
 // src/lib/daemon-log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
@@ -34354,9 +34453,311 @@ class DaemonLog {
 }
 
 // src/lib/destructive-gate.ts
-var import_gray_matter7 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
+import { readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
 import { basename as basename4 } from "node:path";
+
+// src/lib/pull-write.ts
+import { readFileSync as readFileSync15 } from "node:fs";
+
+// src/lib/conflicts.ts
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync14, readdirSync as readdirSync6, statSync as statSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname9, join as join12 } from "node:path";
+function conflictsRoot(workspaceSlug) {
+  return join12(plinthHome(), "_conflicts", workspaceSlug);
+}
+function conflictFilePath(args) {
+  const { workspaceSlug, entityType, entitySlug, timestamp, side } = args;
+  const iso = timestamp.toISOString().replace(/[:.]/g, "-");
+  return join12(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.${side}.md`);
+}
+function stashConflict(args) {
+  const target = conflictFilePath(args);
+  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
+  writeFileSync7(target, args.contents, { mode: 384 });
+  return target;
+}
+function stashEntityConflictOnce(args) {
+  const dir = conflictsRoot(args.workspaceSlug);
+  const head = `${args.entityType}.${args.entitySlug}.`;
+  const tail = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z\\.${args.side}\\.md$`);
+  let names = [];
+  try {
+    names = readdirSync6(dir);
+  } catch {
+    names = [];
+  }
+  const newest = names.filter((name) => name.startsWith(head) && tail.test(name.slice(head.length))).sort().pop();
+  if (newest !== undefined) {
+    const path5 = join12(dir, newest);
+    try {
+      if (readFileSync14(path5, "utf8") === args.contents)
+        return { path: path5, reused: true };
+    } catch {}
+  }
+  return { path: stashConflict(args), reused: false };
+}
+function fileConflictPath(args) {
+  const { workspaceSlug, relPath, timestamp, side } = args;
+  const iso = timestamp.toISOString().replace(/[:.]/g, "-");
+  return join12(conflictsRoot(workspaceSlug), `${fileConflictStem(relPath)}.${iso}.${side}`);
+}
+function fileConflictStem(relPath) {
+  return `files.${relPath.replace(/[/\\]/g, "__")}`;
+}
+function stashFileConflict(args) {
+  const target = fileConflictPath(args);
+  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
+  writeFileSync7(target, args.bytes, { mode: 384 });
+  return target;
+}
+function stashFileConflictOnce(args) {
+  const dir = conflictsRoot(args.workspaceSlug);
+  const head = `${fileConflictStem(args.relPath)}.`;
+  const tail = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z\\.${args.side}$`);
+  let names = [];
+  try {
+    names = readdirSync6(dir);
+  } catch {
+    names = [];
+  }
+  const newest = names.filter((n) => n.startsWith(head) && tail.test(n.slice(head.length))).sort().pop();
+  if (newest !== undefined) {
+    const path5 = join12(dir, newest);
+    try {
+      if (Buffer.compare(args.bytes, readFileSync14(path5)) === 0)
+        return { path: path5, reused: true };
+    } catch {}
+  }
+  return { path: stashFileConflict(args), reused: false };
+}
+var STAMP_RE2 = /\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)(?:\.(local|cloud))?(?:\.md)?$/;
+function parseStamp(stamp) {
+  const iso = stamp.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function labelFor(file2) {
+  const m = STAMP_RE2.exec(file2);
+  if (!m)
+    return file2;
+  const head = file2.slice(0, m.index);
+  if (head.startsWith("files.")) {
+    return `files/${head.slice("files.".length).replace(/__/g, "/")}`;
+  }
+  const dot = head.indexOf(".");
+  if (dot === -1)
+    return head;
+  return `${head.slice(0, dot)}/${head.slice(dot + 1)}`;
+}
+function listConflictStashes(workspaceSlug) {
+  const dir = conflictsRoot(workspaceSlug);
+  let names;
+  try {
+    names = readdirSync6(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file2 of names) {
+    const absPath = join12(dir, file2);
+    let st;
+    try {
+      st = statSync5(absPath);
+    } catch {
+      continue;
+    }
+    if (!st.isFile())
+      continue;
+    if (file2.startsWith("."))
+      continue;
+    const m = STAMP_RE2.exec(file2);
+    const side = m?.[2];
+    out.push({
+      file: file2,
+      absPath,
+      label: labelFor(file2),
+      stashedAt: m ? parseStamp(m[1]) : null,
+      side: side === "local" || side === "cloud" ? side : null,
+      mtimeMs: st.mtimeMs
+    });
+  }
+  return out.sort((a, b) => (b.stashedAt?.getTime() ?? b.mtimeMs) - (a.stashedAt?.getTime() ?? a.mtimeMs));
+}
+
+// src/lib/pull-write.ts
+var UNCACHED = { cache: false };
+function parseUncached(raw) {
+  return matter(raw, UNCACHED);
+}
+var NOT_A_MAPPING = "it is not a list of `key: value` lines";
+var SELF_REFERENCE = "an alias in it refers to itself";
+function readFrontmatter(raw) {
+  let parsed;
+  try {
+    parsed = parseUncached(raw);
+  } catch (err) {
+    return { ok: false, why: yamlReason(err) };
+  }
+  if (Object.prototype.toString.call(parsed.data) !== "[object Object]") {
+    return { ok: false, why: NOT_A_MAPPING };
+  }
+  try {
+    JSON.stringify(parsed.data);
+  } catch {
+    return { ok: false, why: SELF_REFERENCE };
+  }
+  return { ok: true, parsed };
+}
+function yamlReason(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return (message.split(`
+`)[0] ?? "").replace(/:\s*$/, "").trim();
+}
+function frontmatterParseError(raw) {
+  const read = readFrontmatter(raw);
+  return read.ok ? null : read.why;
+}
+function computeMirrorHashes(strategy, content) {
+  const parsed = matter(content);
+  const fm = parsed.data ?? {};
+  const lifted = splitUserFrontmatter(strategy, fm);
+  const userFm = userFrontmatter(strategy, lifted.frontmatter);
+  const hashBody = hashableBody(strategy, parsed.content);
+  return {
+    bodyHash: stableHash(hashBody),
+    frontmatterHash: stableHash({ ...userFm, ...lifted.topLevel }),
+    bodyLen: hashBody.length,
+    frontmatterId: fm["id"]
+  };
+}
+function hashableBody(strategy, body) {
+  return strategy.stripLocalBlocks?.(body) ?? body;
+}
+function relocateForSlugChange(args) {
+  const { workspaceSlug, strategy, fromSlug, toSlug, acked, echo, now } = args;
+  if (fromSlug === toSlug)
+    return { kind: "not_needed", writeSlug: toSlug };
+  if (!echo) {
+    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "unguarded" };
+  }
+  if (strategy.mirrorRelativePath(fromSlug).split("/").length !== 2) {
+    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "foldered" };
+  }
+  let fromPath;
+  try {
+    fromPath = entityFilePath(workspaceSlug, strategy.type, fromSlug);
+    entityFilePath(workspaceSlug, strategy.type, toSlug);
+  } catch (err) {
+    if (err instanceof MirrorPathError) {
+      return {
+        kind: "skipped",
+        writeSlug: toSlug,
+        fromSlug,
+        reason: "unresolvable"
+      };
+    }
+    throw err;
+  }
+  let raw = null;
+  try {
+    raw = readFileSync15(fromPath, "utf8");
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return { kind: "absent", writeSlug: toSlug, fromSlug };
+    }
+    return {
+      kind: "refused",
+      writeSlug: fromSlug,
+      fromSlug,
+      reason: "source_unreadable"
+    };
+  }
+  let diverged = true;
+  try {
+    const hashes = computeMirrorHashes(strategy, raw);
+    diverged = hashes.bodyHash !== acked.bodyHash || hashes.frontmatterHash !== acked.frontmatterHash;
+  } catch {
+    diverged = true;
+  }
+  const stashPath = diverged ? stashConflict({
+    workspaceSlug,
+    entityType: strategy.type,
+    entitySlug: fromSlug,
+    timestamp: now(),
+    contents: raw,
+    side: "local"
+  }) : undefined;
+  try {
+    let registered = false;
+    const result = moveEntityFile(workspaceSlug, strategy.type, fromSlug, toSlug, () => {
+      if (echo.watcher === "live") {
+        echo.suppressor.registerDelete(fromPath);
+        registered = true;
+      }
+    });
+    if (result === "moved") {
+      return { kind: "moved", writeSlug: toSlug, fromSlug, stashPath };
+    }
+    if (registered && echo.watcher === "live") {
+      echo.suppressor.cancelDelete(fromPath);
+    }
+    return { kind: "absent", writeSlug: toSlug, fromSlug };
+  } catch (err) {
+    if (err instanceof MirrorDestinationOccupiedError) {
+      return {
+        kind: "refused",
+        writeSlug: fromSlug,
+        fromSlug,
+        reason: "destination_occupied",
+        stashPath
+      };
+    }
+    if (err instanceof MirrorPathError) {
+      return {
+        kind: "skipped",
+        writeSlug: toSlug,
+        fromSlug,
+        reason: "unresolvable"
+      };
+    }
+    throw err;
+  }
+}
+function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor, pathSlug) {
+  const targetSlug = pathSlug ?? doc2.slug;
+  const content = renderMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, targetSlug);
+  if (suppressor) {
+    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
+    suppressor.registerWrite(target, computeMirrorHashes(strategy, content));
+  }
+  writeMirrorFile(workspaceSlug, strategy.type, targetSlug, content);
+  return content;
+}
+function renderMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, targetSlug) {
+  let content = strategy.serialise(doc2);
+  if (strategy.preserveLocalBodyOnPull) {
+    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
+    let existing = null;
+    try {
+      existing = readFileSync15(target, "utf8");
+    } catch (err) {
+      if (err?.code !== "ENOENT")
+        throw err;
+    }
+    if (existing !== null) {
+      const existingParsed = matter(existing);
+      const cloudParsed = matter(content);
+      const stitched = stringifyFrontmatter(existingParsed.content, cloudParsed.data);
+      content = stitched.endsWith(`
+`) ? stitched : stitched + `
+`;
+    }
+  }
+  return content;
+}
+
+// src/lib/destructive-gate.ts
 var GUTTING_RATIO_DEFAULT = 0.5;
 var GUTTING_MIN_PRIOR_BYTES = 200;
 function envFloat(name, def) {
@@ -34399,10 +34800,10 @@ function classifyDestructive(event, entityType, state, deps = {}) {
       absolutePath: event.absolutePath
     };
   }
-  const readFile = deps.readFile ?? ((p) => readFileSync14(p, "utf8"));
+  const readFile = deps.readFile ?? ((p) => readFileSync16(p, "utf8"));
   const statInode = deps.statInode ?? ((p) => {
     try {
-      return statSync5(p).ino;
+      return statSync6(p).ino;
     } catch {
       return;
     }
@@ -34413,13 +34814,11 @@ function classifyDestructive(event, entityType, state, deps = {}) {
   } catch {
     return null;
   }
-  let newLen;
-  try {
-    const body = import_gray_matter7.default(raw).content;
-    newLen = (getStrategy(entityType)?.stripLocalBlocks?.(body) ?? body).length;
-  } catch {
+  const read = readFrontmatter(raw);
+  if (!read.ok)
     return null;
-  }
+  const body = read.parsed.content;
+  const newLen = (getStrategy(entityType)?.stripLocalBlocks?.(body) ?? body).length;
   const liveInode = statInode(event.absolutePath);
   const slug = basename4(event.absolutePath, ".md");
   const entry2 = (liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined) ?? getEntryBySlug(state, entityType, slug);
@@ -34438,13 +34837,26 @@ function classifyDestructive(event, entityType, state, deps = {}) {
     newLen
   };
 }
+var LONE_MIN_REMOVED_DEFAULT = 5000;
+var LONE_MIN_REMOVED_BYTES_DEFAULT = 100 * 1024;
 function defaultThresholds() {
   return {
     absCount: envInt("PLINTH_GATE_ABS_COUNT", 3),
     propMinOps: envInt("PLINTH_GATE_PROP_MIN_OPS", 2),
-    propPct: envFloat("PLINTH_GATE_PROP_PCT", 0.5)
+    propPct: envFloat("PLINTH_GATE_PROP_PCT", 0.5),
+    loneMinRemoved: envInt("PLINTH_GATE_LONE_MIN_REMOVED", LONE_MIN_REMOVED_DEFAULT),
+    loneMinRemovedBytes: envInt("PLINTH_GATE_LONE_MIN_REMOVED_BYTES", LONE_MIN_REMOVED_BYTES_DEFAULT)
   };
 }
+function tripReasonToken(reason) {
+  return reason.loneRemoved !== undefined ? "size" : reason.kind;
+}
+function evaluateLoneOverwrite(count, removed, floor) {
+  const loneRemoved = Math.max(0, ...removed);
+  if (loneRemoved < floor)
+    return { tripped: false };
+  return { tripped: true, reason: { kind: "count", count, loneRemoved } };
+}
 function evaluateBatch(ops, typePopulations, thresholds = defaultThresholds()) {
   const count = ops.length;
   if (count === 0)
@@ -34472,7 +34884,7 @@ function evaluateBatch(ops, typePopulations, thresholds = defaultThresholds()) {
       };
     }
   }
-  return { tripped: false };
+  return evaluateLoneOverwrite(count, ops.map((op) => op.kind === "overwrite" ? op.priorLen - op.newLen : 0), thresholds.loneMinRemoved);
 }
 function dedupeOps(ops) {
   const byKey = new Map;
@@ -34532,135 +34944,10 @@ class DestructiveGate {
 }
 
 // src/lib/resolve-pending.ts
-import { readFileSync as readFileSync20 } from "node:fs";
-
-// src/lib/conflicts.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, readdirSync as readdirSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname9, join as join12 } from "node:path";
-function conflictsRoot(workspaceSlug) {
-  return join12(plinthHome(), "_conflicts", workspaceSlug);
-}
-function conflictFilePath(args) {
-  const { workspaceSlug, entityType, entitySlug, timestamp, side } = args;
-  const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  return join12(conflictsRoot(workspaceSlug), `${entityType}.${entitySlug}.${iso}.${side}.md`);
-}
-function stashConflict(args) {
-  const target = conflictFilePath(args);
-  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
-  writeFileSync7(target, args.contents, { mode: 384 });
-  return target;
-}
-function stashEntityConflictOnce(args) {
-  const dir = conflictsRoot(args.workspaceSlug);
-  const head = `${args.entityType}.${args.entitySlug}.`;
-  const tail = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z\\.${args.side}\\.md$`);
-  let names = [];
-  try {
-    names = readdirSync6(dir);
-  } catch {
-    names = [];
-  }
-  const newest = names.filter((name) => name.startsWith(head) && tail.test(name.slice(head.length))).sort().pop();
-  if (newest !== undefined) {
-    const path5 = join12(dir, newest);
-    try {
-      if (readFileSync15(path5, "utf8") === args.contents)
-        return { path: path5, reused: true };
-    } catch {}
-  }
-  return { path: stashConflict(args), reused: false };
-}
-function fileConflictPath(args) {
-  const { workspaceSlug, relPath, timestamp, side } = args;
-  const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  return join12(conflictsRoot(workspaceSlug), `${fileConflictStem(relPath)}.${iso}.${side}`);
-}
-function fileConflictStem(relPath) {
-  return `files.${relPath.replace(/[/\\]/g, "__")}`;
-}
-function stashFileConflict(args) {
-  const target = fileConflictPath(args);
-  mkdirSync10(dirname9(target), { recursive: true, mode: 448 });
-  writeFileSync7(target, args.bytes, { mode: 384 });
-  return target;
-}
-function stashFileConflictOnce(args) {
-  const dir = conflictsRoot(args.workspaceSlug);
-  const head = `${fileConflictStem(args.relPath)}.`;
-  const tail = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z\\.${args.side}$`);
-  let names = [];
-  try {
-    names = readdirSync6(dir);
-  } catch {
-    names = [];
-  }
-  const newest = names.filter((n) => n.startsWith(head) && tail.test(n.slice(head.length))).sort().pop();
-  if (newest !== undefined) {
-    const path5 = join12(dir, newest);
-    try {
-      if (Buffer.compare(args.bytes, readFileSync15(path5)) === 0)
-        return { path: path5, reused: true };
-    } catch {}
-  }
-  return { path: stashFileConflict(args), reused: false };
-}
-var STAMP_RE2 = /\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)(?:\.(local|cloud))?(?:\.md)?$/;
-function parseStamp(stamp) {
-  const iso = stamp.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
-  const d = new Date(iso);
-  return Number.isNaN(d.getTime()) ? null : d;
-}
-function labelFor(file2) {
-  const m = STAMP_RE2.exec(file2);
-  if (!m)
-    return file2;
-  const head = file2.slice(0, m.index);
-  if (head.startsWith("files.")) {
-    return `files/${head.slice("files.".length).replace(/__/g, "/")}`;
-  }
-  const dot = head.indexOf(".");
-  if (dot === -1)
-    return head;
-  return `${head.slice(0, dot)}/${head.slice(dot + 1)}`;
-}
-function listConflictStashes(workspaceSlug) {
-  const dir = conflictsRoot(workspaceSlug);
-  let names;
-  try {
-    names = readdirSync6(dir);
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const file2 of names) {
-    const absPath = join12(dir, file2);
-    let st;
-    try {
-      st = statSync6(absPath);
-    } catch {
-      continue;
-    }
-    if (!st.isFile())
-      continue;
-    if (file2.startsWith("."))
-      continue;
-    const m = STAMP_RE2.exec(file2);
-    const side = m?.[2];
-    out.push({
-      file: file2,
-      absPath,
-      label: labelFor(file2),
-      stashedAt: m ? parseStamp(m[1]) : null,
-      side: side === "local" || side === "cloud" ? side : null,
-      mtimeMs: st.mtimeMs
-    });
-  }
-  return out.sort((a, b) => (b.stashedAt?.getTime() ?? b.mtimeMs) - (a.stashedAt?.getTime() ?? a.mtimeMs));
-}
+import { readFileSync as readFileSync21 } from "node:fs";
 
 // src/lib/files/push.ts
-import { readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
 
 // src/lib/permanent-deletions.ts
 import { createHash as createHash3, randomUUID } from "node:crypto";
@@ -34674,7 +34961,7 @@ import {
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync11,
   openSync as openSync4,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   renameSync as renameSync8,
   unlinkSync as unlinkSync8,
   writeSync as writeSync2
@@ -34865,7 +35152,7 @@ function loadPermanentDeletionJournal(workspaceSlug) {
     return emptyJournal(workspaceSlug);
   assertPrivateDirectory(dirname10(target));
   assertOwnerOnlyFile(target);
-  const journal = parseJournal(workspaceSlug, readFileSync16(target, "utf8"));
+  const journal = parseJournal(workspaceSlug, readFileSync17(target, "utf8"));
   try {
     fsyncDirectory(dirname10(target));
   } catch (error52) {
@@ -34932,7 +35219,7 @@ function writePermanentDeletionJournal(prior, next) {
     let installed2 = false;
     try {
       assertOwnerOnlyFile(target);
-      const candidate = parseJournal(body.workspace_slug, readFileSync16(target, "utf8"));
+      const candidate = parseJournal(body.workspace_slug, readFileSync17(target, "utf8"));
       installed2 = candidate.revision === body.revision && checksum(candidate) === checksum(body);
     } catch {
       installed2 = false;
@@ -34946,7 +35233,7 @@ function writePermanentDeletionJournal(prior, next) {
     }
   }
   assertOwnerOnlyFile(target);
-  const installed = parseJournal(body.workspace_slug, readFileSync16(target, "utf8"));
+  const installed = parseJournal(body.workspace_slug, readFileSync17(target, "utf8"));
   if (installed.revision !== body.revision || checksum(installed) !== checksum(body)) {
     throw new PermanentDeletionJournalError("renamed journal revision did not validate", "durability_indeterminate");
   }
@@ -34954,7 +35241,7 @@ function writePermanentDeletionJournal(prior, next) {
     fsyncDirectory(parent);
   } catch (firstError) {
     assertOwnerOnlyFile(target);
-    const reopened = parseJournal(body.workspace_slug, readFileSync16(target, "utf8"));
+    const reopened = parseJournal(body.workspace_slug, readFileSync17(target, "utf8"));
     if (reopened.revision !== body.revision || checksum(reopened) !== checksum(body)) {
       throw new PermanentDeletionJournalError("journal changed after rename", "durability_indeterminate");
     }
@@ -35453,7 +35740,7 @@ async function pushFilesUpsertLocked(args) {
         state: next
       };
     }
-    bytes = readFileSync17(absolutePath);
+    bytes = readFileSync18(absolutePath);
     hash2 = sha256Bytes(bytes);
     inode = st.ino;
   }
@@ -35715,12 +36002,64 @@ async function pushFilesDelete(args) {
 }
 
 // src/lib/push.ts
-var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync19, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync20, statSync as statSync8 } from "node:fs";
 import { basename as basename5, relative as relative5 } from "node:path";
 
+// src/lib/frontmatter-held.ts
+import { lstatSync as lstatSync5, readFileSync as readFileSync19 } from "node:fs";
+import { resolve as resolve4, sep as sep5 } from "node:path";
+function holdUnreadableFrontmatter(args) {
+  const next = recordEntityFrontmatterUnreadable(args);
+  args.output?.log(entityPushHeldLine({
+    entityType: args.entityType,
+    slug: args.slug,
+    reason: FRONTMATTER_UNREADABLE_REASON
+  }));
+  if (next !== args.state) {
+    args.output?.warn(`${args.entityType}/${args.slug}: ${frontmatterUnreadableSentence(args.why)}`);
+  }
+  return next;
+}
+function settleFrontmatterHolds(state, workspaceSlug) {
+  const held = listRejected(state).filter(isFrontmatterHold);
+  if (held.length === 0)
+    return state;
+  let root;
+  try {
+    root = workspaceMirrorPath(workspaceSlug);
+  } catch {
+    return state;
+  }
+  const settled = new Set(held.map((record2) => record2.path).filter((path5) => !stillHeld(workspaceSlug, root, path5)));
+  if (settled.size === 0)
+    return state;
+  return commitState(state, {
+    ...state,
+    rejected: listRejected(state).filter((o) => !(isFrontmatterHold(o) && settled.has(o.path)))
+  });
+}
+function isFrontmatterHold(record2) {
+  return record2.target === "entity" && record2.reason === FRONTMATTER_UNREADABLE_REASON;
+}
+function stillHeld(workspaceSlug, root, recordPath) {
+  const absolutePath = resolve4(root, recordPath);
+  if (!absolutePath.startsWith(root + sep5))
+    return true;
+  if (hasSymlinkedComponent(workspaceSlug, absolutePath))
+    return true;
+  let raw;
+  try {
+    if (!lstatSync5(absolutePath).isFile())
+      return true;
+    raw = readFileSync19(absolutePath, "utf8");
+  } catch (err) {
+    const code = err.code;
+    return code !== "ENOENT" && code !== "ENOTDIR";
+  }
+  return frontmatterParseError(raw) !== null;
+}
+
 // src/lib/frontmatter-id.ts
-var import_gray_matter8 = __toESM(require_gray_matter(), 1);
 function eolOf(content) {
   return /\r\n/.test(content) ? `\r
 ` : `
@@ -35757,158 +36096,16 @@ function withFrontmatterId(raw, parsed, id) {
 }
 function frontmatterIdWriteIsSound(next, id, expectedBody) {
   try {
-    const check2 = import_gray_matter8.default(next);
+    const check2 = matter(next);
     return check2.data?.["id"] === id && check2.content === expectedBody;
   } catch {
     return false;
   }
 }
 
-// src/lib/pull-write.ts
-var import_gray_matter9 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync18 } from "node:fs";
-function computeMirrorHashes(strategy, content) {
-  const parsed = import_gray_matter9.default(content);
-  const fm = parsed.data ?? {};
-  const lifted = splitUserFrontmatter(strategy, fm);
-  const userFm = userFrontmatter(strategy, lifted.frontmatter);
-  const hashBody = hashableBody(strategy, parsed.content);
-  return {
-    bodyHash: stableHash(hashBody),
-    frontmatterHash: stableHash({ ...userFm, ...lifted.topLevel }),
-    bodyLen: hashBody.length,
-    frontmatterId: fm["id"]
-  };
-}
-function hashableBody(strategy, body) {
-  return strategy.stripLocalBlocks?.(body) ?? body;
-}
-function relocateForSlugChange(args) {
-  const { workspaceSlug, strategy, fromSlug, toSlug, acked, echo, now } = args;
-  if (fromSlug === toSlug)
-    return { kind: "not_needed", writeSlug: toSlug };
-  if (!echo) {
-    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "unguarded" };
-  }
-  if (strategy.mirrorRelativePath(fromSlug).split("/").length !== 2) {
-    return { kind: "skipped", writeSlug: toSlug, fromSlug, reason: "foldered" };
-  }
-  let fromPath;
-  try {
-    fromPath = entityFilePath(workspaceSlug, strategy.type, fromSlug);
-    entityFilePath(workspaceSlug, strategy.type, toSlug);
-  } catch (err) {
-    if (err instanceof MirrorPathError) {
-      return {
-        kind: "skipped",
-        writeSlug: toSlug,
-        fromSlug,
-        reason: "unresolvable"
-      };
-    }
-    throw err;
-  }
-  let raw = null;
-  try {
-    raw = readFileSync18(fromPath, "utf8");
-  } catch (err) {
-    const code = err?.code;
-    if (code === "ENOENT") {
-      return { kind: "absent", writeSlug: toSlug, fromSlug };
-    }
-    return {
-      kind: "refused",
-      writeSlug: fromSlug,
-      fromSlug,
-      reason: "source_unreadable"
-    };
-  }
-  let diverged = true;
-  try {
-    const hashes = computeMirrorHashes(strategy, raw);
-    diverged = hashes.bodyHash !== acked.bodyHash || hashes.frontmatterHash !== acked.frontmatterHash;
-  } catch {
-    diverged = true;
-  }
-  const stashPath = diverged ? stashConflict({
-    workspaceSlug,
-    entityType: strategy.type,
-    entitySlug: fromSlug,
-    timestamp: now(),
-    contents: raw,
-    side: "local"
-  }) : undefined;
-  try {
-    let registered = false;
-    const result = moveEntityFile(workspaceSlug, strategy.type, fromSlug, toSlug, () => {
-      if (echo.watcher === "live") {
-        echo.suppressor.registerDelete(fromPath);
-        registered = true;
-      }
-    });
-    if (result === "moved") {
-      return { kind: "moved", writeSlug: toSlug, fromSlug, stashPath };
-    }
-    if (registered && echo.watcher === "live") {
-      echo.suppressor.cancelDelete(fromPath);
-    }
-    return { kind: "absent", writeSlug: toSlug, fromSlug };
-  } catch (err) {
-    if (err instanceof MirrorDestinationOccupiedError) {
-      return {
-        kind: "refused",
-        writeSlug: fromSlug,
-        fromSlug,
-        reason: "destination_occupied",
-        stashPath
-      };
-    }
-    if (err instanceof MirrorPathError) {
-      return {
-        kind: "skipped",
-        writeSlug: toSlug,
-        fromSlug,
-        reason: "unresolvable"
-      };
-    }
-    throw err;
-  }
-}
-function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor, pathSlug) {
-  const targetSlug = pathSlug ?? doc2.slug;
-  const content = renderMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, targetSlug);
-  if (suppressor) {
-    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
-    suppressor.registerWrite(target, computeMirrorHashes(strategy, content));
-  }
-  writeMirrorFile(workspaceSlug, strategy.type, targetSlug, content);
-  return content;
-}
-function renderMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, targetSlug) {
-  let content = strategy.serialise(doc2);
-  if (strategy.preserveLocalBodyOnPull) {
-    const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
-    let existing = null;
-    try {
-      existing = readFileSync18(target, "utf8");
-    } catch (err) {
-      if (err?.code !== "ENOENT")
-        throw err;
-    }
-    if (existing !== null) {
-      const existingParsed = import_gray_matter9.default(existing);
-      const cloudParsed = import_gray_matter9.default(content);
-      const stitched = import_gray_matter9.default.stringify(existingParsed.content, cloudParsed.data);
-      content = stitched.endsWith(`
-`) ? stitched : stitched + `
-`;
-    }
-  }
-  return content;
-}
-
 // src/lib/push.ts
 var DELETE_DECLINED_PATH_EXISTS = "the file is on disk again — a newer write owns this row";
+var FRONTMATTER_PARSE_ERROR = "frontmatter parse error";
 function deleteDeclinedSentence(relPath) {
   return `Not deleted: ${relPath} is on disk again, so the row was left alone. If you meant to delete it, remove the file and it will be retried.`;
 }
@@ -36017,8 +36214,8 @@ function stampStateFromMirror(args) {
   const { strategy, workspaceSlug, doc: doc2, state, priorMemoryHash } = args;
   const targetSlug = args.pathSlug ?? doc2.slug;
   const mirrorPath = entityFilePath(workspaceSlug, strategy.type, targetSlug);
-  const mirrorRaw = readFileSync19(mirrorPath, "utf8");
-  const mirrorParsed = import_gray_matter10.default(mirrorRaw);
+  const mirrorRaw = readFileSync20(mirrorPath, "utf8");
+  const mirrorParsed = matter(mirrorRaw);
   const mirrorFm = mirrorParsed.data ?? {};
   const mirrorLifted = splitUserFrontmatter(strategy, mirrorFm);
   const mirrorUserFm = userFrontmatter(strategy, mirrorLifted.frontmatter);
@@ -36170,7 +36367,7 @@ async function pushFile(args) {
   }
   let raw;
   try {
-    raw = readFileSync19(absolutePath, "utf8");
+    raw = readFileSync20(absolutePath, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
       return runPushDelete({
@@ -36190,23 +36387,32 @@ async function pushFile(args) {
     }
     throw err;
   }
-  let parsed;
-  try {
-    parsed = import_gray_matter10.default(raw);
-  } catch {
-    return {
-      outcome: { kind: "ignored", absolutePath, reason: "frontmatter parse error" },
-      state
-    };
-  }
-  const fm = parsed.data ?? {};
-  const slugFromFm = typeof fm.slug === "string" && fm.slug.length > 0 ? fm.slug : null;
   let parsedSlug = null;
   try {
     const rel = relative5(workspaceMirrorPath(workspaceSlug), absolutePath);
     parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
   } catch {}
   const slugFromPath = parsedSlug ?? basename5(absolutePath, ".md");
+  const read = readFrontmatter(raw);
+  if (!read.ok) {
+    return {
+      outcome: { kind: "ignored", absolutePath, reason: FRONTMATTER_PARSE_ERROR },
+      state: holdUnreadableFrontmatter({
+        state,
+        workspaceSlug,
+        absolutePath,
+        entityType,
+        slug: slugFromPath,
+        why: read.why,
+        now,
+        output
+      }),
+      base: state
+    };
+  }
+  let parsed = read.parsed;
+  const fm = parsed.data ?? {};
+  const slugFromFm = typeof fm.slug === "string" && fm.slug.length > 0 ? fm.slug : null;
   const slug = identity === "path" ? slugFromPath : slugFromFm ?? slugFromPath;
   if (!slug) {
     return {
@@ -36220,14 +36426,14 @@ async function pushFile(args) {
   if (strategy.classifyFieldErrors) {
     const desiredBody = spliceSyncErrorBlock(parsed.content, fieldErrors);
     if (desiredBody.replace(/\s+$/, "") !== parsed.content.replace(/\s+$/, "")) {
-      let rewritten = import_gray_matter10.default.stringify(desiredBody, parsed.data ?? {});
+      let rewritten = stringifyFrontmatter(desiredBody, parsed.data ?? {});
       if (!rewritten.endsWith(`
 `))
         rewritten += `
 `;
       writeMirrorFile(workspaceSlug, entityType, slug, rewritten);
       raw = rewritten;
-      parsed = import_gray_matter10.default(rewritten);
+      parsed = parseUncached(rewritten);
     }
   }
   const liveInode = safeInode2(absolutePath);
@@ -36505,7 +36711,7 @@ async function runPushUpsert(args) {
     }
     const wireProjection = (md) => {
       try {
-        const p = import_gray_matter10.default(md);
+        const p = matter(md);
         const f = p.data ?? {};
         const l = splitUserFrontmatter(strategy, f);
         const u = userFrontmatter(strategy, l.frontmatter);
@@ -36520,7 +36726,7 @@ async function runPushUpsert(args) {
     if (liveEntry !== snapshotEntry) {
       let onDisk = null;
       try {
-        onDisk = readFileSync19(args.absolutePath, "utf8");
+        onDisk = readFileSync20(args.absolutePath, "utf8");
       } catch {
         onDisk = null;
       }
@@ -36982,7 +37188,7 @@ function writeCreatedIdBack(args) {
     if (entityFilePath(args.workspaceSlug, args.strategy.type, args.slug) !== args.absolutePath) {
       return;
     }
-    const readBack = args.readBack ?? ((p) => readFileSync19(p, "utf8"));
+    const readBack = args.readBack ?? ((p) => readFileSync20(p, "utf8"));
     if (readBack(args.absolutePath) !== args.raw)
       return;
     args.suppressor?.registerWrite(args.absolutePath, computeMirrorHashes(args.strategy, write.content));
@@ -37454,8 +37660,8 @@ async function pushRename(args) {
       };
       if (!updated.body_hash || !updated.frontmatter_hash) {
         try {
-          const mirrorRaw = readFileSync19(toPath, "utf8");
-          const mirrorParsed = import_gray_matter10.default(mirrorRaw);
+          const mirrorRaw = readFileSync20(toPath, "utf8");
+          const mirrorParsed = matter(mirrorRaw);
           const renameFm = mirrorParsed.data ?? {};
           const renameLifted = splitUserFrontmatter(strategy, renameFm);
           const renameUserFm = userFrontmatter(strategy, renameLifted.frontmatter);
@@ -37491,7 +37697,7 @@ async function pushRename(args) {
     if (patchResult.reason === "slug_conflict") {
       let contents2 = "";
       try {
-        contents2 = readFileSync19(toPath, "utf8");
+        contents2 = readFileSync20(toPath, "utf8");
       } catch {}
       const stashPath2 = stashConflict({
         workspaceSlug,
@@ -37539,7 +37745,7 @@ async function pushRename(args) {
     }
     let contents = "";
     try {
-      contents = readFileSync19(toPath, "utf8");
+      contents = readFileSync20(toPath, "utf8");
     } catch {}
     const stashPath = stashConflict({
       workspaceSlug,
@@ -37672,7 +37878,7 @@ async function discardBatchOps(batch, deps) {
         const path5 = opPath(deps.workspaceSlug, op);
         let local = null;
         try {
-          local = readFileSync20(path5, "utf8");
+          local = readFileSync21(path5, "utf8");
         } catch {
           local = null;
         }
@@ -37711,7 +37917,7 @@ async function discardFileOp(op, deps) {
   const abs = filesSubtreePath(deps.workspaceSlug, op.path);
   let local = null;
   try {
-    local = readFileSync20(abs);
+    local = readFileSync21(abs);
   } catch {
     local = null;
   }
@@ -37748,7 +37954,7 @@ function opPath(workspaceSlug, op) {
 }
 
 // src/lib/files/classify.ts
-import { relative as relative6, sep as sep5 } from "node:path";
+import { relative as relative6, sep as sep6 } from "node:path";
 var FILES_SUBTREE = "files";
 function classifyFilesPath(args) {
   let root;
@@ -37758,20 +37964,20 @@ function classifyFilesPath(args) {
     return null;
   }
   const rel = relative6(root, args.absolutePath);
-  if (rel.startsWith("..") || rel.startsWith(sep5))
+  if (rel.startsWith("..") || rel.startsWith(sep6))
     return null;
-  const prefix = FILES_SUBTREE + sep5;
+  const prefix = FILES_SUBTREE + sep6;
   if (!rel.startsWith(prefix))
     return null;
   const sub = rel.slice(prefix.length);
   if (sub.length === 0)
     return null;
-  const posix = sep5 === "/" ? sub : sub.split(sep5).join("/");
+  const posix = sep6 === "/" ? sub : sub.split(sep6).join("/");
   return validateFilesRelPath(posix) ? { relPath: posix } : null;
 }
 
 // src/lib/memory-facts/sync.ts
-import { isAbsolute as isAbsolute2, relative as relative7, sep as sep6 } from "node:path";
+import { isAbsolute as isAbsolute2, relative as relative7, sep as sep7 } from "node:path";
 
 // src/lib/memory-facts/api.ts
 var FactCommonSchema = exports_external.object({
@@ -38054,7 +38260,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 +38417,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 };
@@ -38512,7 +38721,7 @@ function classifyMemoryFactPath(args) {
   const rel = relative7(root, args.absolutePath);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel))
     return null;
-  const mirrorRel = `${MEMORY_FACTS_DIR}/${rel.split(sep6).join("/")}`;
+  const mirrorRel = `${MEMORY_FACTS_DIR}/${rel.split(sep7).join("/")}`;
   return { relPath: mirrorRel, fact: parseMemoryFactRelPath(mirrorRel) };
 }
 function classifyMemoryFactEvent(args) {
@@ -38609,7 +38818,7 @@ function evaluateFileBatch(ops, population, thresholds = defaultThresholds()) {
       }
     };
   }
-  return { tripped: false };
+  return evaluateLoneOverwrite(count, ops.map((op) => op.kind === "overwrite" ? op.priorSize - op.newSize : 0), thresholds.loneMinRemovedBytes);
 }
 function dedupeFileOps(ops) {
   const byKey = new Map;
@@ -38680,7 +38889,7 @@ class FileDestructiveGate {
 }
 
 // src/lib/files/reconcile.ts
-import { readFileSync as readFileSync21, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync22, statSync as statSync10 } from "node:fs";
 
 // src/lib/unsynced.ts
 import { join as join14, relative as relative8 } from "node:path";
@@ -39676,7 +39885,7 @@ class NodeFsHandler {
         this._addToNodeFs(path5, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -39685,7 +39894,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve5(undefined);
+        resolve6(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -40444,7 +40653,7 @@ var chokidar_default = { watch, FSWatcher };
 
 // src/lib/watcher.ts
 import { statSync as statSync9 } from "node:fs";
-import { sep as sep7 } from "node:path";
+import { sep as sep8 } from "node:path";
 
 // src/lib/rename-classifier.ts
 class RenameClassifier {
@@ -40575,7 +40784,7 @@ function watcherIgnoreMatcher(workspaceRoot) {
   return (absolutePath) => patterns.some((re) => re.test(absolutePath));
 }
 function escSep() {
-  return sep7 === "/" ? "/" : "\\\\";
+  return sep8 === "/" ? "/" : "\\\\";
 }
 
 class DebounceMap {
@@ -40675,7 +40884,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();
@@ -40714,7 +40928,7 @@ function readBlobForPush(args) {
   }
   let bytes;
   try {
-    bytes = readFileSync21(absolutePath);
+    bytes = readFileSync22(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -40857,7 +41071,7 @@ async function reconcileFilesSubtree(args) {
         ops: pendingOps
       });
       quarantined = ops.length;
-      output?.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${ops.length} reason=${result.reason.kind} source=files-reconcile]`);
+      output?.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${ops.length} reason=${tripReasonToken(result.reason)} source=files-reconcile]`);
     } else {
       for (const c of guttingCandidates) {
         await pushDivergedBlob(c.op.relPath, c.op.absolutePath, c.prepared);
@@ -41024,7 +41238,7 @@ function applyArtistMemoryOnPull(args) {
   const cloudMemory = live.memory;
   const generated = live.memory_generated === true;
   const local = readArtistMemoryFile(workspaceSlug, slug);
-  const refuse = (localContent, canonical2) => {
+  const refuse2 = (localContent, canonical2) => {
     const refused = refuseGeneratedMemoryEdit({
       state,
       workspaceSlug,
@@ -41053,7 +41267,7 @@ function applyArtistMemoryOnPull(args) {
   const cloudHash = stableHash(cloudMemory);
   if (cloudHash === ackedMemoryHash && local !== null) {
     if (generated && stableHash(local) !== ackedMemoryHash) {
-      refuse(local, cloudMemory);
+      refuse2(local, cloudMemory);
       return { memoryHash: cloudHash, state };
     }
     if (generated) {
@@ -41065,7 +41279,7 @@ function applyArtistMemoryOnPull(args) {
     const localHash = stableHash(local);
     if (localHash !== ackedMemoryHash && localHash !== cloudHash) {
       if (generated) {
-        refuse(local, cloudMemory);
+        refuse2(local, cloudMemory);
         return { memoryHash: cloudHash, state };
       }
       const stashPath = stashConflict({
@@ -41775,7 +41989,7 @@ function anyUnknown(state) {
 }
 
 // src/lib/memory/write.ts
-import { readFileSync as readFileSync22, statSync as statSync11 } from "node:fs";
+import { readFileSync as readFileSync23, statSync as statSync11 } from "node:fs";
 
 // src/lib/files/extracted-text.ts
 import { createHash as createHash5 } from "node:crypto";
@@ -41856,7 +42070,6 @@ function extractedTextHash(rendered) {
 }
 
 // src/lib/memory/splice.ts
-var import_gray_matter11 = __toESM(require_gray_matter(), 1);
 var OPEN_RE = /^---\r?\n/;
 function findFrontmatter(content) {
   const open2 = OPEN_RE.exec(content);
@@ -41942,7 +42155,7 @@ function spliceAnnotation(content, lines) {
 }
 function parsesAsFrontmatter(content) {
   try {
-    import_gray_matter11.default(content, { cache: false });
+    matter(content, { cache: false });
     return true;
   } catch {
     return false;
@@ -41970,7 +42183,7 @@ function writeDocumentAnnotation(args) {
   }
   let current;
   try {
-    current = readFileSync22(target, "utf8");
+    current = readFileSync23(target, "utf8");
   } catch {
     return { kind: "absent" };
   }
@@ -42008,18 +42221,32 @@ function writeFileTextAnnotation(args) {
   const current = readExtractedText(args.workspaceSlug, args.relPath);
   if (current === null)
     return { kind: "absent" };
-  if (args.textHash !== undefined && extractedTextHash(current) !== args.textHash) {
+  const onDisk = extractedTextHash(current);
+  const acked = args.textHash;
+  const offAck = acked !== undefined && onDisk !== acked;
+  if (acked !== undefined && offAck && !isOwnRender(current, acked, args.priorLines)) {
     return { kind: "diverged", relPath: extractedTextRelPath(args.relPath) };
   }
   const spliced = spliceAnnotation(current, args.lines);
-  if (!spliced.changed)
-    return { kind: "unchanged" };
+  if (!spliced.changed) {
+    return offAck ? { kind: "unchanged", textHash: onDisk } : { kind: "unchanged" };
+  }
   writeExtractedText(args.workspaceSlug, args.relPath, spliced.content);
   return { kind: "written", textHash: extractedTextHash(spliced.content) };
 }
+function isOwnRender(current, ackedHash, priorLines) {
+  if (extractedTextHash(spliceAnnotation(current, []).content) === ackedHash)
+    return true;
+  if (priorLines === undefined)
+    return false;
+  return extractedTextHash(spliceAnnotation(current, priorLines).content) === ackedHash;
+}
 function divergedNotice(relPath, state) {
   return `${relPath}: its memory context is now "${state}", but the file has local ` + `edits so the marker was not written into it. Your edits are untouched. ` + `Resolve the edit and the next sync writes the marker.`;
 }
+function generatedDivergedNotice(relPath) {
+  return `${relPath}: this generated file does not match Plinth's record of it, ` + `so its memory marker was not written. Plinth rewrites the file when its ` + `source next changes; changes made to it here are not synced.`;
+}
 function unreadableNotice(relPath, why) {
   const reason = why.replace(/\s+/g, " ").trim().slice(0, 120);
   return `${relPath}: its memory context could not be written because the file's ` + `frontmatter could not be read (${reason}). The file is untouched. Fix the ` + `frontmatter and the next sync writes the marker.`;
@@ -42049,6 +42276,10 @@ function heldFileTexts(state) {
     textHash: f.text_hash
   }));
 }
+function priorFileLines(state, id) {
+  return getMemorySourceEntries(state, "workspace_files")[id]?.rendered.split(`
+`);
+}
 async function writeChanged(args) {
   const docs = new Map(heldDocuments(args.state).map((d) => [d.id, d.slug]));
   const texts = new Map(heldFileTexts(args.state).map((f) => [f.id, f]));
@@ -42148,7 +42379,8 @@ async function writeChanged(args) {
           workspaceSlug: args.workspaceSlug,
           relPath: file2.relPath,
           textHash: args.freshTextHashes?.get(answer2.id) ?? file2.textHash,
-          lines: answer2.lines
+          lines: answer2.lines,
+          priorLines: priorFileLines(args.state, answer2.id)
         });
         if (res.kind !== "diverged" && res.kind !== "absent") {
           args.onWritten?.("workspace_files", answer2.id, res.textHash);
@@ -42175,7 +42407,7 @@ async function writeChanged(args) {
     }
     const textPath = extractedTextRelPath(file2.relPath);
     if (outcome.kind === "diverged") {
-      report.push({ path: textPath, record: divergedNotice(textPath, answer2.entry.state) });
+      report.push({ path: textPath, record: generatedDivergedNotice(textPath) });
     } else {
       clear.push(textPath);
     }
@@ -42184,9 +42416,11 @@ async function writeChanged(args) {
       if (outcome.textHash !== undefined) {
         textHashes.set(file2.relPath, { to: outcome.textHash });
       }
+    } else if (outcome.kind === "unchanged" && outcome.textHash !== undefined) {
+      textHashes.set(file2.relPath, { to: outcome.textHash });
     } else if (outcome.kind === "diverged") {
       diverged++;
-      notices.push(divergedNotice(outcome.relPath, answer2.entry.state));
+      notices.push(generatedDivergedNotice(outcome.relPath));
     }
   }
   if (args.abortIfStale?.() === true) {
@@ -42799,6 +43033,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 +43296,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 +43310,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 +43504,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 +43663,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 +43775,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 +43807,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 +43816,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 +43834,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 +43865,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 +43887,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 +43896,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)}**`));
@@ -43701,8 +44142,7 @@ class PullSuppressor {
 }
 
 // src/lib/discover-entities.ts
-var import_gray_matter12 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync23, statSync as statSync12 } from "node:fs";
+import { readFileSync as readFileSync24, statSync as statSync12 } from "node:fs";
 var DISCOVERY_WRITE_CAP_DEFAULT = 10;
 function discoveryWriteCap() {
   const raw = process.env.PLINTH_DISCOVERY_WRITE_CAP;
@@ -43729,6 +44169,11 @@ function classifyUntrackedEntity(args) {
   }
   return { kind: "create" };
 }
+function holdsUnreadableUntracked(args) {
+  if (args.readable)
+    return false;
+  return classifyUntrackedEntity({ ...args, frontmatter: {} }).kind === "create";
+}
 function classifyRenameDestination(args) {
   const occupant = getEntryBySlug(args.state, args.entityType, args.entitySlug);
   if (occupant && occupant.id !== args.movedEntryId) {
@@ -43799,13 +44244,20 @@ function planDiscoveryWrites(args) {
     if (getEntryBySlug(state, entityType, entitySlug))
       continue;
     counts.discovered++;
-    let frontmatter;
+    let raw;
     try {
-      frontmatter = import_gray_matter12.default(readFileSync23(absolutePath, "utf8")).data ?? {};
+      raw = readFileSync24(absolutePath, "utf8");
     } catch {
       counts.discovered--;
       continue;
     }
+    const read = readFrontmatter(raw);
+    if (!read.ok && holdsUnreadableUntracked({ entityType, entitySlug, readable: false })) {
+      counts.discovered--;
+      planned.push({ kind: "unreadable", entityType, entitySlug, absolutePath, why: read.why });
+      continue;
+    }
+    const frontmatter = read.ok ? read.parsed.data : {};
     const verdict = classifyUntrackedEntity({ entityType, entitySlug, frontmatter });
     if (verdict.kind === "hold") {
       if (verdict.held === "artist")
@@ -43846,7 +44298,7 @@ async function discoverUntrackedEntities(args) {
   }
   const cap = discoveryWriteCap();
   const creates = planned.filter((w) => w.kind === "create");
-  const toRun = creates.length > cap ? planned.filter((w) => w.kind === "rename") : planned;
+  const toRun = creates.length > cap ? planned.filter((w) => w.kind !== "create") : planned;
   if (creates.length > cap) {
     counts.heldCap = creates.length;
     output?.log(`[DISCOVERY_HELD reason=cap creates=${creates.length} cap=${cap} source=entity-discovery]`);
@@ -43869,6 +44321,19 @@ async function runPlannedWrites(args) {
   let state = args.state;
   for (const write of planned) {
     try {
+      if (write.kind === "unreadable") {
+        state = holdUnreadableFrontmatter({
+          state,
+          workspaceSlug,
+          absolutePath: write.absolutePath,
+          entityType: write.entityType,
+          slug: write.entitySlug,
+          why: write.why,
+          now,
+          output
+        });
+        continue;
+      }
       if (write.kind === "rename") {
         state = await runDiscoveredRename({
           write,
@@ -44029,8 +44494,7 @@ function recordDiscoveryFailure(args) {
 }
 
 // src/lib/frontmatter-id-backfill.ts
-var import_gray_matter13 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync24, statSync as statSync13 } from "node:fs";
+import { readFileSync as readFileSync25, statSync as statSync13 } from "node:fs";
 var FRONTMATTER_ID_BACKFILL_VERSION = 1;
 function backfillWorthReporting(r) {
   return r.written > 0 || r.failed > 0 || r.skipped.foreignId > 0 || r.skipped.unwritable > 0 || r.skipped.slugCollision > 0;
@@ -44073,7 +44537,7 @@ function safeInode3(path5) {
 function backfillFrontmatterIds(args) {
   const { workspaceSlug, state } = args;
   const compose = args.compose ?? withFrontmatterId;
-  const readRaw = args.readFile ?? ((p) => readFileSync24(p, "utf8"));
+  const readRaw = args.readFile ?? ((p) => readFileSync25(p, "utf8"));
   const result = emptyResult();
   if (state.frontmatter_id_backfill_version === FRONTMATTER_ID_BACKFILL_VERSION) {
     return result;
@@ -44122,7 +44586,7 @@ function backfillFrontmatterIds(args) {
       let rawBody;
       let parsedData;
       try {
-        const parsed = import_gray_matter13.default(raw);
+        const parsed = parseUncached(raw);
         parsedData = parsed.data ?? {};
         existing = parsedData["id"];
         rawBody = parsed.content;
@@ -44201,11 +44665,11 @@ function backfillFrontmatterIds(args) {
 }
 
 // src/lib/reconcile.ts
-import { readFileSync as readFileSync25, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync26, statSync as statSync14 } from "node:fs";
 async function reconcileDivergedRows(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl, output, isFrozen } = args;
   const now = args.now ?? (() => new Date);
-  let state = args.state;
+  let state = settleFrontmatterHolds(args.state, workspaceSlug);
   let scanned = 0;
   let diverged = 0;
   let pushed = 0;
@@ -44313,7 +44777,7 @@ async function reconcileDivergedRows(args) {
       }
       let content;
       try {
-        content = readFileSync25(absolutePath, "utf8");
+        content = readFileSync26(absolutePath, "utf8");
       } catch (err) {
         if (err?.code === "ENOENT") {
           state = clearEntityCloudRowDeleted(state, strategy.mirrorRelativePath(entry2.slug));
@@ -44321,6 +44785,20 @@ async function reconcileDivergedRows(args) {
         }
         throw err;
       }
+      const unreadable = frontmatterParseError(content);
+      if (unreadable !== null) {
+        state = holdUnreadableFrontmatter({
+          state,
+          workspaceSlug,
+          absolutePath,
+          entityType,
+          slug: entry2.slug,
+          why: unreadable,
+          now,
+          output
+        });
+        continue;
+      }
       const hashes = computeMirrorHashes(strategy, content);
       if (hashes.frontmatterId === undefined)
         sawTrackedFileWithoutId = true;
@@ -44371,7 +44849,7 @@ async function reconcileDivergedRows(args) {
         ops: pendingOps
       });
       quarantined = ops.length;
-      output?.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${ops.length} reason=${result.reason.kind} source=reconcile]`);
+      output?.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${ops.length} reason=${tripReasonToken(result.reason)} source=reconcile]`);
     } else {
       for (const c of guttingCandidates) {
         const op = c.op;
@@ -45602,7 +46080,7 @@ class Semaphore {
       this.active += 1;
       return;
     }
-    await new Promise((resolve6) => this.waiters.push(resolve6));
+    await new Promise((resolve7) => this.waiters.push(resolve7));
   }
   release() {
     const next = this.waiters.shift();
@@ -45664,9 +46142,9 @@ function createThrottledFetch(baseFetch, opts = {}) {
 // src/commands/sync.ts
 import {
   existsSync as existsSync9,
-  lstatSync as lstatSync6,
+  lstatSync as lstatSync7,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync29,
+  readFileSync as readFileSync30,
   statSync as statSync17,
   unlinkSync as unlinkSync9
 } from "node:fs";
@@ -45850,17 +46328,17 @@ function refreshConflictsView(workspaceSlug) {
 }
 
 // src/lib/files/pull.ts
-import { existsSync as existsSync8, lstatSync as lstatSync5, readFileSync as readFileSync27, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync8, lstatSync as lstatSync6, readFileSync as readFileSync28, statSync as statSync15 } from "node:fs";
 import { dirname as dirname13 } from "node:path";
 
 // src/lib/permanent-disposition.ts
 import { createHash as createHash6 } from "node:crypto";
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync27 } from "node:fs";
 function sha256(value) {
   return createHash6("sha256").update(value).digest("hex");
 }
 function verifyStash(path5, expectedHash) {
-  const actual = sha256(readFileSync26(path5));
+  const actual = sha256(readFileSync27(path5));
   if (actual !== expectedHash) {
     throw new Error(`permanent deletion stash verification failed for ${path5}`);
   }
@@ -45904,7 +46382,7 @@ function disposePermanentDocumentLocked(args) {
     const target = entityFilePath(args.workspaceSlug, args.strategy.type, retiredEntry?.slug ?? t.logicalKey);
     let raw;
     try {
-      raw = readFileSync26(target, "utf8");
+      raw = readFileSync27(target, "utf8");
     } catch (error52) {
       if (error52?.code !== "ENOENT")
         throw error52;
@@ -46002,7 +46480,7 @@ function disposePermanentFileLocked(args) {
     const target = filesSubtreePath(args.workspaceSlug, t.logicalKey);
     let bytes;
     try {
-      bytes = readFileSync26(target);
+      bytes = readFileSync27(target);
     } catch (error52) {
       if (error52?.code !== "ENOENT")
         throw error52;
@@ -46061,7 +46539,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 +46563,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 +46652,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 +46670,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 +46693,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 +46718,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 +46772,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 +46799,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 +46850,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) {
@@ -46455,7 +46972,7 @@ async function applyFileRow(args) {
     }
     let localBytes;
     try {
-      localBytes = readFileSync27(abs);
+      localBytes = readFileSync28(abs);
     } catch {
       localBytes = undefined;
     }
@@ -46501,6 +47018,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 +47081,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,
@@ -46661,7 +47189,7 @@ function stashUnpushedLocalEdit(args) {
     return { reason: "symlink" };
   let st;
   try {
-    st = lstatSync5(abs);
+    st = lstatSync6(abs);
   } catch (err) {
     if (err?.code === "ENOENT")
       return null;
@@ -46671,7 +47199,7 @@ function stashUnpushedLocalEdit(args) {
     return { reason: "not_a_file" };
   let localBytes;
   try {
-    localBytes = readFileSync27(abs);
+    localBytes = readFileSync28(abs);
   } catch (err) {
     return { reason: "unreadable", code: errCode(err) };
   }
@@ -46712,6 +47240,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;
@@ -46719,7 +47249,7 @@ function textIsCurrent(existing, row, workspaceSlug, relPath) {
 }
 
 // src/lib/files/rejection-sync.ts
-import { readFileSync as readFileSync28, statSync as statSync16 } from "node:fs";
+import { readFileSync as readFileSync29, statSync as statSync16 } from "node:fs";
 
 // src/lib/files/rejections-api.ts
 var RejectionsFeedSchema = exports_external.object({
@@ -46852,7 +47382,7 @@ function settledDisposition(args) {
     return null;
   let bytes;
   try {
-    bytes = readFileSync28(absolute2);
+    bytes = readFileSync29(absolute2);
   } catch {
     return null;
   }
@@ -46968,7 +47498,7 @@ function unlinkIfProvablyOurs(workspaceSlug, strategy, entry2, suppressor) {
   }
   let raw;
   try {
-    raw = readFileSync29(target, "utf8");
+    raw = readFileSync30(target, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
       return { didUnlink: false };
@@ -47023,6 +47553,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 +47623,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 +47634,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 +47760,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 +47782,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 +47792,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 +47808,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 +47828,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 +47868,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 +47891,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 +47927,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 +47937,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 +47952,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 +47976,8 @@ async function runSync(workspaceSlug, deps = {}) {
       pat,
       state,
       cursor: filesStartCursor,
+      baseCursor: filesBaseCursor,
+      recentUnlinks: deps.recentUnlinks,
       fetchImpl,
       now,
       output: out,
@@ -47418,7 +47991,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 +48001,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 +48201,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 +48219,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 +48333,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({
@@ -47777,13 +48375,16 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at && relocation.kind !== "moved") {
     let localRaw = null;
     try {
-      localRaw = readFileSync29(entityFilePath(workspaceSlug, strategy.type, writeSlug), "utf8");
+      localRaw = readFileSync30(entityFilePath(workspaceSlug, strategy.type, writeSlug), "utf8");
     } catch {
       localRaw = null;
     }
     if (localRaw !== null) {
-      const localHashes = computeMirrorHashes(strategy, localRaw);
-      const diverged = localHashes.bodyHash !== existingEntry.body_hash || localHashes.frontmatterHash !== existingEntry.frontmatter_hash;
+      let diverged = !strategy.preserveLocalBodyOnPull && frontmatterParseError(localRaw) !== null;
+      if (!diverged) {
+        const localHashes = computeMirrorHashes(strategy, localRaw);
+        diverged = localHashes.bodyHash !== existingEntry.body_hash || localHashes.frontmatterHash !== existingEntry.frontmatter_hash;
+      }
       if (diverged) {
         const stashPath = stashConflict({
           workspaceSlug,
@@ -47801,7 +48402,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
     const target = entityFilePath(workspaceSlug, strategy.type, writeSlug);
     let localRaw = null;
     try {
-      localRaw = lstatSync6(target).isFile() ? readFileSync29(target, "utf8") : null;
+      localRaw = lstatSync7(target).isFile() ? readFileSync30(target, "utf8") : null;
     } catch {
       localRaw = null;
     }
@@ -47967,7 +48568,7 @@ function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync18(p)
     return { state, changed: false };
   return { state: { ...state, entries: nextEntries }, changed: true };
 }
-function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync30(p, "utf8")) {
+function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync31(p, "utf8")) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -47979,7 +48580,7 @@ function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync3
       }
       try {
         const path5 = entityFilePath(workspaceSlug, entityType, entry2.slug);
-        const bodyLen = import_gray_matter14.default(readFn(path5)).content.length;
+        const bodyLen = parseUncached(readFn(path5)).content.length;
         nextBucket[id] = { ...entry2, body_len: bodyLen };
         changed = true;
       } catch {
@@ -47992,6 +48593,18 @@ function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync3
     return { state, changed: false };
   return { state: { ...state, entries: nextEntries }, changed: true };
 }
+function isOwnWriteEcho(suppressor, absolutePath, strategy, raw) {
+  if (frontmatterParseError(raw) !== null)
+    return false;
+  return suppressor.shouldSuppressUpsert(absolutePath, computeMirrorHashes(strategy, raw));
+}
+function destinationIsUnreadable(absolutePath) {
+  try {
+    return frontmatterParseError(readFileSync31(absolutePath, "utf8")) !== null;
+  } catch {
+    return false;
+  }
+}
 function makeWatchHandler(deps) {
   const {
     workspaceSlug,
@@ -48108,7 +48721,7 @@ function makeWatchHandler(deps) {
         spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
         return;
       }
-      const bytes = readFileSync30(absolutePath);
+      const bytes = readFileSync31(absolutePath);
       const hash2 = sha256Bytes(bytes);
       if (suppressor?.shouldSuppressUpsert(absolutePath, {
         bodyHash: hash2,
@@ -48172,7 +48785,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48211,7 +48824,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48250,7 +48863,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48289,7 +48902,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48328,7 +48941,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48374,11 +48987,11 @@ function makeWatchHandler(deps) {
           const strategy = getStrategy(classifiedFrom.entityType);
           let toRaw = null;
           try {
-            toRaw = readFileSync30(event.toPath, "utf8");
+            toRaw = readFileSync31(event.toPath, "utf8");
           } catch {
             toRaw = null;
           }
-          const isEcho = strategy !== undefined && toRaw !== null && suppressor.shouldSuppressUpsert(event.toPath, computeMirrorHashes(strategy, toRaw));
+          const isEcho = strategy !== undefined && toRaw !== null && isOwnWriteEcho(suppressor, event.toPath, strategy, toRaw);
           if (isEcho) {
             output?.log(`[RENAME_SUPPRESSED entityType=${classifiedFrom.entityType} ` + `from=${event.fromSlug} id=${event.id} reason=pull_echo]`);
             return;
@@ -48386,6 +48999,9 @@ function makeWatchHandler(deps) {
           await handle({ kind: "upsert", absolutePath: event.toPath });
           return;
         }
+        if (destinationIsUnreadable(event.toPath)) {
+          await handle({ kind: "upsert", absolutePath: event.toPath });
+        }
         const base3 = getState();
         const result2 = await pushRename({
           workspaceSlug,
@@ -48443,7 +49059,7 @@ function makeWatchHandler(deps) {
         if (event.kind === "upsert") {
           try {
             ownEcho = suppressor?.shouldSuppressUpsert(absolutePath, {
-              bodyHash: stableHash(readFileSync30(absolutePath, "utf8")),
+              bodyHash: stableHash(readFileSync31(absolutePath, "utf8")),
               frontmatterHash: ""
             }) === true;
           } catch {
@@ -48498,11 +49114,11 @@ function makeWatchHandler(deps) {
           if (strategy) {
             let raw = null;
             try {
-              raw = readFileSync30(absolutePath, "utf8");
+              raw = readFileSync31(absolutePath, "utf8");
             } catch {
               raw = null;
             }
-            if (raw !== null && suppressor.shouldSuppressUpsert(absolutePath, computeMirrorHashes(strategy, raw))) {
+            if (raw !== null && isOwnWriteEcho(suppressor, absolutePath, strategy, raw)) {
               return;
             }
           }
@@ -48553,7 +49169,8 @@ function makeWatchHandler(deps) {
           echo: suppressor ? { watcher: "live", suppressor } : undefined
         }
       });
-      applyState(result.base ?? base2, clearEntityRejected(result.state, workspaceSlug, absolutePath));
+      const heldUnreadable = result.outcome.kind === "ignored" && result.outcome.reason === FRONTMATTER_PARSE_ERROR;
+      applyState(result.base ?? base2, heldUnreadable ? result.state : clearEntityRejected(result.state, workspaceSlug, absolutePath));
       reportOutcome(spinner, workspaceSlug, getState(), result.outcome);
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown push error";
@@ -49101,7 +49718,7 @@ async function runStart(workspaceSlug, deps = {}) {
         return;
       }
       refreshFrozen();
-      out.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${batch.length} reason=${result.reason.kind}]`);
+      out.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${batch.length} reason=${tripReasonToken(result.reason)}]`);
       spinner.warn(`Held ${batch.length} destructive op${batch.length === 1 ? "" : "s"} pending confirm → ${stashPath}. Run \`plinth confirm\` to review.`);
       spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
     }
@@ -49157,7 +49774,7 @@ async function runStart(workspaceSlug, deps = {}) {
         return;
       }
       refreshFrozen();
-      out.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${batch.length} reason=${result.reason.kind} source=files-watch]`);
+      out.log(`[DESTRUCTIVE_HELD batch=${batchId} ops=${batch.length} reason=${tripReasonToken(result.reason)} source=files-watch]`);
       spinner.warn(`Held ${batch.length} destructive file op${batch.length === 1 ? "" : "s"} pending confirm → ${stashPath}. Run \`plinth confirm\` to review.`);
       spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
     }
@@ -49187,13 +49804,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 +49827,7 @@ async function runStart(workspaceSlug, deps = {}) {
         isFileFrozen,
         loggedTombstoneSkips,
         loggedStashNotices
-      });
+      }));
       if (result.exitCode === 0) {
         const applied = result.applied ?? 0;
         if (applied > 0) {
@@ -49244,6 +49866,9 @@ async function runStart(workspaceSlug, deps = {}) {
     afterPoll: () => {
       (async () => {
         state = loadState(slug);
+        const unsettled = state;
+        const settled = settleFrontmatterHolds(unsettled, slug);
+        state = rebaseState(state, unsettled, settled);
         if (draining)
           return;
         draining = true;
@@ -49465,12 +50090,12 @@ async function runStart(workspaceSlug, deps = {}) {
       try {
         await Promise.race([
           watcher.drainPending().then(() => Promise.all([gate.drain(), fileGate.drain()])),
-          new Promise((resolve6) => setTimeout(() => resolve6(-1), SHUTDOWN_DRAIN_TIMEOUT_MS))
+          new Promise((resolve7) => setTimeout(() => resolve7(-1), SHUTDOWN_DRAIN_TIMEOUT_MS))
         ]);
       } finally {
         await Promise.race([
           watcher.stop(),
-          new Promise((resolve6) => setTimeout(resolve6, SHUTDOWN_DRAIN_TIMEOUT_MS))
+          new Promise((resolve7) => setTimeout(resolve7, SHUTDOWN_DRAIN_TIMEOUT_MS))
         ]);
         clearDaemonPid(slug);
         releaseDaemonLock(lockHandle);
@@ -50025,7 +50650,7 @@ function assessContextWalls(workspaceSlug, deps = {}) {
 
 // src/lib/build-stamp.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync11, mkdirSync as mkdirSync12, readFileSync as readFileSync31, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync12, readFileSync as readFileSync32, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname14, join as join19 } from "node:path";
 import { fileURLToPath } from "node:url";
 var BUILD_STAMP_FILENAME = "build-stamp.json";
@@ -50049,7 +50674,7 @@ function readHead(repoDir) {
 }
 function readBuildStamp(distDir) {
   try {
-    const parsed = JSON.parse(readFileSync31(stampPath(distDir), "utf8"));
+    const parsed = JSON.parse(readFileSync32(stampPath(distDir), "utf8"));
     if (parsed && typeof parsed.sha === "string" && parsed.sha.length > 0 && typeof parsed.dirty === "boolean" && typeof parsed.built_at === "string") {
       return { sha: parsed.sha, dirty: parsed.dirty, built_at: parsed.built_at };
     }
@@ -50110,12 +50735,12 @@ function checkBuildStaleness(deps = {}) {
 }
 
 // src/lib/memory-links.ts
-import { readFileSync as readFileSync32 } from "node:fs";
-import { relative as relative15, sep as sep8 } from "node:path";
+import { readFileSync as readFileSync33 } from "node:fs";
+import { relative as relative15, sep as sep9 } from "node:path";
 var MEMORY_FILE_RE = /^(workspace-memory\.md|user-memory\.md|artists\/[^/]+\/memory\.md|memory\/[^/]+\.md|memory\/private\/[^/]+\.md)$/i;
 function scanMemoryLinks(deps) {
   const listFiles = deps.listFiles ?? ((r) => walkSubtreeFiles(r, isVcsInternal));
-  const readFile = deps.readFile ?? ((p) => readFileSync32(p, "utf8"));
+  const readFile = deps.readFile ?? ((p) => readFileSync33(p, "utf8"));
   let root;
   let absPaths;
   try {
@@ -50124,7 +50749,7 @@ function scanMemoryLinks(deps) {
   } catch {
     return { scanned: 0, unreadable: [], dead: [] };
   }
-  const relPaths = absPaths.map((p) => relative15(root, p).split(sep8).join("/"));
+  const relPaths = absPaths.map((p) => relative15(root, p).split(sep9).join("/"));
   const artists = buildArtistIndex(relPaths, root, (abs) => readFile(abs));
   const dead = [];
   const unreadable = [];
@@ -50159,9 +50784,8 @@ function scanMemoryLinks(deps) {
 init_output();
 
 // src/lib/pending-writes.ts
-import { readFileSync as readFileSync33, statSync as statSync19 } from "node:fs";
+import { readFileSync as readFileSync34, statSync as statSync19 } from "node:fs";
 import { relative as relative16 } from "node:path";
-var import_gray_matter15 = __toESM(require_gray_matter(), 1);
 var EMPTY3 = { writes: [], count: 0 };
 function reportedElsewhere(state) {
   const entities = new Set;
@@ -50207,7 +50831,7 @@ function scanPendingWrites(args) {
         continue;
       let hash2;
       try {
-        hash2 = sha256Bytes(readFileSync33(absolutePath));
+        hash2 = sha256Bytes(readFileSync34(absolutePath));
       } catch {
         continue;
       }
@@ -50238,17 +50862,15 @@ function scanPendingWrites(args) {
       continue;
     let content;
     try {
-      content = readFileSync33(absolutePath, "utf8");
+      content = readFileSync34(absolutePath, "utf8");
     } catch {
       continue;
     }
     if (!entry2) {
-      let frontmatter;
-      try {
-        frontmatter = import_gray_matter15.default(content).data ?? {};
-      } catch {
+      const read = readFrontmatter(content);
+      if (holdsUnreadableUntracked({ entityType, entitySlug, readable: read.ok }))
         continue;
-      }
+      const frontmatter = read.ok ? read.parsed.data : {};
       const verdict = classifyUntrackedEntity({
         entityType,
         entitySlug,
@@ -50704,7 +51326,7 @@ async function runStatus(args, deps = {}) {
     }
   }
   if (freshness.length > 0) {
-    out.info(row("Memory context", `${freshness.length} file${freshness.length === 1 ? "" : "s"} could not be marked with ${freshness.length === 1 ? "its" : "their"} current memory state. Your edits are untouched.`));
+    out.info(row("Memory context", `${freshness.length} file${freshness.length === 1 ? "" : "s"} could not be marked with ${freshness.length === 1 ? "its" : "their"} current memory state.`));
     for (const r of freshness.slice(0, MAX_SHOWN)) {
       out.info(cont(r.message));
     }
@@ -51149,7 +51771,7 @@ var versionCommand = defineCommand({
 });
 
 // src/commands/voice-gate.ts
-import { readFileSync as readFileSync36 } from "node:fs";
+import { readFileSync as readFileSync37 } from "node:fs";
 
 // src/lib/voice-gate/api.ts
 var VoiceGateSurfaces = [
@@ -51254,7 +51876,7 @@ async function callVoiceGate(req) {
 import { createHash as createHash7 } from "node:crypto";
 import {
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   renameSync as renameSync9,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync9
@@ -51285,7 +51907,7 @@ function emptyFile() {
 }
 function load2(workspaceSlug) {
   try {
-    const raw = readFileSync34(attemptsPath(workspaceSlug), "utf8");
+    const raw = readFileSync35(attemptsPath(workspaceSlug), "utf8");
     const parsed = AttemptsFileSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : emptyFile();
   } catch {
@@ -51448,9 +52070,9 @@ function denyUngated(detail) {
 }
 
 // src/lib/voice-gate/payload.ts
-import { readFileSync as readFileSync35, statSync as statSync21 } from "node:fs";
+import { readFileSync as readFileSync36, statSync as statSync21 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute4, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute4, resolve as resolve7 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
 var HELPER_BASENAME = "push_gmail_draft.py";
 var DRAFT_FLAGS = ["--to", "--body-file", "--body-stdin"];
@@ -51609,7 +52231,7 @@ function defaultReadBodyFile(path5) {
   if (stat4.size > MAX_BODY_BYTES) {
     throw new Error(`draft body is ${stat4.size} bytes, over the ${MAX_BODY_BYTES}-byte gate limit`);
   }
-  return readFileSync35(path5, "utf8");
+  return readFileSync36(path5, "utf8");
 }
 function parseRecipients(...raw) {
   const all = raw.filter((v) => typeof v === "string").flatMap((v) => v.split(",")).map((v) => v.trim().toLowerCase()).filter((v) => v.length > 0);
@@ -51644,13 +52266,13 @@ function applyCd(tokens, state) {
     return { dir: expanded, known: true };
   if (!state.known)
     return state;
-  return { dir: resolve6(state.dir, expanded), known: true };
+  return { dir: resolve7(state.dir, expanded), known: true };
 }
 function expandHome(path5) {
   if (path5 === "~")
     return homedir2();
   if (path5.startsWith("~/"))
-    return resolve6(homedir2(), path5.slice(2));
+    return resolve7(homedir2(), path5.slice(2));
   return path5;
 }
 function classifyHelperSegment(tokens, dirState, readBodyFile) {
@@ -51676,7 +52298,7 @@ function classifyHelperSegment(tokens, dirState, readBodyFile) {
       unreadable: `the draft push uses a relative \`--body-file\` (${bodyFile}) after a \`cd\` ` + `the voice gate cannot resolve, so it cannot tell which file ships. Pass an ` + `absolute \`--body-file\` path.`
     };
   }
-  const resolved = isAbsolute4(expanded) ? expanded : resolve6(dirState.dir, expanded);
+  const resolved = isAbsolute4(expanded) ? expanded : resolve7(dirState.dir, expanded);
   let body;
   try {
     body = readBodyFile(resolved);
@@ -51969,7 +52591,7 @@ async function runVoiceGateDirect(args, deps = {}) {
   let text;
   if (args.file) {
     try {
-      text = readFileSync36(args.file, "utf8");
+      text = readFileSync37(args.file, "utf8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       out.error(`Could not read ${args.file}: ${msg}`);