@plinth-music/cli 0.23.1 → 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.1",
+  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, {
@@ -22189,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 + `
 `;
@@ -22829,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(),
@@ -22984,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 + `
 `;
@@ -24475,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 },
@@ -24557,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;
   }
@@ -24825,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();
       }
@@ -25634,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),
@@ -25743,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) {
@@ -27630,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) {
@@ -27655,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 });
@@ -29045,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;
@@ -29172,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;
   }
@@ -30545,6 +30582,9 @@ 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}]`;
 }
@@ -30739,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;
@@ -34319,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";
@@ -34386,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) {
@@ -34431,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;
     }
@@ -34445,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);
@@ -34470,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)
@@ -34504,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;
@@ -34564,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";
@@ -34706,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
@@ -34897,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) {
@@ -34964,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;
@@ -34978,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");
   }
@@ -34986,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");
     }
@@ -35485,7 +35740,7 @@ async function pushFilesUpsertLocked(args) {
         state: next
       };
     }
-    bytes = readFileSync17(absolutePath);
+    bytes = readFileSync18(absolutePath);
     hash2 = sha256Bytes(bytes);
     inode = st.ino;
   }
@@ -35747,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
 ` : `
@@ -35789,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.`;
 }
@@ -36049,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);
@@ -36202,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({
@@ -36222,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 {
@@ -36252,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);
@@ -36537,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);
@@ -36552,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;
       }
@@ -37014,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));
@@ -37486,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);
@@ -37523,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,
@@ -37571,7 +37745,7 @@ async function pushRename(args) {
     }
     let contents = "";
     try {
-      contents = readFileSync19(toPath, "utf8");
+      contents = readFileSync20(toPath, "utf8");
     } catch {}
     const stashPath = stashConflict({
       workspaceSlug,
@@ -37704,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;
         }
@@ -37743,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;
   }
@@ -37780,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;
@@ -37790,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({
@@ -38547,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) {
@@ -38644,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;
@@ -38715,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";
@@ -39711,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, () => {
@@ -39720,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) => {
@@ -40479,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 {
@@ -40610,7 +40784,7 @@ function watcherIgnoreMatcher(workspaceRoot) {
   return (absolutePath) => patterns.some((re) => re.test(absolutePath));
 }
 function escSep() {
-  return sep7 === "/" ? "/" : "\\\\";
+  return sep8 === "/" ? "/" : "\\\\";
 }
 
 class DebounceMap {
@@ -40754,7 +40928,7 @@ function readBlobForPush(args) {
   }
   let bytes;
   try {
-    bytes = readFileSync21(absolutePath);
+    bytes = readFileSync22(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -40897,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);
@@ -41064,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,
@@ -41093,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) {
@@ -41105,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({
@@ -41815,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";
@@ -41896,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);
@@ -41982,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;
@@ -42010,7 +42183,7 @@ function writeDocumentAnnotation(args) {
   }
   let current;
   try {
-    current = readFileSync22(target, "utf8");
+    current = readFileSync23(target, "utf8");
   } catch {
     return { kind: "absent" };
   }
@@ -42048,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.`;
@@ -42089,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]));
@@ -42188,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);
@@ -42215,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);
     }
@@ -42224,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) {
@@ -43948,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;
@@ -43976,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) {
@@ -44046,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")
@@ -44093,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]`);
@@ -44116,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,
@@ -44276,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;
@@ -44320,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;
@@ -44369,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;
@@ -44448,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;
@@ -44560,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));
@@ -44568,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;
@@ -44618,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;
@@ -45849,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();
@@ -45911,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";
@@ -46097,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}`);
   }
@@ -46151,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;
@@ -46249,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;
@@ -46741,7 +46972,7 @@ async function applyFileRow(args) {
     }
     let localBytes;
     try {
-      localBytes = readFileSync27(abs);
+      localBytes = readFileSync28(abs);
     } catch {
       localBytes = undefined;
     }
@@ -46958,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;
@@ -46968,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) };
   }
@@ -47018,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({
@@ -47151,7 +47382,7 @@ function settledDisposition(args) {
     return null;
   let bytes;
   try {
-    bytes = readFileSync28(absolute2);
+    bytes = readFileSync29(absolute2);
   } catch {
     return null;
   }
@@ -47267,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 };
@@ -48144,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,
@@ -48168,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;
     }
@@ -48334,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)) {
@@ -48346,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 {
@@ -48359,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,
@@ -48475,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,
@@ -48539,7 +48785,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48578,7 +48824,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48617,7 +48863,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48656,7 +48902,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48695,7 +48941,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync30(absolutePath, "utf8");
+        raw = readFileSync31(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -48741,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;
@@ -48753,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,
@@ -48810,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 {
@@ -48865,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;
             }
           }
@@ -48920,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";
@@ -49468,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)}`);
     }
@@ -49524,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)}`);
     }
@@ -49616,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;
@@ -49837,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);
@@ -50397,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";
@@ -50421,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 };
     }
@@ -50482,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 {
@@ -50496,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 = [];
@@ -50531,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;
@@ -50579,7 +50831,7 @@ function scanPendingWrites(args) {
         continue;
       let hash2;
       try {
-        hash2 = sha256Bytes(readFileSync33(absolutePath));
+        hash2 = sha256Bytes(readFileSync34(absolutePath));
       } catch {
         continue;
       }
@@ -50610,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,
@@ -51076,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));
     }
@@ -51521,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 = [
@@ -51626,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
@@ -51657,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 {
@@ -51820,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"];
@@ -51981,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);
@@ -52016,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) {
@@ -52048,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);
@@ -52341,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}`);