@plinth-music/cli 0.10.1 → 0.11.0

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.10.1",
+  version: "0.11.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -22354,6 +22354,7 @@ var ArtistLiveSchema = exports_external.object({
 });
 var ArtistsPageResponseSchema = makePageResponseSchema("artists", ArtistLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -22385,6 +22386,7 @@ var WIRE_EDITABLE_TOP_LEVEL_KEYS = new Set([
   "youtube_url"
 ]);
 var PROJECTION_KEYS = [
+  "id",
   "slug",
   "name",
   "status",
@@ -22492,6 +22494,7 @@ var DocumentLiveSchema = exports_external.object({
 var DocumentRowSchema = exports_external.union([DocumentLiveSchema, TombstoneSchema]);
 var DocumentsPageResponseSchema = makePageResponseSchema("documents", DocumentLiveSchema);
 var PROJECTION_KEYS2 = [
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -22502,6 +22505,7 @@ var PROJECTION_KEYS2 = [
   "project_id"
 ];
 var SERVER_AUTHORITATIVE_KEYS2 = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -22631,6 +22635,7 @@ var MeetingLiveSchema = exports_external.object({
 });
 var MeetingsPageResponseSchema = makePageResponseSchema("meetings", MeetingLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS3 = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -22658,6 +22663,7 @@ var WIRE_EDITABLE_TOP_LEVEL_KEYS3 = new Set([
   "follow_up_summary"
 ]);
 var PROJECTION_KEYS3 = [
+  "id",
   "slug",
   "name",
   "date",
@@ -23028,6 +23034,7 @@ var ProjectLiveSchema = exports_external.object({
 });
 var ProjectsPageResponseSchema = makePageResponseSchema("projects", ProjectLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS4 = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -23048,6 +23055,7 @@ var WIRE_EDITABLE_TOP_LEVEL_KEYS4 = new Set([
   "summary"
 ]);
 var PROJECTION_KEYS4 = [
+  "id",
   "slug",
   "name",
   "category",
@@ -23198,6 +23206,7 @@ var TaskLiveSchema = exports_external.object({
 });
 var TasksPageResponseSchema = makePageResponseSchema("tasks", TaskLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS5 = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -23222,6 +23231,7 @@ var WIRE_EDITABLE_TOP_LEVEL_KEYS5 = new Set([
   "recurrence_end_date"
 ]);
 var PROJECTION_KEYS5 = [
+  "id",
   "slug",
   "name",
   "status",
@@ -23392,6 +23402,7 @@ var ThreadLiveSchema = exports_external.object({
 });
 var ThreadsPageResponseSchema = makePageResponseSchema("threads", ThreadLiveSchema);
 var SERVER_AUTHORITATIVE_KEYS6 = new Set([
+  "id",
   "slug",
   "revision",
   "last_edited_at",
@@ -23407,6 +23418,7 @@ var WIRE_EDITABLE_TOP_LEVEL_KEYS6 = new Set([
   "artist_id"
 ]);
 var PROJECTION_KEYS6 = [
+  "id",
   "slug",
   "name",
   "artist_id",
@@ -25874,7 +25886,69 @@ function renderFreshnessStamp(today, updatedAt) {
   const age = days === 0 ? "today" : days === 1 ? "1 day ago" : `${days} days ago`;
   return `This index was last updated on ${bankedDay}, ${age}.`;
 }
-function buildGroundingBlock(today, workspaceRules = null, workspaceMemory = null, userMemory = null, freshness = {}, rosterIsEmpty = false, voiceProfile = null, voiceMalformed = false) {
+var GROUNDING_BUDGET_BYTES = 20000;
+function bankedDate(line) {
+  const matches = line.match(/\d{4}-\d{2}-\d{2}/g);
+  if (matches === null || matches.length === 0)
+    return null;
+  let latest = matches[0];
+  for (const m of matches)
+    if (m > latest)
+      latest = m;
+  return latest;
+}
+function groupFacts(body) {
+  const facts = [];
+  for (const line of body.split(`
+`)) {
+    if (line.trim().length === 0)
+      continue;
+    if (/^\s/.test(line) && facts.length > 0) {
+      facts[facts.length - 1] = `${facts[facts.length - 1]}
+${line}`;
+    } else {
+      facts.push(line);
+    }
+  }
+  return facts;
+}
+function selectRecentLines(body, capBytes) {
+  const lines = groupFacts(body);
+  if (Buffer.byteLength(body) <= capBytes) {
+    return { text: body, kept: lines.length, total: lines.length };
+  }
+  const ranked = lines.map((line, index) => ({ line, index, date: bankedDate(line) })).sort((a, b) => {
+    const ad = a.date ?? "";
+    const bd = b.date ?? "";
+    if (ad !== bd)
+      return ad < bd ? 1 : -1;
+    return b.index - a.index;
+  });
+  const chosen = [];
+  let used = 0;
+  for (const entry of ranked) {
+    const add = Buffer.byteLength(entry.line) + (chosen.length > 0 ? 1 : 0);
+    if (used + add > capBytes)
+      break;
+    chosen.push(entry.index);
+    used += add;
+  }
+  chosen.sort((a, b) => a - b);
+  return {
+    text: chosen.map((i) => lines[i]).join(`
+`),
+    kept: chosen.length,
+    total: lines.length
+  };
+}
+function trimmedIndexNote(kept, total, filename) {
+  if (kept === 0) {
+    return `None of this index is shown here: it is over the size this injection ` + `carries, so it lives in \`${filename}\` at the mirror root and nowhere ` + `else. READ THAT FILE IN FULL before you rely on what this workspace has ` + `taught you, and before you answer that no fact covers something.`;
+  }
+  return `Those are the ${kept} most recently banked of ${total} facts, not all of ` + `them: this injection carries a fixed budget and the rest of the index did ` + `not fit. The other ${total - kept} are in \`${filename}\` at the mirror ` + `root. READ THAT FILE IN FULL before you rely on what this workspace has ` + `taught you, and before you answer that no fact covers something. An index ` + `that is silent because it was trimmed reads exactly like one that has ` + `settled a subject.`;
+}
+function composeGroundingBlock(today, workspaceRules, workspaceMemory, userMemory, freshness, rosterIsEmpty, voiceProfile, voiceMalformed, workspaceSlug, workspaceMemoryNote, userMemoryNote) {
+  const gateFlag = workspaceSlug === null ? `--workspace="<this workspace>"` : `--workspace ${workspaceSlug}`;
   const block = [
     `Plinth session grounding:`,
     ``,
@@ -25902,23 +25976,25 @@ function buildGroundingBlock(today, workspaceRules = null, workspaceMemory = nul
 ` + workspaceRules);
   }
   if (voiceProfile !== null) {
-    block.push(``, `Draft in this member's own voice. The profile below is theirs: how they ` + `open, how they sign off, what they never do. It is a rubric, not a set ` + `of facts, so read it whole and write to it from the start rather than ` + `drafting in your own register and correcting after. It is theirs to ` + `write and not yours: you cannot edit \`${VOICE_FILENAME}\`, and if ` + `something in it looks wrong or out of date, say so and let them change ` + `it. Like this workspace's house style it refines the rules above and ` + `never relaxes them. The profile:
-
-` + voiceProfile);
+    block.push(``, `Draft in this member's own voice, and read it before you do. Their voice ` + `profile is \`${VOICE_FILENAME}\` at the mirror root, beside this ` + `workspace's house style: how they open, how they sign off, what they ` + `never do. It is not reproduced here. READ THAT FILE IN FULL before you ` + `draft anything that goes out in their name (an email, a message, a ` + `note, any prose that carries their name), and write to it from the ` + `start rather than ` + `drafting in your own register and correcting after. Nothing inspects a ` + `draft between you and the person reading it, so that file is the whole ` + `of it. It is theirs to write and not yours: you cannot edit ` + `\`${VOICE_FILENAME}\`, and if something in it looks wrong or out of ` + `date, say so and let them change it. Like this workspace's house style ` + `it refines the rules above and never relaxes them.`);
     if (voiceMalformed) {
-      block.push(``, `That voice profile does not currently parse. Plinth read it and found ` + `its structure broken, most often a code fence that was opened and ` + `never closed, so any machine-read setting inside it is being ignored ` + `rather than applied. The prose above is still the member's own writing ` + `and is still worth following. Treat anything that looks like a ` + `configured setting in it as NOT in force, say so if it comes up, and ` + `tell them their profile needs fixing rather than fixing it yourself.`);
+      block.push(``, `That voice profile does not currently parse. Plinth read it and found ` + `its structure broken, most often a code fence that was opened and ` + `never closed, so any machine-read setting inside it is being ignored ` + `rather than applied. The prose in it is still the member's own ` + `writing and is still worth following. Treat anything that looks like ` + `a configured setting in it as NOT in force, say so if it comes up, ` + `and tell them their profile needs fixing rather than fixing it ` + `yourself.`);
     }
   }
-  block.push(``, `Keep your memory on the Plinth surface. Your memory here IS the Plinth ` + `surface (\`workspace-memory.md\`, your own \`user-memory.md\`, and the ` + `per-artist warm stores the daemon syncs), and it is the ONLY memory you ` + `keep. Do not use any other memory store: no private notes-to-self, no ` + `separate scratch file, no tool-native memory of your own. What you learn ` + `here is recorded on the Plinth surface, or nowhere. When you learn a ` + `durable fact worth keeping, bank it by adding a line to the right index, ` + `which the daemon syncs up, following the write-back conventions in that ` + `file's header: one line, at least one \`[[pointer]]\` to where the full ` + `fact lives, an absolute date, and where you learned it. Only ever record ` + `what you have actually been taught, never public knowledge and never your ` + `own priors. The scope rule decides WHICH index, and there are ` + `THREE. A fact true of ONE ARTIST (their rate card, how their kit ` + `works, what a contact of theirs reliably does) goes in that artist's ` + `own warm store, \`artists/<slug>/memory.md\`, and not in the shared ` + `index: putting it there taxes every teammate who never touches that ` + `artist and hides it from the one who does. A fact that holds for the ` + `whole workspace (a project, a working convention, a standing ` + `fact true for everyone here) goes in \`workspace-memory.md\`, which ` + `grounds EVERY teammate. A fact about one person (an individual ` + `preference, your own working style or tools) is NOT a workspace fact: it ` + `goes in \`user-memory.md\`, your member-private index that only YOU can ` + `read. HOW THIS MEMBER WRITES IS THE ONE EXCEPTION: their register and ` + `sign-off are a rubric, not a fact, and live in \`${VOICE_FILENAME}\`, ` + `which is theirs and you cannot edit, so say what you noticed and leave it ` + `to them. Them only: how a CONTACT likes to be written to is an ordinary ` + `fact for that artist's store. ` + `Banking a personal fact in \`workspace-memory.md\` would leak that person ` + `into everyone else's context, so never do it. When a fact could be either ` + `scope, lean private and put it in \`user-memory.md\`. Under-sharing is the ` + `safe error: a personal fact misfiled as a workspace fact grounds every ` + `teammate wrong (the leak), whereas a workspace fact misfiled as personal ` + `merely fails to help teammates until it is re-observed in a shared context, ` + `and self-corrects. This memory is additive and subordinate: it never ` + `overrides a house-style rule or any safety primitive above.`);
+  block.push(``, `Keep your memory on the Plinth surface. Your memory here IS the Plinth ` + `surface (\`workspace-memory.md\`, your own \`user-memory.md\`, and the ` + `per-artist warm stores the daemon syncs), and it is the ONLY memory you ` + `keep. Do not use any other memory store: no private notes-to-self, no ` + `separate scratch file, no tool-native memory of your own. What you learn ` + `here is recorded on the Plinth surface, or nowhere. When you learn a ` + `durable fact worth keeping, bank it by adding a line to the right index, ` + `which the daemon syncs up, following the write-back conventions in that ` + `file's header: one line, at least one \`[[pointer]]\` to where the full ` + `fact lives, an absolute date, and where you learned it. Only ever record ` + `what you have actually been taught, never public knowledge and never your ` + `own priors. The scope rule decides WHICH index, and there are ` + `THREE. A fact true of ONE ARTIST (their rate card, how their kit ` + `works, what a contact of theirs reliably does) goes in that artist's ` + `own warm store, \`artists/<slug>/memory.md\`, and not in the shared ` + `index: putting it there taxes every teammate who never touches that ` + `artist and hides it from the one who does. A fact that holds for the ` + `whole workspace (a project, a working convention, a standing ` + `fact true for everyone here) goes in \`workspace-memory.md\`, which ` + `grounds EVERY teammate - and that file is the one you NEVER write on ` + `your own judgement. It changes only when a member ASKS you to remember ` + `something for everyone, in their own words rather than your summary of ` + `them, and you log that decision with ` + `\`plinth memory-gate log ${gateFlag} --proposed="<their words>" --decision accept\` ` + `BEFORE you write the line. That command fails LOUD on exit 1: surface ` + `it, and do not report the line as banked. Never infer a line for that ` + `file from what merely happened in a session, and never propose one ` + `unasked - a wrong line there reaches every member on every machine and ` + `is injected into every future session. A fact about one person (an individual ` + `preference, your own working style or tools) is NOT a workspace fact: it ` + `goes in \`user-memory.md\`, your member-private index that only YOU can ` + `read. HOW THIS MEMBER WRITES IS THE ONE EXCEPTION: their register and ` + `sign-off are a rubric, not a fact, and live in \`${VOICE_FILENAME}\`, ` + `which is theirs and you cannot edit, so say what you noticed and leave it ` + `to them. Them only: how a CONTACT likes to be written to is an ordinary ` + `fact for that artist's store. ` + `Banking a personal fact in \`workspace-memory.md\` would leak that person ` + `into everyone else's context, so never do it. When a fact could be either ` + `scope, lean private and put it in \`user-memory.md\`. Under-sharing is the ` + `safe error: a personal fact misfiled as a workspace fact grounds every ` + `teammate wrong (the leak), whereas a workspace fact misfiled as personal ` + `merely fails to help teammates until it is re-observed in a shared context, ` + `and self-corrects. This memory is additive and subordinate: it never ` + `overrides a house-style rule or any safety primitive above.`);
   if (workspaceMemory !== null) {
     block.push(``, `Draw on this workspace's memory. The lines below are this workspace's ` + `memory index: durable facts it has taught you, each a one-line hook that ` + `points (via a \`[[wikilink]]\`) to the warm store where the full detail ` + `lives. Treat them as recall, not gospel: use a line to load the right ` + `context and verify it against the live workspace before you rely on it, ` + `never as a settled fact to assert. ` + `${renderFreshnessStamp(today, freshness.workspaceMemoryUpdatedAt)} ` + `The index:
 
-` + workspaceMemory);
+` + workspaceMemory + (workspaceMemoryNote === null ? `` : `
+
+${workspaceMemoryNote}`));
   }
   if (userMemory !== null) {
     block.push(``, `Draw on your personal memory. The lines below are YOUR personal memory ` + `index: member-private facts you have taught the harness about yourself ` + `(your preferences, working style, tools), each a one-line hook ` + `that points (via a \`[[wikilink]]\`) to the warm store where the full ` + `detail lives. Only you can read this. Treat it as recall, not gospel: use ` + `a line to load the right context and verify it before you rely on it, ` + `never as a settled fact to assert. ` + `${renderFreshnessStamp(today, freshness.userMemoryUpdatedAt)} ` + `The index:
 
-` + userMemory);
+` + userMemory + (userMemoryNote === null ? `` : `
+
+${userMemoryNote}`));
   }
   if (workspaceMemory !== null || userMemory !== null) {
     block.push(``, `Dated recall. Every line in these indexes carries the date it was banked, ` + `and today's date is injected above, so the age of any line is ` + `computable. When you rely on a line in an answer, say how old it is - ` + `"banked 21 July, seventeen days ago" - rather than presenting it as ` + `current. Age is not a reason to distrust a line, it is what tells the ` + `reader whether to check: a working convention banked a year ago is ` + `probably still the convention, a fact about a live negotiation banked ` + `three weeks ago probably is not. And say what the indexes do NOT cover. ` + `If you are asked about something no line here addresses, say so plainly ` + `rather than answering only from what happens to be present - an index ` + `that is silent on a subject reads exactly like one that has settled it.`);
@@ -25930,6 +26006,59 @@ function buildGroundingBlock(today, workspaceRules = null, workspaceMemory = nul
   return block.join(`
 `);
 }
+function buildGroundingReport(today, workspaceRules = null, workspaceMemory = null, userMemory = null, freshness = {}, rosterIsEmpty = false, voiceProfile = null, voiceMalformed = false, workspaceSlug = null) {
+  const compose = (wmBody, umBody, wmNote, umNote) => composeGroundingBlock(today, workspaceRules, wmBody, umBody, freshness, rosterIsEmpty, voiceProfile, voiceMalformed, workspaceSlug, wmNote, umNote);
+  const whole = compose(workspaceMemory, userMemory, null, null);
+  const untrimmed = () => ({
+    block: whole,
+    picks: {
+      wmPick: workspaceMemory === null ? null : { text: workspaceMemory, kept: groupFacts(workspaceMemory).length, total: groupFacts(workspaceMemory).length },
+      umPick: userMemory === null ? null : { text: userMemory, kept: groupFacts(userMemory).length, total: groupFacts(userMemory).length }
+    }
+  });
+  if (Buffer.byteLength(whole) <= GROUNDING_BUDGET_BYTES)
+    return untrimmed();
+  if (workspaceMemory === null && userMemory === null)
+    return untrimmed();
+  const factCount = (body) => body === null ? 0 : groupFacts(body).length;
+  const wmFacts = factCount(workspaceMemory);
+  const umFacts = factCount(userMemory);
+  const measureFixed = (wmNoted, umNoted) => Buffer.byteLength(compose(workspaceMemory === null ? null : "", userMemory === null ? null : "", wmNoted ? trimmedIndexNote(wmFacts, wmFacts, WORKSPACE_MEMORY_FILENAME) : null, umNoted ? trimmedIndexNote(umFacts, umFacts, USER_MEMORY_FILENAME) : null));
+  const wmSize = workspaceMemory === null ? 0 : Buffer.byteLength(workspaceMemory);
+  const umSize = userMemory === null ? 0 : Buffer.byteLength(userMemory);
+  const allocate = (remaining) => {
+    const half = Math.floor(remaining / 2);
+    let umCap;
+    let wmCap;
+    if (umSize <= half) {
+      umCap = umSize;
+      wmCap = remaining - umSize;
+    } else if (wmSize <= half) {
+      wmCap = wmSize;
+      umCap = remaining - wmSize;
+    } else {
+      umCap = half;
+      wmCap = remaining - half;
+    }
+    const umPick = userMemory === null ? null : selectRecentLines(userMemory, umCap);
+    const umUsed = umPick === null ? 0 : Buffer.byteLength(umPick.text);
+    return {
+      wmPick: workspaceMemory === null ? null : selectRecentLines(workspaceMemory, remaining - umUsed),
+      umPick
+    };
+  };
+  const trimmed = (pick2) => pick2 !== null && pick2.kept !== pick2.total;
+  const noteFor = (pick2, filename) => pick2 === null || pick2.kept === pick2.total ? null : trimmedIndexNote(pick2.kept, pick2.total, filename);
+  const build = (picks) => compose(picks.wmPick === null ? null : picks.wmPick.text, picks.umPick === null ? null : picks.umPick.text, noteFor(picks.wmPick, WORKSPACE_MEMORY_FILENAME), noteFor(picks.umPick, USER_MEMORY_FILENAME));
+  const conservative = allocate(Math.max(0, GROUNDING_BUDGET_BYTES - measureFixed(true, true)));
+  const refined = allocate(Math.max(0, GROUNDING_BUDGET_BYTES - Buffer.byteLength(compose(workspaceMemory === null ? null : "", userMemory === null ? null : "", noteFor(conservative.wmPick, WORKSPACE_MEMORY_FILENAME), noteFor(conservative.umPick, USER_MEMORY_FILENAME)))));
+  const kept = (p) => (p.wmPick?.kept ?? 0) + (p.umPick?.kept ?? 0);
+  const candidates = [refined, conservative].map((picks) => ({ picks, text: build(picks) })).map((c) => ({ ...c, bytes: Buffer.byteLength(c.text), facts: kept(c.picks) }));
+  const fitting = candidates.filter((c) => c.bytes <= GROUNDING_BUDGET_BYTES);
+  const best = fitting.length > 0 ? fitting.reduce((a, b) => b.facts > a.facts ? b : a) : candidates.reduce((a, b) => b.bytes < a.bytes ? b : a);
+  return { block: best.text, picks: best.picks };
+}
+var buildGroundingReportFor = buildGroundingReport;
 function formatLocalDate(d) {
   const year = d.getFullYear();
   const month = String(d.getMonth() + 1).padStart(2, "0");
@@ -26558,6 +26687,9 @@ function resolveVoiceMalformed(raw, record2) {
   return stableHash(raw) === record2.body_hash;
 }
 function runGrounding(deps = {}) {
+  return runGroundingReport(deps).block;
+}
+function runGroundingReport(deps = {}) {
   const now = deps.now ?? (() => new Date);
   const readWorkspaceRules = deps.readWorkspaceRules ?? readWorkspaceRulesFile;
   const readWorkspaceMemory = deps.readWorkspaceMemory ?? readWorkspaceMemoryFile;
@@ -26575,34 +26707,35 @@ function runGrounding(deps = {}) {
     userVoice: null
   };
   let noArtists = false;
-  if (deps.workspaceSlug) {
+  const workspaceSlug = isValidWorkspaceSlug(deps.workspaceSlug ?? "") ? deps.workspaceSlug : null;
+  if (workspaceSlug) {
     try {
-      rawRules = readWorkspaceRules(deps.workspaceSlug);
+      rawRules = readWorkspaceRules(workspaceSlug);
     } catch {
       rawRules = null;
     }
     try {
-      rawMemory = readWorkspaceMemory(deps.workspaceSlug);
+      rawMemory = readWorkspaceMemory(workspaceSlug);
     } catch {
       rawMemory = null;
     }
     try {
-      rawUserMemory = readUserMemory(deps.workspaceSlug);
+      rawUserMemory = readUserMemory(workspaceSlug);
     } catch {
       rawUserMemory = null;
     }
     try {
-      rawVoiceProfile = readVoiceProfile(deps.workspaceSlug);
+      rawVoiceProfile = readVoiceProfile(workspaceSlug);
     } catch {
       rawVoiceProfile = null;
     }
     try {
-      freshness = readFreshness(deps.workspaceSlug);
+      freshness = readFreshness(workspaceSlug);
     } catch {
       freshness = { workspaceMemory: null, userMemory: null, userVoice: null };
     }
     try {
-      noArtists = readRosterIsEmpty(deps.workspaceSlug);
+      noArtists = readRosterIsEmpty(workspaceSlug);
     } catch {
       noArtists = false;
     }
@@ -26611,10 +26744,10 @@ function runGrounding(deps = {}) {
   const memory = extractWorkspaceMemory(rawMemory);
   const userMemory = extractUserMemory(rawUserMemory);
   const voiceProfile = extractVoiceProfile(rawVoiceProfile);
-  return buildGroundingBlock(formatLocalDate(now()), rules, memory, userMemory, {
+  return buildGroundingReportFor(formatLocalDate(now()), rules, memory, userMemory, {
     workspaceMemoryUpdatedAt: resolveUpdatedAt(rawMemory, freshness.workspaceMemory),
     userMemoryUpdatedAt: resolveUpdatedAt(rawUserMemory, freshness.userMemory)
-  }, noArtists, voiceProfile, resolveVoiceMalformed(rawVoiceProfile, freshness.userVoice));
+  }, noArtists, voiceProfile, resolveVoiceMalformed(rawVoiceProfile, freshness.userVoice), workspaceSlug);
 }
 var groundingCommand = defineCommand({
   meta: {
@@ -28587,7 +28720,7 @@ function buildCloseCommandMd(workspaceSlug) {
   const ws = `--workspace ${workspaceSlug}`;
   return withUserBlock([
     "---",
-    "description: Close a Plinth session. Verifies what you wrote landed, routes follow-ups to a durable surface, asks before anything reaches shared memory, and logs what was decided.",
+    "description: Close a Plinth session. Verifies what you wrote landed, routes follow-ups to a durable surface, and banks what was learned where it belongs.",
     "---",
     "",
     OWNERSHIP_NOTE,
@@ -28600,7 +28733,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "## Step 1: reconstruct the session",
     "",
-    "From the **transcript**, not from your memory of it. Which entities were touched, which writes were made, what was decided, what was learned. If the session was pure reading with no changes, say so and go to Step 4 anyway: a read-only close still logs, and the `--nothing-proposed` rule below is why.",
+    "From the **transcript**, not from your memory of it. Which entities were touched, which writes were made, what was decided, what was learned. If the session was pure reading with no changes, say so and **work through every step below anyway.** A session that answered a real question has a record worth banking in Step 3, and reading can teach you a durable fact as readily as writing can.",
     "",
     "## Step 2: verify each write landed",
     "",
@@ -28640,7 +28773,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "<what was discussed, what was decided, what was done, what is still open>",
     "```",
     "",
-    "**Re-read `_artist.md` at the moment you write it, and add only your own dated section.** Other people close sessions in this workspace too, and this file syncs: when two closes touch one artist at once the cloud copy wins and the other edit is set aside, seconds after you wrote it. **Step 2's conflicts read cannot catch that: it ran before this write.** Step 6 re-reads it, and that is the check covering what you write here. So read the file now rather than trusting what it said earlier in the session, and never reword a section another session wrote.",
+    "**Re-read `_artist.md` at the moment you write it, and add only your own dated section.** Other people close sessions in this workspace too, and this file syncs: when two closes touch one artist at once the cloud copy wins and the other edit is set aside, seconds after you wrote it. **Step 2's conflicts read cannot catch that: it ran before this write.** Step 5 re-reads it, and that is the check covering what you write here. So read the file now rather than trusting what it said earlier in the session, and never reword a section another session wrote.",
     "",
     "**Keep the five most recent dated sections.** Adding a sixth means dropping the oldest - but first take anything in it that is still true and write it into `artists/<slug>/memory.md`, where durable facts live. If nothing in it survives that test it was not durable, and dropping it costs nothing. **Removing an old section is the one edit you may make to someone else's: you may drop it, never reword it.** Without this bound the record grows without limit on a synced column, and every teammate loads the whole of it on every session.",
     "",
@@ -28648,7 +28781,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "## Step 4: bank what was learned, by type first and scope second",
     "",
-    "**Two sorts, in this order, and the order is the whole of it.** First: does this fact already have a surface of its own? Then, and only then: whose fact is it? Sorting by scope alone is how a contact record ends up in shared memory wearing a memory line's clothes.",
+    "**Two sorts, in this order, and the order is the whole of it.** First: does this fact already have a surface of its own? Then, and only then: whose fact is it? Sorting by scope alone is how a contact record ends up in a memory file wearing a memory line's clothes.",
     "",
     "### Step 4a: type first. A fact with a typed home never becomes prose.",
     "",
@@ -28656,7 +28789,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "- **A person and their details** - name, company, email, role, how they relate to the work - is a **contact on that artist**. Write it with `create_artist_contact`; it renders in the `## Contacts` block of that artist's `artists/<slug>/_artist.md`.",
     "- **Something to do** is a task, and Step 3 has already routed it.",
-    "- **A note, brief or bio that is a piece of writing in its own right** is a document under `documents/`. That means standalone material, NOT the detail sitting behind a memory line - those two are not competing destinations, and Step 4b says how they fit together.",
+    "- **A note, brief or bio that is a piece of writing in its own right** is a document under `documents/`. That means standalone material somebody would open and read on its own, not a fact you are recording because you learned it - a fact is a memory line, and Step 4b routes it.",
     "- **A stable attribute of an artist** - their website, a handle, their bio - is that artist's own field, or the body of `artists/<slug>/_artist.md`.",
     "- **A contract, statement or attachment** is a file under `files/`.",
     "- **A date is live state and belongs in no memory file.** A deadline rides its task as a due date. Every other date is a calendar matter: say plainly what the date is, say that a person adds it in Plinth's calendar view, and name it in the closing summary so it is not quietly dropped.",
@@ -28665,19 +28798,19 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "Whatever is left has no typed surface anywhere. That is what memory is for.",
     "",
-    "### Step 4b: three piles, and the artist pile comes first",
+    "### Step 4b: two piles, and the artist pile comes first",
     "",
-    "**Most of what a session learns is true of exactly one artist**, and that is the pile that gets forgotten. Sending an artist's fact to shared memory pushes it into every teammate's context on every future session, including everyone who never touches that artist, and buries it where the person who does will not look.",
+    "**Most of what a session learns is true of exactly one artist**, and that is the pile that gets forgotten. The other is true of the member in front of you. Write both directly: they are scoped to the person or the act they describe, and a wrong line in either is theirs to prune.",
     "",
     "**The sorting test: would a teammate who never touches that artist be worse off without this line?** If not, it is the artist pile.",
     "",
-    "The three piles are treated differently on purpose, and the difference is not politeness. A wrong line in the **shared** index reaches every member on every machine and is injected into every future session, so it is the only pile that is gated. A wrong line in an artist's store or a member's own is theirs to prune.",
+    "**A fact that is true of neither - a way this whole team works - is named in the closing summary and written nowhere by this close.** Asking for something to hold for everyone here is the member's to do, not yours to infer from what happened. This close has no third pile, and that is deliberate rather than an omission.",
     "",
     "#### True of one artist: `artists/<slug>/memory.md`. Write it directly.",
     "",
-    "That artist's rate card, a contact of theirs whose behaviour you had to learn, how their kit actually works, what a venue reliably does. No gate. It syncs to that artist's Plinth record, so a teammate opening that artist gets it. **List what you wrote here in the closing summary.**",
+    "That artist's rate card, a contact of theirs whose behaviour you had to learn, how their kit actually works, what a venue reliably does. It syncs to that artist's Plinth record, so a teammate opening that artist gets it. **List what you wrote here in the closing summary.**",
     "",
-    "Follow the conventions in the file's own header: one line per fact, what taught you it, an absolute date, and **supersede in place** - when a fact here goes wrong, edit that line rather than adding one that contradicts it.",
+    "**Follow the conventions in the file's own header comment**, which states them and is the version that stays current. Do not work from a copy of them here.",
     "",
     "**Re-read the file at the moment you write it, not when you were planning.** The daemon can pull a `memory.md` down from Plinth at any point in a session, so a file that was missing minutes ago may exist now - and if it does, add your line to it rather than creating it over the top. This is not hypothetical: a close on 26 Aug 2026 checked, found nothing, and clobbered a copy the daemon had pulled in ninety seconds earlier.",
     "",
@@ -28696,71 +28829,15 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "#### True of this member: `user-memory.md` at the mirror root. Write it directly.",
     "",
-    "Facts true of this member: what they prefer, how they work, their own identifiers. No gate. **List what you wrote in the closing summary**, so it is visible without opening the file.",
+    "Facts true of this member: what they prefer, how they work, their own identifiers. **List what you wrote in the closing summary**, so it is visible without opening the file.",
     "",
     "**How they WRITE does not go here, and it is not a fact.** Their register, greetings, sign-off and the things they never do are a rubric, and they live in `voice.md` at the mirror root - a file the member owns and you are denied from editing, because the profile you are judged against is not yours to rewrite. So do not bank a voice rule in this index or any other. Say what you noticed in the closing summary and leave it for them to put in their own profile.",
     "",
     "If the file is not there yet, create it the same way as the artist store: a one-line title, the same conventions in a comment, and a real fact in the same edit. **Check what the workspace already says before you write a personal line** - a convention that is already in `workspace-rules.md` or the workspace's own house-style file is in force for everyone, and copying it here duplicates a live rule into a second injected surface instead of adding anything.",
     "",
-    "#### True of the whole workspace: `workspace-memory.md` at the mirror root. Propose. Never write unasked.",
-    "",
-    "**This is the only gated pile**, and a fact that names a single artist is almost never in it.",
-    "",
-    `**The test is what the user SAID, not what you concluded.** A line belongs here only if they stated it as how this workspace operates - "always", "never", "from now on", "our policy is", or a confirmation in the transcript that amounts to one. Something you inferred from a single event is not that, however durable it looks: it is this session's detail, Step 3 has already banked it in the record, and it is not proposed here.`,
-    "",
-    "**Most sessions have nothing for this pile, and that is the expected outcome rather than a failure to look.** Proposing nothing is a clean close: log it with `--nothing-proposed` below, which is this step's ordinary line and not an exception to it. A gate that finds a candidate every session is not discriminating, it is manufacturing them out of what happened.",
-    "",
-    "For anything that does pass, draft the candidate lines first.",
-    "",
-    "**Each line has a required shape, and it is the file's own, not this command's.** `workspace-memory.md` is an INDEX, and the grounding block tells every future session that each line is a one-line hook pointing via a `[[wikilink]]` to the warm store where the full detail lives. So a line carries: the hook, a `[[wikilink]]` to where the detail actually is, an **absolute** date (turn \"last week\" into a real one), and what taught you it. **A line with no warm store behind it makes the grounding block lie to every session that loads it.** Read the file's header comment and follow the conventions there; where it and this command disagree, the file wins.",
+    "## Step 5: summarise, then end the session",
     "",
-    "**Writing the warm store is PART of banking a line, not an alternative to it.** The hook goes in the index; the full detail goes where its `[[wikilink]]` points. An artist-scoped fact already has a warm store (`artists/<slug>/memory.md`), and a workspace-wide fact with no other home takes a document under `documents/`. Write that target in this same close, and **never bank a hook whose target you did not write** - that is precisely how the grounding block ends up asserting a pointer to nothing.",
-    "",
-    "Then put the candidates to the user with **`AskUserQuestion`**:",
-    "",
-    "- **One multi-select question, one option per proposed line.** Selected means bank it. Unselected means rejected.",
-    "- **With exactly one candidate, ask a two-option question instead: bank it, or leave it.** The tool refuses a question carrying fewer than two options, so the one-option-per-line form above cannot run on its own - and one candidate is the ordinary case, not an edge. Record the answer exactly as you would from the multi-select.",
-    '- **The free-text "Other" choice is how the user rewrites a line in their own words.** Their wording wins over yours, always.',
-    "- The tool takes **four options per question and four questions**. If you have more than four candidate lines, you are banking session detail rather than durable facts: **say so and cut the list. Do not paginate.**",
-    "",
-    "**An accepted line that contradicts one already in the file supersedes it in place.** Edit the wrong line. Never leave two lines disagreeing.",
-    "",
-    "## Step 5: log every decision, then write the file",
-    "",
-    "**In that order.** The log is the record of what was decided; the file is the consequence.",
-    "",
-    "```sh",
-    `plinth memory-gate log ${ws} --proposed="<the line as you put it>" --decision accept`,
-    `plinth memory-gate log ${ws} --proposed="<the line as you put it>" --decision reject`,
-    `plinth memory-gate log ${ws} --proposed="<the line as you put it>" --decision edit --final="<their rewrite>"`,
-    "```",
-    "",
-    "A close that proposed nothing still logs, because *gated and proposed nothing* has to stay distinguishable from *never gated*:",
-    "",
-    "```sh",
-    `plinth memory-gate log ${ws} --nothing-proposed`,
-    "```",
-    "",
-    `\`plinth memory-gate show ${ws} [--json]\` reads the log back.`,
-    "",
-    "**The `=` in `--proposed=` and `--final=` is load-bearing. Do not rewrite it as a space.** A `workspace-memory.md` line is a markdown bullet, so the value starts with `- ` - and in the space form the parser swallows a value beginning with a dash, leaving the command to report that `--proposed` carried nothing. Measured 26 Aug 2026: the space form fails on exactly the lines this step exists to log, the equals form takes them. The same applies to any line starting with `--`.",
-    "",
-    "**`--workspace` is pinned on these commands on purpose. Do not drop it.** The CLI otherwise resolves whichever workspace is *active* on this machine, not the mirror you are standing in - so a close run here would write its decisions into a different workspace's log, silently and with exit 0. That log has no delete and no edit, so the wrong row is permanent.",
-    "",
-    "**Four rules. Break one and a decision is lost:**",
-    "",
-    "1. `--decision edit` **requires** `--final`. The rewrite is the record: it is the user's own words for their own standard, and it is the most valuable row in the log.",
-    "2. `--final` is **refused** on `accept` and `reject`. An accept records the proposed line; a reject records none.",
-    "3. `--nothing-proposed` **cannot** be combined with `--proposed` or `--decision`.",
-    '4. **`memory-gate` fails LOUD**: exit 1, with a message on stderr. **Surface it. Never swallow it.** A silently dropped decision produces exactly the "never gated" state the log exists to make visible, while looking like a clean close. If it fails, tell the user, and do not report the line as banked.',
-    "",
-    "**Never write this log by hand.** The CLI owns the format so it can still be read back in a year.",
-    "",
-    "Only once the decisions are logged, write the accepted lines into `workspace-memory.md`.",
-    "",
-    "## Step 6: summarise, then end the session",
-    "",
-    "**First, re-read the conflicts list.** Everything this close wrote - the session record in Step 3, the memory files in Step 4, the accepted lines at the end of Step 5 - landed AFTER Step 2 looked, and a losing write is set aside within seconds of being made. Step 2 therefore cannot have seen it. Read the list again now:",
+    "**First, re-read the conflicts list.** Everything this close wrote - the session record in Step 3, the memory files in Step 4 - landed AFTER Step 2 looked, and a losing write is set aside within seconds of being made. Step 2 therefore cannot have seen it. Read the list again now:",
     "",
     "```sh",
     `plinth status ${ws}`,
@@ -28772,7 +28849,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "**Anything named there was NOT banked, whatever the write appeared to return.** Say so plainly, name the file, and point the user at the restore command rather than reporting the work as done. A close that reports a stashed session record as banked is the one failure this step exists to prevent, because the record was the point of the close.",
     "",
-    "**Five to seven lines**, and no file-by-file dump: **where the session record went, named per artist**, what now lives on a durable surface, what is still in flight and on whom, **what was banked to memory and to which of the three piles**, anything you named as having no home yet, any date you handed to a person, and the obvious next move.",
+    "**Five to seven lines**, and no file-by-file dump: **where the session record went, named per artist**, what now lives on a durable surface, what is still in flight and on whom, **what was banked to memory and to which of the two piles**, anything you named as having no home yet, any fact you judged true of the whole team and left unwritten, any date you handed to a person, and the obvious next move. **This is how the user sees what was stored without opening a file**, so name the files rather than saying that memory was updated.",
     "",
     "Then, as the **very last step**:",
     "",
@@ -28782,7 +28859,7 @@ function buildCloseCommandMd(workspaceSlug) {
     "",
     "**The `=` in `--summary=` is load-bearing. Do not rewrite it as a space.** A summary line often starts with `- `, and in the space form the parser swallows a value beginning with a dash. `session end` will tell you it dropped it and end the session anyway, so the cost is a lost summary rather than a lost close - but the equals form simply never loses it.",
     "",
-    "This is the opposite of `memory-gate`: it **always exits 0**, whatever happens, and prints nothing on success. It marks this session ended, and when it is running inside the Plinth desktop dock it tells the dock the session is finished so the tab can close itself. **Outside the dock it does nothing visible, and that is correct.** Nothing in this command depends on the dock; it runs the same in a bare terminal. The one thing it will ever print is a warning on stderr saying your `--summary` was lost before it could be read; the session still ends."
+    "It **always exits 0**, whatever happens, and prints nothing on success. It marks this session ended, and when it is running inside the Plinth desktop dock it tells the dock the session is finished so the tab can close itself. **Outside the dock it does nothing visible, and that is correct.** Nothing in this command depends on the dock; it runs the same in a bare terminal. The one thing it will ever print is a warning on stderr saying your `--summary` was lost before it could be read; the session still ends."
   ]);
 }
 function buildOnboardCommandMd(workspaceSlug) {
@@ -28928,12 +29005,16 @@ function ensureWorkspaceCommands(deps) {
   const created = [];
   const refreshed = [];
   const noArtists = (deps.readRosterIsEmpty ?? rosterIsEmpty)(workspaceSlug);
-  const targets = [
-    [START_COMMAND_REL, buildStartCommandMd(noArtists)],
-    [CLOSE_COMMAND_REL, buildCloseCommandMd(workspaceSlug)],
-    [ONBOARD_COMMAND_REL, buildOnboardCommandMd(workspaceSlug)]
-  ];
-  for (const [rel, generated] of targets) {
+  const bodies = {
+    [START_COMMAND_REL]: buildStartCommandMd(noArtists),
+    [CLOSE_COMMAND_REL]: buildCloseCommandMd(workspaceSlug),
+    [ONBOARD_COMMAND_REL]: buildOnboardCommandMd(workspaceSlug)
+  };
+  for (const rel of GENERATED_COMMAND_RELS) {
+    const generated = bodies[rel];
+    if (generated === undefined) {
+      throw new Error(`ensureWorkspaceCommands: no generated body for ${rel}`);
+    }
     const existing = readContextFile(workspaceSlug, rel);
     const decision = decideRegen({ existing, currentVersion: "", generated, force });
     if (decision.action === "backup-regen" && decision.backup !== undefined) {
@@ -28956,6 +29037,44 @@ function ensureWorkspaceCommands(deps) {
 function backupStamp2(d) {
   return d.toISOString().replace(/[-:.]/g, "").replace("Z", "");
 }
+var RETIRED_COMMAND_TOKENS = [
+  { commandRel: CLOSE_COMMAND_REL, token: "memory-gate", version: "0.11.0" }
+];
+var GENERATED_COMMAND_RELS = [
+  START_COMMAND_REL,
+  CLOSE_COMMAND_REL,
+  ONBOARD_COMMAND_REL
+];
+function scanStaleUserBlocks(deps) {
+  const retired = deps.retired ?? RETIRED_COMMAND_TOKENS;
+  const read = deps.read ?? readContextFile;
+  const stale = [];
+  const unchecked = [];
+  let checked = 0;
+  for (const rel of GENERATED_COMMAND_RELS) {
+    let content;
+    try {
+      content = read(deps.workspaceSlug, rel);
+    } catch {
+      unchecked.push({ commandRel: rel, reason: "unreadable" });
+      continue;
+    }
+    if (content === null)
+      continue;
+    const block = extractUserBlock(content);
+    if (block === null) {
+      unchecked.push({ commandRel: rel, reason: "no-markers" });
+      continue;
+    }
+    checked++;
+    const haystack = block.toLowerCase();
+    const tokens = retired.filter((r) => r.commandRel === rel && haystack.includes(r.token.toLowerCase()));
+    if (tokens.length > 0) {
+      stale.push({ commandRel: rel, invocation: invocationFor(rel), tokens });
+    }
+  }
+  return { checked, unchecked, stale };
+}
 
 // src/lib/context/workspace-claude-md.ts
 var EXTRACTED_TEXT_DIR = extractedTextRelPath("x").replace(/x\.md$/, "");
@@ -28991,7 +29110,7 @@ function buildWorkspaceClaudeMd(input) {
     ``,
     `> **Session grounding**: the current date, an entity-resolution rule, and a write-confirmation rule are injected at every session start by the Plinth hook in \`.claude/settings.json\` (and each \`artists/<slug>/.claude/settings.json\`).`,
     ``,
-    `> **Filing a file the user hands you - BOTH halves, and the first one is unconditional**: put a copy in \`files/\`, which is how Plinth gets the text (folder map below) - do this even if everything else here fails. Then put the **original** in the user's own file storage with whatever tool you have for that, and write down where it went somewhere durable: \`artists/<slug>/memory.md\` if it is that artist's, otherwise \`workspace-memory.md\`. A pointer that exists only in this conversation is lost when it ends. If you have no tool that reaches their file storage, SAY SO - do not leave them believing the original was filed.`,
+    `> **Filing a file the user hands you - BOTH halves, and the first one is unconditional**: put a copy in \`files/\`, which is how Plinth gets the text (folder map below) - do this even if everything else here fails. Then put the **original** in the user's own file storage with whatever tool you have for that, and write down where it went somewhere durable: \`artists/<slug>/memory.md\` if it is that artist's, otherwise your own \`user-memory.md\`. A pointer that exists only in this conversation is lost when it ends. If you have no tool that reaches their file storage, SAY SO - do not leave them believing the original was filed.`,
     ``,
     `## Folder map`,
     `- \`artists/<slug>/\` one folder per artist, the working dir for artist-scoped sessions · \`threads/<slug>/_thread.md\` one folder per thread`,
@@ -29010,7 +29129,7 @@ function buildWorkspaceClaudeMd(input) {
     `## Navigating the corpus`,
     `- **What points at X?** → \`plinth backlinks "<name>"\`, a mirror path, or a wikilink target as written. Render-only blocks, code spans and comments are narrowed out; \`--unfiltered\` shows them. A bare name several files answer to is refused with the candidates listed, so re-run with the path it names`,
     `- **What does this file link to?** → grep \`[[\` in it`,
-    `- **Find a file by name** → glob under \`files/\` \`documents/\` \`artists/\` · **text inside a PDF** → \`${EXTRACTED_TEXT_DIR}\` (folder map above) · **a task, project, artist or contact by field** → the \`mcp__plinth__*\` \`search_entities\` / \`list_*\` tools`,
+    `- **Find a file by name** → glob under \`files/\` \`documents/\` \`artists/\` · **text inside a PDF** → \`${EXTRACTED_TEXT_DIR}\` (folder map above) · **write to a row you have the mirror file for** → pass its frontmatter \`id:\` to the \`mcp__plinth__*\` write tool; if you do not have the file, find it with \`search_entities\` / \`list_*\``,
     ``,
     `## Entity model: ${MCP_INTROSPECTION_POINTER}`,
     ...entityLines,
@@ -29811,8 +29930,8 @@ var sessionCommand = defineCommand({
 });
 
 // src/commands/start.ts
-var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync21, statSync as statSync13 } from "node:fs";
+var import_gray_matter12 = __toESM(require_gray_matter(), 1);
+import { readFileSync as readFileSync23, statSync as statSync15 } from "node:fs";
 
 // src/lib/daemon-log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
@@ -30212,6 +30331,9 @@ function fileFailedLine(f) {
   const serverPart = f.serverMessage ? ` server_msg="${f.serverMessage}"` : "";
   return `[FILE_PUSH_FAILED path=${f.path} status=${f.status} reason=${f.reason}${detailPart}${serverPart}]`;
 }
+function frontmatterIdBackfillLine(r) {
+  return `[FRONTMATTER_ID_BACKFILL scanned=${r.scanned} written=${r.written} ` + `inodes_restamped=${r.inodesRestamped} failed=${r.failed} ` + `skipped_frozen=${r.skipped.frozen} ` + `skipped_foreign_id=${r.skipped.foreignId} ` + `skipped_no_frontmatter=${r.skipped.noFrontmatter} ` + `skipped_slug_collision=${r.skipped.slugCollision} ` + `skipped_diverged=${r.skipped.diverged}]`;
+}
 function pullNoticeLine(kind) {
   const token = kind === "auth" ? "PULL_PAUSED" : "PULL_DEGRADED";
   return `[${token} reason=${kind}]`;
@@ -31148,6 +31270,7 @@ async function pushFile(args) {
     unlinkContext,
     deps
   } = args;
+  const identity = args.identity ?? "auto";
   const fetchImpl = deps?.fetchImpl;
   const now = deps?.now ?? (() => new Date);
   const mutex = deps?.mutex ?? new PerIdMutex;
@@ -31214,7 +31337,7 @@ async function pushFile(args) {
     parsedSlug = strategy.parseMirrorPath(rel)?.slug ?? null;
   } catch {}
   const slugFromPath = parsedSlug ?? basename4(absolutePath, ".md");
-  const slug = slugFromFm ?? slugFromPath;
+  const slug = identity === "path" ? slugFromPath : slugFromFm ?? slugFromPath;
   if (!slug) {
     return {
       outcome: { kind: "ignored", absolutePath, reason: "empty slug" },
@@ -31238,7 +31361,8 @@ async function pushFile(args) {
     }
   }
   const liveInode = safeInode2(absolutePath);
-  const stateEntry = (liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined) ?? getEntryBySlug(state, entityType, slug);
+  const byInode = liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined;
+  const stateEntry = identity === "path" ? byInode : byInode ?? getEntryBySlug(state, entityType, slug);
   if (!stateEntry) {
     return runPushCreate({
       strategy,
@@ -31254,7 +31378,8 @@ async function pushFile(args) {
       fetchImpl,
       now,
       output,
-      quarantinedKeys
+      quarantinedKeys,
+      identity
     });
   }
   return runPushUpsert({
@@ -31807,7 +31932,7 @@ async function runPushCreate(args) {
   const strategy = args.strategy;
   const key = `create:${strategy.type}:${args.slug}`;
   return args.mutex.run(key, async () => {
-    const inLock = getEntryBySlug(args.state, strategy.type, args.slug);
+    const inLock = args.identity === "path" ? undefined : getEntryBySlug(args.state, strategy.type, args.slug);
     if (inLock) {
       return runPushUpsert({
         strategy,
@@ -35949,8 +36074,500 @@ class PullSuppressor {
   }
 }
 
+// src/lib/discover-entities.ts
+var import_gray_matter10 = __toESM(require_gray_matter(), 1);
+import { readFileSync as readFileSync18, statSync as statSync11 } from "node:fs";
+var DISCOVERY_WRITE_CAP_DEFAULT = 10;
+function discoveryWriteCap() {
+  const raw = process.env.PLINTH_DISCOVERY_WRITE_CAP;
+  if (raw === undefined || raw === "")
+    return DISCOVERY_WRITE_CAP_DEFAULT;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DISCOVERY_WRITE_CAP_DEFAULT;
+}
+function looksLikeCloudRow(args) {
+  const { frontmatter, entitySlug } = args;
+  if (frontmatter.revision === undefined || frontmatter.revision === null) {
+    return false;
+  }
+  return frontmatter.slug === entitySlug;
+}
+function classifyUntrackedEntity(args) {
+  if (args.entityType === "artists")
+    return { kind: "hold", held: "artist" };
+  if (looksLikeCloudRow({
+    frontmatter: args.frontmatter,
+    entitySlug: args.entitySlug
+  })) {
+    return { kind: "hold", held: "cloud-row" };
+  }
+  return { kind: "create" };
+}
+function classifyRenameDestination(args) {
+  const occupant = getEntryBySlug(args.state, args.entityType, args.entitySlug);
+  if (occupant && occupant.id !== args.movedEntryId) {
+    return { kind: "hold", held: "rename-taken" };
+  }
+  return { kind: "rename" };
+}
+var EMPTY = {
+  discovered: 0,
+  created: 0,
+  collisions: 0,
+  renamed: 0,
+  renameConflicts: 0,
+  renameVanished: 0,
+  heldCap: 0,
+  heldArtist: 0,
+  heldCloudRow: 0,
+  refusedRename: 0,
+  failed: 0,
+  rejected: 0
+};
+function planDiscoveryWrites(args) {
+  const { workspaceSlug, mirrorRootPath, state, counts, output, isFrozen } = args;
+  const spokenFor = new Set;
+  for (const op of [...listUnsynced(state), ...listRejected(state)]) {
+    if (op.target !== "file")
+      spokenFor.add(op.path);
+  }
+  const ignored = watcherIgnoreMatcher(mirrorRootPath);
+  const planned = [];
+  for (const absolutePath of walkSubtreeFiles(mirrorRootPath, ignored)) {
+    const match = classifyMirrorPath({ workspaceSlug, absolutePath });
+    if (!match)
+      continue;
+    const { entityType, entitySlug } = match;
+    const strategy = getStrategy(entityType);
+    if (!strategy)
+      continue;
+    const relPath = strategy.mirrorRelativePath(entitySlug);
+    if (spokenFor.has(relPath))
+      continue;
+    let liveInode;
+    try {
+      liveInode = statSync11(absolutePath).ino;
+    } catch {
+      continue;
+    }
+    const byInode = liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined;
+    if (byInode) {
+      if (byInode.slug === entitySlug)
+        continue;
+      if (isFrozen?.(entityType, byInode.id))
+        continue;
+      const destination = classifyRenameDestination({
+        state,
+        entityType,
+        entitySlug,
+        movedEntryId: byInode.id
+      });
+      if (destination.kind === "hold") {
+        counts.refusedRename++;
+        output?.warn(`Offline rename of ${entityType}/${byInode.slug} to ${entitySlug} was not ` + `synced: ${entitySlug} already belongs to another ${entityType} row. ` + `Rename it to a free name and Plinth will pick it up.`);
+        continue;
+      }
+      planned.push({ kind: "rename", entityType, entitySlug, absolutePath, entry: byInode });
+      continue;
+    }
+    if (getEntryBySlug(state, entityType, entitySlug))
+      continue;
+    counts.discovered++;
+    let frontmatter;
+    try {
+      frontmatter = import_gray_matter10.default(readFileSync18(absolutePath, "utf8")).data ?? {};
+    } catch {
+      counts.discovered--;
+      continue;
+    }
+    const verdict = classifyUntrackedEntity({ entityType, entitySlug, frontmatter });
+    if (verdict.kind === "hold") {
+      if (verdict.held === "artist")
+        counts.heldArtist++;
+      else
+        counts.heldCloudRow++;
+      continue;
+    }
+    planned.push({ kind: "create", entityType, entitySlug, absolutePath });
+  }
+  return planned;
+}
+async function discoverUntrackedEntities(args) {
+  const { workspaceSlug, baseUrl, pat, fetchImpl, output, isFrozen } = args;
+  const now = args.now ?? (() => new Date);
+  let state = args.state;
+  const counts = { ...EMPTY };
+  let mirrorRootPath;
+  try {
+    mirrorRootPath = workspaceMirrorPath(workspaceSlug);
+  } catch {
+    return { state, ...counts };
+  }
+  let planned;
+  try {
+    planned = planDiscoveryWrites({
+      workspaceSlug,
+      mirrorRootPath,
+      state,
+      counts,
+      output,
+      isFrozen
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "unknown error";
+    output?.warn(`Could not check this workspace for files added while Plinth was closed: ${msg} ` + `(everything already synced is unaffected).`);
+    return { state, ...EMPTY };
+  }
+  const cap = discoveryWriteCap();
+  const creates = planned.filter((w) => w.kind === "create");
+  const toRun = creates.length > cap ? planned.filter((w) => w.kind === "rename") : planned;
+  if (creates.length > cap) {
+    counts.heldCap = creates.length;
+    output?.log(`[DISCOVERY_HELD reason=cap creates=${creates.length} cap=${cap} source=entity-discovery]`);
+  }
+  state = await runPlannedWrites({
+    planned: toRun,
+    workspaceSlug,
+    baseUrl,
+    pat,
+    state,
+    fetchImpl,
+    now,
+    output,
+    counts
+  });
+  return { state, ...counts };
+}
+async function runPlannedWrites(args) {
+  const { planned, workspaceSlug, baseUrl, pat, fetchImpl, now, output, counts } = args;
+  let state = args.state;
+  for (const write of planned) {
+    try {
+      if (write.kind === "rename") {
+        state = await runDiscoveredRename({
+          write,
+          workspaceSlug,
+          baseUrl,
+          pat,
+          state,
+          fetchImpl,
+          now,
+          output,
+          counts
+        });
+        continue;
+      }
+      const result = await pushFile({
+        workspaceSlug,
+        baseUrl,
+        pat,
+        absolutePath: write.absolutePath,
+        entityType: write.entityType,
+        state,
+        exists: true,
+        unlinkContext: null,
+        identity: "path",
+        deps: { fetchImpl, now, output }
+      });
+      state = result.state;
+      switch (result.outcome.kind) {
+        case "created":
+        case "pushed":
+          counts.created++;
+          break;
+        case "conflict":
+        case "create_slug_conflict":
+          counts.collisions++;
+          break;
+        case "sync_error":
+          counts.created++;
+          break;
+        default:
+          break;
+      }
+    } catch (err) {
+      state = recordDiscoveryFailure({
+        err,
+        write,
+        workspaceSlug,
+        state,
+        now,
+        output,
+        counts
+      });
+    }
+  }
+  return state;
+}
+async function runDiscoveredRename(args) {
+  const { write, workspaceSlug, baseUrl, pat, fetchImpl, now, output, counts } = args;
+  let state = args.state;
+  let fromPath;
+  try {
+    fromPath = entityFilePath(workspaceSlug, write.entityType, write.entry.slug);
+  } catch (err) {
+    if (!(err instanceof MirrorPathError))
+      throw err;
+    return state;
+  }
+  const renameResult = await pushRename({
+    workspaceSlug,
+    baseUrl,
+    pat,
+    entityType: write.entityType,
+    fromPath,
+    toPath: write.absolutePath,
+    id: write.entry.id,
+    expectedUpdatedAt: write.entry.updated_at,
+    fromSlug: write.entry.slug,
+    state,
+    deps: { fetchImpl, now, output }
+  });
+  state = renameResult.state;
+  if (renameResult.outcome.kind === "not_found") {
+    counts.renameVanished++;
+    output?.warn(`${write.entityType}/${write.entry.slug} was renamed here, but it no longer ` + `exists in Plinth — the next sync will remove the file.`);
+    return state;
+  }
+  if (renameResult.outcome.kind !== "renamed") {
+    if (renameResult.outcome.kind === "conflict" || renameResult.outcome.kind === "rename_slug_conflict") {
+      counts.renameConflicts++;
+    }
+    return state;
+  }
+  counts.renamed++;
+  let upsert;
+  try {
+    upsert = await pushFile({
+      workspaceSlug,
+      baseUrl,
+      pat,
+      absolutePath: write.absolutePath,
+      entityType: write.entityType,
+      state,
+      exists: true,
+      unlinkContext: null,
+      identity: "path",
+      deps: { fetchImpl, now, output }
+    });
+  } catch (err) {
+    return recordDiscoveryFailure({
+      err,
+      write,
+      workspaceSlug,
+      state,
+      now,
+      output,
+      counts
+    });
+  }
+  if (upsert.outcome.kind === "conflict")
+    counts.renameConflicts++;
+  return upsert.state;
+}
+function recordDiscoveryFailure(args) {
+  const { err, write, workspaceSlug, now, output, counts } = args;
+  let state = args.state;
+  const msg = err instanceof Error ? err.message : "unknown error";
+  output?.log(pushFailedLine({
+    entityType: write.entityType,
+    slug: write.entitySlug,
+    id: write.kind === "rename" ? write.entry.id : "",
+    ...categorizeError(err)
+  }));
+  if (isPermanentReject(err)) {
+    counts.rejected++;
+    output?.warn(`Plinth refused ${write.entityType}/${write.entitySlug}: ${msg} ` + `(see \`plinth status\`; fix the file and save it again).`);
+    return recordEntityRejected({
+      state,
+      workspaceSlug,
+      absolutePath: write.absolutePath,
+      op: "upsert",
+      err,
+      now
+    });
+  }
+  counts.failed++;
+  output?.warn(`Could not sync ${write.entityType}/${write.entitySlug}: ${msg} ` + `(file kept on disk; will retry).`);
+  if (isRecordableFailure(err)) {
+    state = recordEntityUnsynced({
+      state,
+      workspaceSlug,
+      absolutePath: write.absolutePath,
+      op: "upsert",
+      err,
+      now
+    });
+  }
+  return state;
+}
+
+// src/lib/frontmatter-id-backfill.ts
+var import_gray_matter11 = __toESM(require_gray_matter(), 1);
+import { readFileSync as readFileSync19, statSync as statSync12 } from "node:fs";
+function backfillWorthReporting(r) {
+  return r.written > 0 || r.failed > 0 || r.skipped.foreignId > 0;
+}
+function emptyResult() {
+  return {
+    scanned: 0,
+    written: 0,
+    alreadyPresent: 0,
+    missing: 0,
+    skipped: {
+      frozen: 0,
+      foreignId: 0,
+      noFrontmatter: 0,
+      slugCollision: 0,
+      diverged: 0
+    },
+    failed: 0,
+    inodesRestamped: 0
+  };
+}
+function heldByAnyBatch(workspaceSlug) {
+  const out = new Set;
+  for (const batch of listPendingBatches(workspaceSlug)) {
+    for (const op of batch.ops) {
+      if (op.target === "entity")
+        out.add(`${op.entityType}:${op.id}`);
+    }
+  }
+  return out;
+}
+function safeInode3(path5) {
+  try {
+    return statSync12(path5).ino;
+  } catch {
+    return;
+  }
+}
+function spliceFrontmatterId(content, id) {
+  const eol = /^---\r\n/.test(content) ? `\r
+` : `
+`;
+  if (!content.startsWith(`---${eol}`))
+    return null;
+  const closeAt = content.indexOf(`${eol}---`, 3);
+  if (closeAt === -1)
+    return null;
+  return `${content.slice(0, closeAt)}${eol}id: ${id}${content.slice(closeAt)}`;
+}
+function backfillFrontmatterIds(args) {
+  const { workspaceSlug, state } = args;
+  const splice = args.splice ?? spliceFrontmatterId;
+  const result = emptyResult();
+  let held;
+  try {
+    held = heldByAnyBatch(workspaceSlug);
+  } catch {
+    return result;
+  }
+  let nextState = state;
+  let stateChanged = false;
+  for (const [entityType, bucket] of Object.entries(state.entries)) {
+    const strategy = getStrategy(entityType);
+    if (!strategy)
+      continue;
+    const slugCounts = new Map;
+    for (const e of Object.values(bucket)) {
+      slugCounts.set(e.slug, (slugCounts.get(e.slug) ?? 0) + 1);
+    }
+    for (const [id, entry2] of Object.entries(bucket)) {
+      result.scanned++;
+      if ((slugCounts.get(entry2.slug) ?? 0) > 1) {
+        result.skipped.slugCollision++;
+        continue;
+      }
+      if (held.has(`${entityType}:${id}`)) {
+        result.skipped.frozen++;
+        continue;
+      }
+      let raw;
+      try {
+        raw = readFileSync19(entityFilePath(workspaceSlug, entityType, entry2.slug), "utf8");
+      } catch (err) {
+        if (err?.code === "ENOENT") {
+          result.missing++;
+        } else {
+          result.failed++;
+        }
+        continue;
+      }
+      let existing;
+      let rawBody;
+      try {
+        const parsed = import_gray_matter11.default(raw);
+        existing = (parsed.data ?? {})["id"];
+        rawBody = parsed.content;
+      } catch {
+        result.failed++;
+        continue;
+      }
+      if (existing !== undefined) {
+        if (existing === id)
+          result.alreadyPresent++;
+        else
+          result.skipped.foreignId++;
+        continue;
+      }
+      const hashes = computeMirrorHashes(strategy, raw);
+      if (hashes.bodyHash !== entry2.body_hash || hashes.frontmatterHash !== entry2.frontmatter_hash) {
+        result.skipped.diverged++;
+        continue;
+      }
+      const next = splice(raw, id);
+      if (next === null) {
+        result.skipped.noFrontmatter++;
+        continue;
+      }
+      try {
+        const check2 = import_gray_matter11.default(next);
+        if (check2.data?.["id"] !== id || check2.content !== rawBody) {
+          result.failed++;
+          continue;
+        }
+      } catch {
+        result.failed++;
+        continue;
+      }
+      let ino;
+      try {
+        const stillRaw = readFileSync19(entityFilePath(workspaceSlug, entityType, entry2.slug), "utf8");
+        if (stillRaw !== raw) {
+          result.skipped.diverged++;
+          continue;
+        }
+        writeMirrorFile(workspaceSlug, entityType, entry2.slug, next);
+        result.written++;
+        ino = safeInode3(entityFilePath(workspaceSlug, entityType, entry2.slug));
+      } catch {
+        result.failed++;
+        continue;
+      }
+      if (ino !== undefined && ino !== entry2.inode) {
+        const up = upsertEntry(nextState, entityType, { ...entry2, inode: ino });
+        nextState = up.state;
+        if (up.changed) {
+          stateChanged = true;
+          result.inodesRestamped++;
+        }
+      }
+    }
+  }
+  if (stateChanged) {
+    try {
+      commitState(state, nextState);
+    } catch {
+      result.failed++;
+      result.inodesRestamped = 0;
+    }
+  }
+  return result;
+}
+
 // src/lib/reconcile.ts
-import { readFileSync as readFileSync18 } from "node:fs";
+import { readFileSync as readFileSync20 } from "node:fs";
 async function reconcileDivergedRows(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl, output, isFrozen } = args;
   const now = args.now ?? (() => new Date);
@@ -36036,7 +36653,7 @@ async function reconcileDivergedRows(args) {
       }
       let content;
       try {
-        content = readFileSync18(absolutePath, "utf8");
+        content = readFileSync20(absolutePath, "utf8");
       } catch (err) {
         if (err?.code === "ENOENT")
           continue;
@@ -36098,7 +36715,29 @@ async function reconcileDivergedRows(args) {
       }
     }
   }
-  return { state, scanned, diverged, pushed, conflicts, noop, failed, quarantined, syncErrors };
+  const discovery = await discoverUntrackedEntities({
+    workspaceSlug,
+    baseUrl,
+    pat,
+    state,
+    fetchImpl,
+    now,
+    output,
+    isFrozen
+  });
+  state = discovery.state;
+  return {
+    state,
+    scanned,
+    diverged,
+    pushed,
+    conflicts,
+    noop,
+    failed,
+    quarantined,
+    syncErrors,
+    discovery
+  };
 }
 
 // src/lib/workspace-rules/sync.ts
@@ -37095,8 +37734,8 @@ function createThrottledFetch(baseFetch, opts = {}) {
 import {
   existsSync as existsSync7,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync20,
-  statSync as statSync12,
+  readFileSync as readFileSync22,
+  statSync as statSync14,
   unlinkSync as unlinkSync7
 } from "node:fs";
 import { join as join16 } from "node:path";
@@ -37222,7 +37861,7 @@ function refreshConflictsView(workspaceSlug) {
 }
 
 // src/lib/files/pull.ts
-import { existsSync as existsSync6, readFileSync as readFileSync19, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync21, statSync as statSync13 } from "node:fs";
 
 // src/lib/files/extracted-text.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -37334,6 +37973,7 @@ async function pullFiles(args) {
         output: args.output,
         suppressor: args.suppressor,
         isFileFrozen: args.isFileFrozen,
+        loggedTombstoneSkips: args.loggedTombstoneSkips,
         forceTextRewalk: args.forceTextRewalk
       });
       state = outcome.state;
@@ -37482,6 +38122,26 @@ async function applyFileRow(args) {
   }
   const existing = getFileEntry(state, relPath);
   if (row.deleted_at !== null) {
+    if (existing && existing.id !== row.id) {
+      const key = `${row.id}:${existing.id}:${relPath}`;
+      if (!args.loggedTombstoneSkips?.has(key)) {
+        args.loggedTombstoneSkips?.add(key);
+        output?.log(`[FILE_TOMBSTONE_SKIP path=${relPath} row_id=${row.id} tracked_id=${existing.id} reason=id_mismatch]`);
+      }
+      return { state, action: "skipped" };
+    }
+    let localBytes;
+    try {
+      localBytes = readFileSync21(abs);
+    } catch {
+      localBytes = undefined;
+    }
+    const isOurs = localBytes === undefined || existing !== undefined && sha256Bytes(localBytes) === existing.content_hash;
+    if (!isOurs) {
+      output?.log(`[FILE_TOMBSTONE_KEEP path=${relPath} row_id=${row.id} reason=${existing === undefined ? "untracked" : "diverged"}]`);
+      const next2 = existing ? removeFileEntry(state, relPath).state : state;
+      return { state: next2, action: "skipped" };
+    }
     suppressor?.registerDelete(abs);
     const didUnlink = deleteFilesFile(workspaceSlug, relPath);
     const removedText = safeDeleteExtractedText(workspaceSlug, relPath, output);
@@ -37569,7 +38229,7 @@ async function applyFileRow(args) {
   }
   if (!suppressor && existing && existing.content_hash !== row.content_hash && existsSync6(abs)) {
     try {
-      const localBytes = readFileSync19(abs);
+      const localBytes = readFileSync21(abs);
       if (sha256Bytes(localBytes) !== existing.content_hash) {
         const stashPath = stashFileConflict({ workspaceSlug, relPath, timestamp: now(), bytes: localBytes });
         output?.warn(`Conflict on files/${relPath} → stashed local edit to ${stashPath} (cloud-wins on boot).`);
@@ -37610,7 +38270,7 @@ async function applyFileRow(args) {
   }
   let inode;
   try {
-    inode = statSync11(abs).ino;
+    inode = statSync13(abs).ino;
   } catch {
     inode = undefined;
   }
@@ -37718,7 +38378,7 @@ function unlinkIfInodeMatches(workspaceSlug, entityType, entrySlug, expectedInod
   }
   let liveInode;
   try {
-    liveInode = statSync12(target).ino;
+    liveInode = statSync14(target).ino;
   } catch {
     return { didUnlink: false, skippedReason: "absent" };
   }
@@ -37865,6 +38525,7 @@ async function runSync(workspaceSlug, deps = {}) {
       output: out,
       suppressor: deps.suppressor,
       isFileFrozen: deps.isFileFrozen,
+      loggedTombstoneSkips: deps.loggedTombstoneSkips,
       commit: commitState,
       forceTextRewalk: needsDerivedTextRewalk
     });
@@ -38080,7 +38741,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at) {
     let localRaw = null;
     try {
-      localRaw = readFileSync20(entityFilePath(workspaceSlug, strategy.type, live.slug), "utf8");
+      localRaw = readFileSync22(entityFilePath(workspaceSlug, strategy.type, live.slug), "utf8");
     } catch {
       localRaw = null;
     }
@@ -38103,7 +38764,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   const hashes = computeMirrorHashes(strategy, content);
   let inode;
   try {
-    inode = statSync12(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
+    inode = statSync14(entityFilePath(workspaceSlug, strategy.type, live.slug)).ino;
   } catch {
     inode = undefined;
   }
@@ -38172,6 +38833,13 @@ var syncCommand = defineCommand({
         process.exit(1);
       }
       handle = acquired.handle;
+      const idBackfill = backfillFrontmatterIds({
+        workspaceSlug: slug,
+        state: loadState(slug)
+      });
+      if (backfillWorthReporting(idBackfill)) {
+        out.log(frontmatterIdBackfillLine(idBackfill));
+      }
     }
     let result;
     try {
@@ -38189,7 +38857,7 @@ var syncCommand = defineCommand({
 // src/commands/start.ts
 var SHUTDOWN_DRAIN_TIMEOUT_MS = 5000;
 var PULL_HEARTBEAT_MS = 900000;
-function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync13(p)) {
+function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync15(p)) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -38222,7 +38890,7 @@ function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync13(p)
     return { state, changed: false };
   return { state: { ...state, entries: nextEntries }, changed: true };
 }
-function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync21(p, "utf8")) {
+function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync23(p, "utf8")) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -38234,7 +38902,7 @@ function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync2
       }
       try {
         const path5 = entityFilePath(workspaceSlug, entityType, entry2.slug);
-        const bodyLen = import_gray_matter10.default(readFn(path5)).content.length;
+        const bodyLen = import_gray_matter12.default(readFn(path5)).content.length;
         nextBucket[id] = { ...entry2, body_len: bodyLen };
         changed = true;
       } catch {
@@ -38310,7 +38978,7 @@ function makeWatchHandler(deps) {
       }
       let st;
       try {
-        st = statSync13(absolutePath);
+        st = statSync15(absolutePath);
       } catch (err) {
         if (err?.code === "ENOENT")
           return;
@@ -38341,7 +39009,7 @@ function makeWatchHandler(deps) {
         spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
         return;
       }
-      const bytes = readFileSync21(absolutePath);
+      const bytes = readFileSync23(absolutePath);
       const hash2 = sha256Bytes(bytes);
       if (suppressor?.shouldSuppressUpsert(absolutePath, {
         bodyHash: hash2,
@@ -38399,7 +39067,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync21(absolutePath, "utf8");
+        raw = readFileSync23(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -38437,7 +39105,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync21(absolutePath, "utf8");
+        raw = readFileSync23(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -38475,7 +39143,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync21(absolutePath, "utf8");
+        raw = readFileSync23(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -38513,7 +39181,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync21(absolutePath, "utf8");
+        raw = readFileSync23(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -38551,7 +39219,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync21(absolutePath, "utf8");
+        raw = readFileSync23(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -38660,7 +39328,7 @@ function makeWatchHandler(deps) {
           if (strategy) {
             let raw = null;
             try {
-              raw = readFileSync21(absolutePath, "utf8");
+              raw = readFileSync23(absolutePath, "utf8");
             } catch {
               raw = null;
             }
@@ -38903,6 +39571,13 @@ async function runStart(workspaceSlug, deps = {}) {
   });
   if (recon.quarantined > 0)
     refreshFrozen();
+  const idBackfill = backfillFrontmatterIds({
+    workspaceSlug: slug,
+    state: loadState(slug)
+  });
+  if (backfillWorthReporting(idBackfill)) {
+    daemonLog.log(frontmatterIdBackfillLine(idBackfill));
+  }
   if (recon.diverged > 0 || recon.quarantined > 0) {
     const parts = [];
     if (recon.pushed > 0)
@@ -38918,6 +39593,33 @@ async function runStart(workspaceSlug, deps = {}) {
     const acted = recon.diverged + recon.quarantined;
     out.info(`Reconciled ${acted} offline edit${acted === 1 ? "" : "s"}${parts.length ? `: ${parts.join(", ")}` : ""}.`);
   }
+  const disc = recon.discovery;
+  if (disc.created > 0 || disc.renamed > 0 || disc.collisions > 0 || disc.renameConflicts > 0) {
+    const parts = [];
+    if (disc.created > 0)
+      parts.push(`${disc.created} synced`);
+    if (disc.renamed > 0)
+      parts.push(`${disc.renamed} renamed in Plinth`);
+    if (disc.collisions > 0) {
+      parts.push(`${disc.collisions} already in Plinth, local copy stashed to ~/.plinth/_conflicts/`);
+    }
+    if (disc.renameConflicts > 0) {
+      parts.push(`${disc.renameConflicts} changed in Plinth first, local copy stashed to ~/.plinth/_conflicts/`);
+    }
+    out.info(`Caught up on files changed while Plinth was closed: ${parts.join(", ")}.`);
+  }
+  if (disc.heldCap > 0) {
+    out.info(`Found ${disc.heldCap} new file${disc.heldCap === 1 ? "" : "s"} in this ` + `workspace — more than Plinth adds on its own (limit ${discoveryWriteCap()}), ` + `so none were added. Run \`plinth status\` to see them.`);
+  }
+  if (disc.heldArtist > 0) {
+    out.info(`${disc.heldArtist} artist folder${disc.heldArtist === 1 ? "" : "s"} ` + `${disc.heldArtist === 1 ? "has" : "have"} no artist in Plinth. Plinth ` + `never adds an artist on its own — see \`plinth status\`.`);
+  }
+  if (disc.refusedRename > 0) {
+    out.info(`${disc.refusedRename} renamed file${disc.refusedRename === 1 ? "" : "s"} ` + `${disc.refusedRename === 1 ? "has a name" : "have names"} already taken in ` + `Plinth, so ${disc.refusedRename === 1 ? "it was" : "they were"} left alone — ` + `see \`plinth status\`.`);
+  }
+  if (disc.heldCloudRow > 0) {
+    out.info(`${disc.heldCloudRow} file${disc.heldCloudRow === 1 ? "" : "s"} came from ` + `Plinth but this copy has lost track of ${disc.heldCloudRow === 1 ? "it" : "them"}. ` + `Nothing is lost — see \`plinth status\`.`);
+  }
   const reconFiles = await reconcileFilesSubtree({
     workspaceSlug: slug,
     baseUrl: entry2.api_base_url,
@@ -39056,6 +39758,7 @@ async function runStart(workspaceSlug, deps = {}) {
     const msg = err instanceof Error ? err.message : "unknown error";
     out.warn(`Artist memory reconcile skipped: ${msg}`);
   }
+  const loggedTombstoneSkips = new Set;
   const initial = await runSync(workspaceSlug, {
     fetchImpl,
     keychain,
@@ -39064,7 +39767,8 @@ async function runStart(workspaceSlug, deps = {}) {
     now: deps.now,
     logSink: daemonLog,
     isFrozen,
-    isFileFrozen
+    isFileFrozen,
+    loggedTombstoneSkips
   });
   if (initial.exitCode !== 0)
     return initial;
@@ -39293,7 +39997,8 @@ async function runStart(workspaceSlug, deps = {}) {
         logSink: daemonLog,
         suppressor,
         isFrozen,
-        isFileFrozen
+        isFileFrozen,
+        loggedTombstoneSkips
       });
       if (result.exitCode === 0) {
         const applied = result.applied ?? 0;
@@ -39754,11 +40459,11 @@ var startCommand = defineCommand({
 });
 
 // src/commands/status.ts
-import { statSync as statSync15 } from "node:fs";
+import { statSync as statSync17 } from "node:fs";
 
 // src/lib/build-stamp.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync11, readFileSync as readFileSync24, writeFileSync as writeFileSync8 } from "node:fs";
 import { dirname as dirname10, join as join17 } from "node:path";
 import { fileURLToPath } from "node:url";
 var BUILD_STAMP_FILENAME = "build-stamp.json";
@@ -39782,7 +40487,7 @@ function readHead(repoDir) {
 }
 function readBuildStamp(distDir) {
   try {
-    const parsed = JSON.parse(readFileSync22(stampPath(distDir), "utf8"));
+    const parsed = JSON.parse(readFileSync24(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 };
     }
@@ -39846,9 +40551,10 @@ function checkBuildStaleness(deps = {}) {
 init_output();
 
 // src/lib/pending-writes.ts
-import { readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
+import { readFileSync as readFileSync25, statSync as statSync16 } from "node:fs";
 import { relative as relative13 } from "node:path";
-var EMPTY = { writes: [], count: 0 };
+var import_gray_matter13 = __toESM(require_gray_matter(), 1);
+var EMPTY2 = { writes: [], count: 0 };
 function reportedElsewhere(state) {
   const entities = new Set;
   const files = new Set;
@@ -39866,13 +40572,14 @@ function scanPendingWrites(args) {
   try {
     mirrorRootPath = workspaceMirrorPath(workspaceSlug);
   } catch {
-    return EMPTY;
+    return EMPTY2;
   }
   const ignored = watcherIgnoreMatcher(mirrorRootPath);
   const reported = reportedElsewhere(state);
   const frozenEntities = computeFrozen(workspaceSlug);
   const frozenFiles = computeFrozenFiles(workspaceSlug);
   const writes = [];
+  const discovered = [];
   for (const absolutePath of walkSubtreeFiles(mirrorRootPath, ignored)) {
     const relPath = relative13(mirrorRootPath, absolutePath);
     const fileMatch = classifyFilesPath({ workspaceSlug, absolutePath });
@@ -39884,7 +40591,7 @@ function scanPendingWrites(args) {
       const entry3 = getFileEntry(state, fileMatch.relPath);
       let size;
       try {
-        size = statSync14(absolutePath).size;
+        size = statSync16(absolutePath).size;
       } catch {
         continue;
       }
@@ -39892,7 +40599,7 @@ function scanPendingWrites(args) {
         continue;
       let hash2;
       try {
-        hash2 = sha256Bytes(readFileSync23(absolutePath));
+        hash2 = sha256Bytes(readFileSync25(absolutePath));
       } catch {
         continue;
       }
@@ -39913,21 +40620,42 @@ function scanPendingWrites(args) {
       continue;
     let liveInode;
     try {
-      liveInode = statSync14(absolutePath).ino;
+      liveInode = statSync16(absolutePath).ino;
     } catch {
       liveInode = undefined;
     }
-    const entry2 = (liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined) ?? getEntryBySlug(state, entityType, entitySlug);
+    const byInode = liveInode !== undefined ? getEntryByInode(state, entityType, liveInode) : undefined;
+    const entry2 = byInode ?? getEntryBySlug(state, entityType, entitySlug);
     if (entry2 && frozenEntities.has(`${entityType}:${entry2.id}`))
       continue;
     let content;
     try {
-      content = readFileSync23(absolutePath, "utf8");
+      content = readFileSync25(absolutePath, "utf8");
     } catch {
       continue;
     }
     if (!entry2) {
-      writes.push({ path: relPath, kind: "new", clears: "resave" });
+      let frontmatter;
+      try {
+        frontmatter = import_gray_matter13.default(content).data ?? {};
+      } catch {
+        continue;
+      }
+      const verdict = classifyUntrackedEntity({
+        entityType,
+        entitySlug,
+        frontmatter
+      });
+      if (verdict.kind === "hold") {
+        writes.push({
+          path: relPath,
+          kind: "new",
+          clears: "resave",
+          held: verdict.held
+        });
+      } else {
+        discovered.push({ path: relPath, kind: "new" });
+      }
       continue;
     }
     let hashes;
@@ -39936,10 +40664,38 @@ function scanPendingWrites(args) {
     } catch {
       continue;
     }
-    if (hashes.bodyHash !== entry2.body_hash || hashes.frontmatterHash !== entry2.frontmatter_hash) {
+    const edited = hashes.bodyHash !== entry2.body_hash || hashes.frontmatterHash !== entry2.frontmatter_hash;
+    if (byInode && byInode.slug !== entitySlug) {
+      const destination = classifyRenameDestination({
+        state,
+        entityType,
+        entitySlug,
+        movedEntryId: byInode.id
+      });
+      if (destination.kind === "hold") {
+        writes.push({
+          path: relPath,
+          kind: edited ? "edited" : "renamed",
+          clears: "resave",
+          held: destination.held
+        });
+      } else {
+        writes.push({
+          path: relPath,
+          kind: edited ? "edited" : "renamed",
+          clears: "boot"
+        });
+      }
+      continue;
+    }
+    if (edited) {
       writes.push({ path: relPath, kind: "edited", clears: "boot" });
     }
   }
+  const overCap = discovered.length > discoveryWriteCap();
+  for (const d of discovered) {
+    writes.push(overCap ? { path: d.path, kind: d.kind, clears: "resave", held: "cap" } : { path: d.path, kind: d.kind, clears: "boot" });
+  }
   for (const lane of [
     {
       filename: WORKSPACE_RULES_FILENAME,
@@ -40016,6 +40772,15 @@ function row(label, value) {
 function cont(value) {
   return `${" ".repeat(LABEL_WIDTH)}  ${value}`;
 }
+function uncheckedLines(items) {
+  const n = items.length;
+  const head = `${n} generated command file${n === 1 ? "" : "s"} could not be checked, ` + `so ${n === 1 ? "its block was" : "their blocks were"} not compared.`;
+  const why = {
+    unreadable: "could not be opened; check its permissions and that it is a file",
+    "no-markers": "its BEGIN/END markers are gone; the next sync backs your copy up and restores them"
+  };
+  return [head, ...items.map((i) => `${i.commandRel} — ${why[i.reason]}`)];
+}
 function formatRelative(deltaMs) {
   const s = Math.floor(Math.max(0, deltaMs) / 1000);
   if (s < 1)
@@ -40055,7 +40820,7 @@ function renderBuild(out, staleness) {
 }
 function lastActivity(now) {
   try {
-    const mtimeMs = statSync15(daemonLogPath()).mtimeMs;
+    const mtimeMs = statSync17(daemonLogPath()).mtimeMs;
     return formatRelative(now.getTime() - mtimeMs);
   } catch {
     return null;
@@ -40161,7 +40926,10 @@ async function runStatus(args, deps = {}) {
     out.info(row("Unsynced", "All local writes synced."));
   } else {
     const bootable = pending.writes.filter((w) => w.clears === "boot");
-    const resavable = pending.writes.filter((w) => w.clears === "resave");
+    const heldByCap = pending.writes.filter((w) => w.held === "cap");
+    const heldArtists = pending.writes.filter((w) => w.held === "artist");
+    const heldCloudRows = pending.writes.filter((w) => w.held === "cloud-row");
+    const heldRenames = pending.writes.filter((w) => w.held === "rename-taken");
     const MAX_SHOWN = 10;
     const listPaths = (writes) => {
       for (const w of writes.slice(0, MAX_SHOWN)) {
@@ -40182,10 +40950,25 @@ async function runStatus(args, deps = {}) {
       listPaths(bootable);
       out.info(cont(pushing ? "A file you just saved clears within seconds. If something " + "stays listed, save it again or restart the daemon." : "Start the daemon so it can push them — the Plinth desktop app " + "runs it for you; in a terminal, `plinth start`."));
     }
-    if (resavable.length > 0) {
-      head(`${resavable.length} file${resavable.length === 1 ? "" : "s"} ` + `Plinth has never seen.`);
-      listPaths(resavable);
-      out.info(cont("New files are only picked up when they change. With the daemon " + "running, open and save each one and it will sync."));
+    if (heldByCap.length > 0) {
+      head(`${heldByCap.length} file${heldByCap.length === 1 ? "" : "s"} ` + `Plinth has never seen — more than it adds unattended in one go.`);
+      listPaths(heldByCap);
+      out.info(cont(`Plinth adds at most ${discoveryWriteCap()} new files per start. ` + "With the daemon running, open and save the ones you want now — or " + "set PLINTH_DISCOVERY_WRITE_CAP higher and restart it."));
+    }
+    if (heldArtists.length > 0) {
+      head(`${heldArtists.length} artist file${heldArtists.length === 1 ? "" : "s"} ` + `with no artist in Plinth.`);
+      listPaths(heldArtists);
+      out.info(cont("Plinth never adds an artist on its own. Create the artist in Plinth, " + "or open and save this file with the daemon running to add them."));
+    }
+    if (heldRenames.length > 0) {
+      head(`${heldRenames.length} renamed file${heldRenames.length === 1 ? "" : "s"} ` + `whose new name is already taken in Plinth.`);
+      listPaths(heldRenames);
+      out.info(cont("Two files cannot share a name in Plinth. Rename this one to something " + "free and it will sync."));
+    }
+    if (heldCloudRows.length > 0) {
+      head(`${heldCloudRows.length} file${heldCloudRows.length === 1 ? "" : "s"} ` + `that came from Plinth but this copy has lost track of.`);
+      listPaths(heldCloudRows);
+      out.info(cont("If this copy simply lost track of them, re-sync with `plinth login " + `--workspace ${slug} --reset-sync\`. If you made this file by ` + "duplicating another, delete its `revision:` line and Plinth will " + "add it as new."));
     }
     if (unsynced > 0) {
       head(`${unsynced} write${unsynced === 1 ? "" : "s"} awaiting retry (rate-limited or offline).`);
@@ -40220,6 +41003,33 @@ async function runStatus(args, deps = {}) {
     out.info(cont(`Full list with restore commands: ${CONFLICTS_VIEW_REL_PATH} (written by the sync, so this line is the fresher of the two)`));
   }
   out.info("");
+  const commandScan = scanStaleUserBlocks({ workspaceSlug: slug });
+  const unchecked = commandScan.unchecked;
+  if (commandScan.stale.length > 0) {
+    const n = commandScan.stale.length;
+    out.info(row("Commands", n === 1 ? `1 customisable block names machinery ${commandScan.stale[0].invocation} no longer uses.` : `${n} customisable blocks name machinery their commands no longer use.`));
+    for (const f of commandScan.stale) {
+      const versions2 = new Set(f.tokens.map((t) => t.version));
+      const names = f.tokens.map((t) => versions2.size === 1 ? `\`${t.token}\`` : `\`${t.token}\` (${t.version})`);
+      const joined = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+      const inVersion = versions2.size === 1 ? ` in ${f.tokens[0].version}` : "";
+      out.info(cont(`${f.commandRel} names ${joined}, retired from ${f.invocation}` + `${inVersion}. Review it.`));
+    }
+    if (unchecked.length > 0) {
+      for (const line of uncheckedLines(unchecked))
+        out.info(cont(line));
+    }
+  } else if (unchecked.length > 0) {
+    const [head, ...rest] = uncheckedLines(unchecked);
+    out.info(row("Commands", head));
+    for (const line of rest)
+      out.info(cont(line));
+  } else if (commandScan.checked === 0) {
+    out.info(row("Commands", "No generated commands yet. They arrive on the next sync."));
+  } else {
+    out.info(row("Commands", "Your customisable blocks match the current commands."));
+  }
+  out.info("");
   const voiceRecord = localState.user_voice;
   let voiceRaw = null;
   try {
@@ -40241,6 +41051,59 @@ async function runStatus(args, deps = {}) {
   } else {
     out.info(row("Voice", `${VOICE_FILENAME} is present; Plinth has not checked it yet.`));
   }
+  out.info("");
+  let report = null;
+  try {
+    report = runGroundingReport({ workspaceSlug: slug });
+  } catch {
+    report = null;
+  }
+  if (report === null) {
+    out.info(row("Injection", "Could not render the session grounding to measure it."));
+  } else {
+    const injected = report.block;
+    const bytes = Buffer.byteLength(injected);
+    const overBudget = bytes > GROUNDING_BUDGET_BYTES;
+    out.info(row("Injection", `${bytes.toLocaleString("en-GB")} bytes at every session start` + (overBudget ? "" : ` (budget ${GROUNDING_BUDGET_BYTES.toLocaleString("en-GB")})`)));
+    const contributors = [];
+    const rides = (name, reduce) => {
+      let raw = null;
+      try {
+        raw = readContextFile(slug, name);
+      } catch {
+        raw = null;
+      }
+      const body = reduce(raw);
+      if (body !== null)
+        contributors.push({ name, bytes: Buffer.byteLength(body) });
+    };
+    rides(WORKSPACE_MEMORY_FILENAME, extractWorkspaceMemory);
+    rides(USER_MEMORY_FILENAME, extractUserMemory);
+    contributors.sort((a, b) => b.bytes - a.bytes);
+    const largest = contributors[0];
+    const indexes = [
+      { name: WORKSPACE_MEMORY_FILENAME, pick: report.picks.wmPick },
+      { name: USER_MEMORY_FILENAME, pick: report.picks.umPick }
+    ].flatMap((i) => i.pick === null ? [] : [{ name: i.name, ...i.pick }]);
+    const dropped = indexes.filter((i) => i.kept === 0 && i.total > 0);
+    const partial2 = indexes.filter((i) => i.kept > 0 && i.kept < i.total);
+    if (overBudget) {
+      out.info(cont(`Over the ${GROUNDING_BUDGET_BYTES.toLocaleString("en-GB")}-byte budget.` + (indexes.length > 0 ? " Your memory indexes are already trimmed as far as they go, so the rest is Plinth's own grounding." : " There is no memory index to trim, so all of it is Plinth's own grounding and this workspace's rules.") + " Report it."));
+    } else if (dropped.length > 0 || partial2.length > 0) {
+      for (const i of dropped) {
+        out.info(cont(`NONE of ${i.name} fits in the injection: all ${i.total} facts are read from the file on demand, not recalled.`));
+      }
+      for (const i of partial2) {
+        out.info(cont(`Only ${i.kept} of ${i.total} facts in ${i.name} fit in the injection. The rest stay in the file and are read on demand.`));
+      }
+      if (largest !== undefined) {
+        out.info(cont(`${largest.name} is the largest of these at ${largest.bytes.toLocaleString("en-GB")} bytes. Shorter lines fit more facts: the convention is one line per fact, a hook and a [[pointer]], not a paragraph.`));
+      }
+    } else {
+      out.info(cont("Every memory fact fits; nothing is being trimmed."));
+    }
+  }
+  out.info("");
   return { exitCode: 0 };
 }
 var statusCommand = defineCommand({
@@ -40280,7 +41143,7 @@ var versionCommand = defineCommand({
 });
 
 // src/commands/voice-gate.ts
-import { readFileSync as readFileSync26 } from "node:fs";
+import { readFileSync as readFileSync28 } from "node:fs";
 
 // src/lib/voice-gate/api.ts
 var VoiceGateSurfaces = [
@@ -40385,7 +41248,7 @@ async function callVoiceGate(req) {
 import { createHash as createHash4 } from "node:crypto";
 import {
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync26,
   renameSync as renameSync8,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync9
@@ -40416,7 +41279,7 @@ function emptyFile() {
 }
 function load2(workspaceSlug) {
   try {
-    const raw = readFileSync24(attemptsPath(workspaceSlug), "utf8");
+    const raw = readFileSync26(attemptsPath(workspaceSlug), "utf8");
     const parsed = AttemptsFileSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : emptyFile();
   } catch {
@@ -40579,7 +41442,7 @@ function denyUngated(detail) {
 }
 
 // src/lib/voice-gate/payload.ts
-import { readFileSync as readFileSync25, statSync as statSync16 } from "node:fs";
+import { readFileSync as readFileSync27, statSync as statSync18 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { isAbsolute as isAbsolute3, resolve as resolve4 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
@@ -40736,11 +41599,11 @@ function isHelperInvocation(tokens) {
   return helperIndex === start + 1 && /(^|\/)python[0-9.]*$/.test(prev);
 }
 function defaultReadBodyFile(path5) {
-  const stat4 = statSync16(path5);
+  const stat4 = statSync18(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 readFileSync25(path5, "utf8");
+  return readFileSync27(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);
@@ -41100,7 +41963,7 @@ async function runVoiceGateDirect(args, deps = {}) {
   let text;
   if (args.file) {
     try {
-      text = readFileSync26(args.file, "utf8");
+      text = readFileSync28(args.file, "utf8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       out.error(`Could not read ${args.file}: ${msg}`);