@plinth-music/cli 0.21.1 → 0.22.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.21.1",
+  version: "0.22.0",
   description: "Plinth capstone sync daemon and CLI",
   type: "module",
   private: false,
@@ -22479,6 +22479,204 @@ function formatValueToken(value) {
   return s.length > 40 ? s.slice(0, 40) : s;
 }
 
+// src/lib/memory/annotate.ts
+var MEMORY_ANNOTATION_KEYS = [
+  "memory_state",
+  "memory_checked_at",
+  "memory_retryable",
+  "memory_state_revision",
+  "memory_invalidated_at",
+  "memory_refresh_attempts",
+  "memory_last_refresh_failed_at",
+  "memory_stale_premises",
+  "memory_stale_premises_withheld",
+  "memory_corrections",
+  "memory_corrections_count",
+  "memory_corrections_coverage"
+];
+function yamlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\u0000-\u001f\u007f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
+  return `"${escaped}"`;
+}
+function listItem(pairs, indent = "  ") {
+  return pairs.map(([k, v], i) => i === 0 ? `${indent}- ${k}: ${v}` : `${indent}  ${k}: ${v}`);
+}
+function successorLines(outcome, successor) {
+  const out = [];
+  if (outcome)
+    out.push(["trail", yamlString(outcome)]);
+  if (successor?.slug) {
+    out.push(["replaced_by", yamlString(successor.slug)]);
+    if (successor.description) {
+      out.push(["replaced_by_says", yamlString(successor.description)]);
+    }
+  } else if (outcome === "superseded" || outcome === "withheld") {
+    out.push(["replaced_by", yamlString("withheld - not readable by you")]);
+  }
+  return out;
+}
+function correctionLines(items) {
+  if (items.length === 0)
+    return [];
+  const lines = [];
+  const sorted = [...items].sort((a, b) => a.evidence_id < b.evidence_id ? -1 : a.evidence_id > b.evidence_id ? 1 : 0);
+  for (const item of sorted) {
+    const pairs = [["fact", yamlString(item.slug)]];
+    pairs.push(["status", yamlString(item.status)]);
+    if (item.evidential_status && item.evidential_status !== "undisputed") {
+      pairs.push(["dispute", yamlString(item.evidential_status)]);
+    }
+    if (item.heading_or_span)
+      pairs.push(["where", yamlString(item.heading_or_span)]);
+    if (item.redacted === true) {
+      pairs.push(["says", yamlString("withheld")]);
+    } else if (item.excerpt) {
+      pairs.push(["says", yamlString(item.excerpt)]);
+    }
+    pairs.push(...successorLines(item.trail_outcome, item.successor));
+    lines.push(...listItem(pairs));
+  }
+  return lines;
+}
+function premiseLines(items) {
+  if (items.length === 0)
+    return [];
+  const lines = [];
+  const sorted = [...items].sort((a, b) => a.fact_id < b.fact_id ? -1 : a.fact_id > b.fact_id ? 1 : 0);
+  for (const item of sorted) {
+    const pairs = [["fact", yamlString(item.slug)]];
+    pairs.push(["status", yamlString(item.status)]);
+    if (item.evidential_status && item.evidential_status !== "undisputed") {
+      pairs.push(["dispute", yamlString(item.evidential_status)]);
+    }
+    pairs.push(...successorLines(item.trail_outcome, item.successor));
+    lines.push(...listItem(pairs));
+  }
+  return lines;
+}
+function renderAnnotationLines(a) {
+  const lines = [];
+  if (a.kind === "document") {
+    lines.push(`memory_state: ${yamlString(a.state)}`);
+  }
+  lines.push(`memory_checked_at: ${a.checkedAt === null ? "null" : yamlString(a.checkedAt)}`);
+  if (a.retryable)
+    lines.push("memory_retryable: true");
+  if (a.stateRevision !== null) {
+    lines.push(`memory_state_revision: ${a.stateRevision}`);
+  }
+  if (a.invalidatedAt) {
+    lines.push(`memory_invalidated_at: ${yamlString(a.invalidatedAt)}`);
+  }
+  if (a.refreshAttempts !== null && a.refreshAttempts > 0) {
+    lines.push(`memory_refresh_attempts: ${a.refreshAttempts}`);
+  }
+  if (a.lastRefreshFailedAt) {
+    lines.push(`memory_last_refresh_failed_at: ${yamlString(a.lastRefreshFailedAt)}`);
+  }
+  const premises = premiseLines(a.stalePremises);
+  if (premises.length > 0) {
+    lines.push("memory_stale_premises:");
+    lines.push(...premises);
+  }
+  if (a.withheldPremises > 0) {
+    lines.push(`memory_stale_premises_withheld: ${a.withheldPremises}`);
+  }
+  if (a.corrections === null) {
+    lines.push("memory_corrections: null");
+  } else {
+    lines.push(`memory_corrections_coverage: ${yamlString(a.coverage ?? "recorded_evidence")}`);
+    lines.push(`memory_corrections_count: ${a.corrections.length}`);
+    if (a.corrections.length === 0) {
+      lines.push("memory_corrections: []");
+    } else {
+      lines.push("memory_corrections:");
+      lines.push(...correctionLines(a.corrections));
+    }
+  }
+  return lines;
+}
+function classifyServedState(word) {
+  switch (word) {
+    case "untracked":
+    case "current":
+    case "invalidated":
+    case "refresh_failed":
+    case "not_found":
+      return word;
+    default:
+      return "unknown";
+  }
+}
+function annotationForDocument(args) {
+  const { projection, corrections, checkedAt } = args;
+  if (!projection) {
+    return {
+      kind: "document",
+      state: "unknown",
+      checkedAt,
+      retryable: false,
+      stateRevision: null,
+      invalidatedAt: null,
+      lastRefreshFailedAt: null,
+      refreshAttempts: null,
+      stalePremises: [],
+      withheldPremises: 0,
+      corrections: corrections ? corrections.items : null,
+      coverage: corrections ? corrections.coverage : null
+    };
+  }
+  const state = classifyServedState(projection.state);
+  const dependencies = projection.dependencies_not_current ?? [];
+  return {
+    kind: "document",
+    state,
+    checkedAt,
+    retryable: projection.retryable ?? state === "refresh_failed",
+    stateRevision: projection.state_revision ?? null,
+    invalidatedAt: projection.invalidated_at ?? null,
+    lastRefreshFailedAt: projection.last_refresh_failed_at ?? null,
+    refreshAttempts: projection.refresh_attempts ?? null,
+    stalePremises: dependencies.filter((d) => !("withheld" in d)),
+    withheldPremises: dependencies.filter((d) => ("withheld" in d)).length,
+    corrections: corrections ? corrections.items : null,
+    coverage: corrections ? corrections.coverage : null
+  };
+}
+function annotationForWorkspaceFile(args) {
+  const { corrections, checkedAt } = args;
+  return {
+    kind: "workspace_file",
+    state: corrections ? "current" : "unknown",
+    checkedAt,
+    retryable: false,
+    stateRevision: null,
+    invalidatedAt: null,
+    lastRefreshFailedAt: null,
+    refreshAttempts: null,
+    stalePremises: [],
+    withheldPremises: 0,
+    corrections: corrections ? corrections.items : null,
+    coverage: corrections ? corrections.coverage : null
+  };
+}
+function unknownAnnotation(priorCheckedAt, kind = "document") {
+  return {
+    kind,
+    state: "unknown",
+    checkedAt: priorCheckedAt,
+    retryable: false,
+    stateRevision: null,
+    invalidatedAt: null,
+    lastRefreshFailedAt: null,
+    refreshAttempts: null,
+    stalePremises: [],
+    withheldPremises: 0,
+    corrections: null,
+    coverage: null
+  };
+}
+
 // src/lib/entities/documents.ts
 var DocumentLiveSchema = exports_external.object({
   ...BASE_ROW,
@@ -22514,7 +22712,8 @@ var SERVER_AUTHORITATIVE_KEYS2 = new Set([
   "last_edited_at",
   "pinned",
   "artist_id",
-  "project_id"
+  "project_id",
+  ...MEMORY_ANNOTATION_KEYS
 ]);
 var WIRE_EDITABLE_TOP_LEVEL_KEYS2 = new Set([
   "category",
@@ -23755,8 +23954,11 @@ var MEMORY_FACTS_DIR = "memory";
 var MEMORY_FACTS_PRIVATE_SEGMENT = "private";
 var MEMORY_FACT_SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var MEMORY_FACT_SLUG_MAX = 64;
+function isWritableFactSlug(slug) {
+  return MEMORY_FACT_SLUG_RE.test(slug) && slug.length <= MEMORY_FACT_SLUG_MAX;
+}
 function assertFactSlug(slug) {
-  if (!MEMORY_FACT_SLUG_RE.test(slug) || slug.length > MEMORY_FACT_SLUG_MAX) {
+  if (!isWritableFactSlug(slug)) {
     throw new MirrorPathError(`Invalid memory fact slug: ${JSON.stringify(slug)}`);
   }
 }
@@ -23764,6 +23966,46 @@ function memoryFactRelPath(pile, slug) {
   assertFactSlug(slug);
   return pile === "private" ? `${MEMORY_FACTS_DIR}/${MEMORY_FACTS_PRIVATE_SEGMENT}/${slug}.md` : `${MEMORY_FACTS_DIR}/${slug}.md`;
 }
+function memoryFactLinkTarget(pile, slug) {
+  return memoryFactRelPath(pile, slug).slice(0, -".md".length);
+}
+var MEMORY_FRESHNESS_BASENAME = "_freshness.md";
+function memoryFreshnessRelPath() {
+  return `${MEMORY_FACTS_DIR}/${MEMORY_FRESHNESS_BASENAME}`;
+}
+function memoryFreshnessFilePath(workspaceSlug) {
+  const ws = workspaceMirrorPath(workspaceSlug);
+  const target = resolve(join2(ws, MEMORY_FACTS_DIR, MEMORY_FRESHNESS_BASENAME));
+  const prefix = join2(ws, MEMORY_FACTS_DIR) + sep;
+  if (!target.startsWith(prefix)) {
+    throw new MirrorPathError("Resolved freshness marker path escapes the memory subtree");
+  }
+  assertNoSymlinkedComponent(ws, target);
+  return target;
+}
+function writeMemoryFreshnessFile(workspaceSlug, content) {
+  const target = memoryFreshnessFilePath(workspaceSlug);
+  const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+  mkdirSync(dirname(target), { recursive: true, mode: 448 });
+  writeFileSync(tmp, content, { mode: 384 });
+  try {
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {}
+    throw err;
+  }
+}
+function readMemoryFreshnessFile(workspaceSlug) {
+  try {
+    return readFileSync(memoryFreshnessFilePath(workspaceSlug), "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    throw err;
+  }
+}
 function parseMemoryFactRelPath(rel) {
   const posix = rel.split(sep).join("/");
   if (!posix.startsWith(`${MEMORY_FACTS_DIR}/`) || !posix.endsWith(".md")) {
@@ -25931,6 +26173,25 @@ import {
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { dirname as dirname4, join as join6 } from "node:path";
+
+// src/lib/hash.ts
+import { createHash } from "node:crypto";
+function stableHash(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map((v) => stableStringify(v)).join(",") + "]";
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return "{" + keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",") + "}";
+}
+
+// src/lib/state.ts
 var StateEntrySchema = exports_external.object({
   id: exports_external.string().uuid(),
   slug: exports_external.string().min(1),
@@ -25978,9 +26239,61 @@ var MemoryFactEntrySchema = exports_external.object({
   id: exports_external.string().min(1),
   body_hash: exports_external.string().min(1)
 });
+var FeedWatermarkStateSchema = exports_external.object({
+  snapshot: exports_external.string().min(1),
+  taken_at: exports_external.string()
+});
+var FACT_FRESHNESS = ["current", "behind", "unknown"];
+var FACT_PULL_REASONS = [
+  "behind",
+  "floor_due",
+  "watcher_edit",
+  "incomplete_apply",
+  "bad_watermark"
+];
 var MemoryFactsStateSchema = exports_external.object({
   fetched_at: exports_external.string().datetime({ offset: true }),
-  facts: exports_external.record(exports_external.string(), MemoryFactEntrySchema).default({})
+  facts: exports_external.record(exports_external.string(), MemoryFactEntrySchema).default({}),
+  watermark: FeedWatermarkStateSchema.nullish(),
+  freshness: exports_external.enum(FACT_FRESHNESS).optional(),
+  freshness_checked_at: exports_external.string().datetime({ offset: true }).nullish(),
+  freshness_reason: exports_external.string().nullish(),
+  last_full_pull_at: exports_external.string().datetime({ offset: true }).nullish(),
+  pull_epoch: exports_external.number().int().nonnegative().optional(),
+  pull_pending: exports_external.partialRecord(exports_external.enum(FACT_PULL_REASONS), exports_external.number().int()).optional(),
+  freshness_cooldown_until: exports_external.string().datetime({ offset: true }).nullish(),
+  freshness_failures: exports_external.number().int().nonnegative().optional()
+});
+var MEMORY_SOURCE_STATES = [
+  "untracked",
+  "current",
+  "invalidated",
+  "refresh_failed",
+  "not_found",
+  "unknown"
+];
+var MemorySourceStateSchema = exports_external.enum(MEMORY_SOURCE_STATES);
+var MemorySourceEntrySchema = exports_external.object({
+  id: exports_external.string().min(1),
+  state: MemorySourceStateSchema,
+  state_revision: exports_external.number().nullable(),
+  retryable: exports_external.boolean(),
+  corrections_hash: exports_external.string().nullable(),
+  corrections_count: exports_external.number().int().nonnegative().nullable(),
+  checked_at: exports_external.string().nullable(),
+  rendered: exports_external.string()
+});
+var MemorySourcesStateSchema = exports_external.object({
+  polled_at: exports_external.string().datetime({ offset: true }).optional(),
+  ask_failed_at: exports_external.string().datetime({ offset: true }).nullish(),
+  write_interrupted: exports_external.boolean().nullish(),
+  unwritten: exports_external.record(exports_external.string(), exports_external.object({
+    path: exports_external.string().min(1),
+    message: exports_external.string().min(1),
+    recorded_at: exports_external.string().datetime({ offset: true })
+  })).optional(),
+  documents: exports_external.record(exports_external.string(), MemorySourceEntrySchema).default({}),
+  workspace_files: exports_external.record(exports_external.string(), MemorySourceEntrySchema).default({})
 });
 var UnsyncedOpSchema = exports_external.object({
   target: exports_external.enum(["entity", "file"]),
@@ -26041,7 +26354,8 @@ var WorkspaceStateV2Schema = exports_external.object({
   team_rejected: TeamRejectedSchema.optional(),
   size_anchor: SizeAnchorSchema.optional(),
   last_trim_at: exports_external.string().min(1).optional(),
-  memory_facts: MemoryFactsStateSchema.optional()
+  memory_facts: MemoryFactsStateSchema.optional(),
+  memory_sources: MemorySourcesStateSchema.optional()
 });
 var WorkspaceStateV1Schema = exports_external.object({
   version: exports_external.literal(1),
@@ -26260,7 +26574,8 @@ function mergeWorkspaceState(fresh, before, after, wantCorrected = true) {
     team_rejected: mergeScalar(fresh.team_rejected, before.team_rejected, after.team_rejected),
     size_anchor: mergeAnchor(fresh.size_anchor, before.size_anchor, after.size_anchor),
     last_trim_at: mergeScalar(fresh.last_trim_at, before.last_trim_at, after.last_trim_at),
-    memory_facts: mergeScalar(fresh.memory_facts, before.memory_facts, after.memory_facts)
+    memory_facts: mergeScalar(fresh.memory_facts, before.memory_facts, after.memory_facts),
+    memory_sources: mergeScalar(fresh.memory_sources, before.memory_sources, after.memory_sources)
   };
   if (!wantCorrected)
     return { merged, corrected: after };
@@ -26556,13 +26871,62 @@ function getMemoryFactEntries(state) {
 function getMemoryFactEntry(state, relPath) {
   return state.memory_facts?.facts[relPath];
 }
+function raiseFactPullReason(state, reason, nowIso) {
+  const entry = state.memory_facts ?? { fetched_at: nowIso, facts: {} };
+  const pending = entry.pull_pending ?? {};
+  const epoch = (entry.pull_epoch ?? 0) + 1;
+  return {
+    ...state,
+    memory_facts: {
+      ...entry,
+      pull_epoch: epoch,
+      pull_pending: { ...pending, [reason]: epoch }
+    }
+  };
+}
 function setMemoryFactsState(state, entry) {
   const existing = state.memory_facts;
-  if (existing && sameFactRegistry(existing.facts, entry.facts)) {
+  if (existing && sameFactsEntry(existing, entry)) {
     return { state, changed: false };
   }
   return { state: { ...state, memory_facts: entry }, changed: true };
 }
+function sameFactsEntry(a, b) {
+  if (!sameFactRegistry(a.facts, b.facts))
+    return false;
+  if ((a.watermark?.snapshot ?? null) !== (b.watermark?.snapshot ?? null))
+    return false;
+  if ((a.watermark?.taken_at ?? null) !== (b.watermark?.taken_at ?? null))
+    return false;
+  if ((a.freshness ?? null) !== (b.freshness ?? null))
+    return false;
+  if ((a.freshness_checked_at ?? null) !== (b.freshness_checked_at ?? null))
+    return false;
+  if ((a.freshness_reason ?? null) !== (b.freshness_reason ?? null))
+    return false;
+  if ((a.last_full_pull_at ?? null) !== (b.last_full_pull_at ?? null))
+    return false;
+  if ((a.pull_epoch ?? 0) !== (b.pull_epoch ?? 0))
+    return false;
+  if ((a.freshness_cooldown_until ?? null) !== (b.freshness_cooldown_until ?? null)) {
+    return false;
+  }
+  if ((a.freshness_failures ?? 0) !== (b.freshness_failures ?? 0))
+    return false;
+  return samePullPending(a.pull_pending, b.pull_pending);
+}
+function samePullPending(a, b) {
+  const ak = Object.keys(a ?? {});
+  const bk = Object.keys(b ?? {});
+  if (ak.length !== bk.length)
+    return false;
+  for (const key of ak) {
+    const reason = key;
+    if (a?.[reason] !== b?.[reason])
+      return false;
+  }
+  return true;
+}
 function sameFactRegistry(a, b) {
   const aKeys = Object.keys(a);
   if (aKeys.length !== Object.keys(b).length)
@@ -26632,6 +26996,16 @@ function setLastTrimAt(state, at) {
     return { state, changed: false };
   return { state: { ...state, last_trim_at: at }, changed: true };
 }
+function getMemorySourceEntries(state, arm) {
+  return state.memory_sources?.[arm] ?? {};
+}
+function setMemorySourcesState(state, entry) {
+  const existing = state.memory_sources;
+  if (existing !== undefined && stableHash(existing) === stableHash(entry)) {
+    return { state, changed: false };
+  }
+  return { state: { ...state, memory_sources: entry }, changed: true };
+}
 
 // src/lib/memory-facts/stores.ts
 var BLOB_MEMORY_STORES = Object.freeze({
@@ -27174,25 +27548,8 @@ function injectUserBlock(generated, preserved) {
   return generated.slice(0, afterBegin) + preserved + generated.slice(endIdx);
 }
 
-// src/lib/hash.ts
-import { createHash } from "node:crypto";
-function stableHash(value) {
-  return createHash("sha256").update(stableStringify(value)).digest("hex");
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return "[" + value.map((v) => stableStringify(v)).join(",") + "]";
-  }
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  return "{" + keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",") + "}";
-}
-
 // src/lib/context/schema-version.ts
-var TEMPLATE_VERSION = "5";
+var TEMPLATE_VERSION = "6";
 var HEADER_RE = /<!--\s*plinth-schema-version:\s*([a-f0-9]+)\s*-->/;
 function computeSchemaVersion(inputs) {
   return stableHash(inputs).slice(0, 12);
@@ -29974,7 +30331,16 @@ function fileOverCapLine(f) {
   return `[FILE_OVER_CAP path=${f.path} size=${f.size} max=${f.max} max_from=${f.source}]`;
 }
 function fileConflictLine(f) {
-  return `[FILE_CONFLICT path=${f.path} stash=${f.stash}]`;
+  const viaPart = f.via ? ` via=${f.via}` : "";
+  const reusedPart = f.reused ? " reused=true" : "";
+  return `[FILE_CONFLICT path=${f.path} stash=${f.stash}${viaPart}${reusedPart}]`;
+}
+function filePushSkippedLine(f) {
+  return `[FILE_PUSH_SKIPPED path=${f.path} op=${f.op} reason=${f.reason}]`;
+}
+function fileStashFailedLine(f) {
+  const codePart = f.code ? ` code=${f.code}` : "";
+  return `[FILE_STASH_FAILED path=${f.path} reason=${f.reason}${codePart}]`;
 }
 function fileRejectionSyncFailedLine(f) {
   const parts = [`[FILE_REJECTION_SYNC_FAILED verb=${f.verb}`];
@@ -30364,7 +30730,31 @@ function clearMemoryGeneratedRefusal(state, workspaceSlug, absolutePath) {
   return commitState(state, { ...state, rejected: next });
 }
 
+// src/lib/context/house-style.ts
+var HOUSE_STYLE = [
+  "## House style: documents you write in `files/` or `documents/` (the workspace block below overrides it)",
+  "- Title as an H1. In `files/` name the file after it; in `documents/` keep the lowercase-hyphen filename (`tour-brief.md`) or it never syncs.",
+  "- Frontmatter: `artist`, `project`, `date`, `status`, as labels. A new `documents/` file links only through `artist_id:` / `project_id:`, the `id:` of the artist's or project's file.",
+  "- A one-line summary directly under the title.",
+  "- Money in tables, with the currency and thousands separators.",
+  "- Dates in ISO form with the day name, e.g. `2026-09-21 (Monday)`.",
+  "- Warnings and open questions as `>` callouts, not inline.",
+  "- Plain headings: no emoji, no decorative rules."
+];
+
 // src/lib/context/workspace-claude-md.ts
+var FILES_SEED_FOLDERS = [
+  "Deals",
+  "Finance",
+  "Live",
+  "Releases",
+  "Marketing",
+  "Meetings"
+];
+function seedFolderList() {
+  const head = FILES_SEED_FOLDERS.slice(0, -1).join(", ");
+  return `${head} or ${FILES_SEED_FOLDERS[FILES_SEED_FOLDERS.length - 1]}`;
+}
 var EXTRACTED_TEXT_DIR = extractedTextRelPath("x").replace(/x\.md$/, "");
 function rosterBlock(roster, activeProjectCountBySlug) {
   if (roster.length === 0)
@@ -30415,6 +30805,8 @@ function buildWorkspaceClaudeMd(input) {
     `- \`artists/<slug>/\` one folder per artist, the working dir for artist-scoped sessions · \`threads/<slug>/_thread.md\` one folder per thread${emptyNote(folders, ["artists", "threads"])}`,
     `- \`projects/\` \`tasks/\` \`documents/\` \`meetings/\` workspace-root flat entity files (one \`.md\` per entity, NOT nested under \`artists/\`, so one artist's rows are found by matching \`artist_id:\` in their frontmatter against that artist's own \`id:\` in \`artists/<slug>/_artist.md\`, never by matching the artist's name: a name match returned 16 of one artist's 46 projects and read as "no such project")${emptyNote(folders, ["projects", "tasks", "documents", "meetings"])}`,
     `- \`files/\` free-form document store: PDFs, executed agreements, spreadsheets, anything that is a FILE rather than an entity. Mirrored byte-for-byte both ways, folders and all${emptyNote(folders, [FILES_SUBTREE_DIR])}`,
+    `- Where a file goes in \`files/\`: a project's files in \`files/<Artist>/<Project>/\`, both names as Plinth shows them (name or slug, any case). That folder path is what links the file to the artist and the project when it syncs; frontmatter links nothing. If the artist or project is renamed in Plinth, new files under the old folder name may no longer link to it (files already there keep their links): file new work under the new name and leave existing folders where they are`,
+    `- An artist's files that belong to no single project go in \`files/<Artist>/\` under ${seedFolderList()} (a meeting's own notes stay on the Plinth meeting), or a folder two or more artists already have; start a new folder only when none fits. Files for no artist, an artist-less project's included, go in a top-level folder of \`files/\` named for the work, not an artist's name or slug; nothing links them`,
     `- \`${extractedTextRelPath("<path>")}\` where \`<path>\` is the file's path under \`files/\`: the text Plinth extracted from that file, so a PDF's contents can be searched. Not every file has one - text files are already their own text, and extraction can fail. Where it produced junk the file exists and says so instead of carrying it, so read what is there before trusting a silence. Derived: edits here are overwritten and never reach Plinth`,
     `- \`.claude/commands/\` local skills, incl. generated \`${START_COMMAND_INVOCATION}\` + \`${CLOSE_COMMAND_INVOCATION}\` + \`${ONBOARD_COMMAND_INVOCATION}\` · at the mirror root: \`workspace-memory.md\` \`workspace-rules.md\` (workspace-wide) + \`user-memory.md\` (yours), synced to Plinth · \`voice.md\` (yours: how you write, read by the agent, edited only by you) · \`CLAUDE.local.md\` private, gitignored`,
     ``,
@@ -30441,6 +30833,8 @@ function buildWorkspaceClaudeMd(input) {
     `## Skills: ${skillCount} discoverable location${skillCount === 1 ? "" : "s"}`,
     ...skillLines,
     ``,
+    ...HOUSE_STYLE,
+    ``,
     USER_BLOCK_BEGIN,
     USER_BLOCK_PLACEHOLDER,
     USER_BLOCK_END
@@ -33701,8 +34095,8 @@ var sessionCommand = defineCommand({
 });
 
 // src/commands/start.ts
-var import_gray_matter13 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync9, readFileSync as readFileSync26, statSync as statSync17 } from "node:fs";
+var import_gray_matter14 = __toESM(require_gray_matter(), 1);
+import { existsSync as existsSync9, readFileSync as readFileSync28, statSync as statSync18 } from "node:fs";
 
 // src/lib/daemon-log.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9, renameSync as renameSync7, statSync as statSync4 } from "node:fs";
@@ -33946,10 +34340,10 @@ class DestructiveGate {
 }
 
 // src/lib/resolve-pending.ts
-import { readFileSync as readFileSync18 } from "node:fs";
+import { readFileSync as readFileSync19 } from "node:fs";
 
 // src/lib/conflicts.ts
-import { mkdirSync as mkdirSync10, readdirSync as readdirSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync15, readdirSync as readdirSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname9, join as join12 } from "node:path";
 function conflictsRoot(workspaceSlug) {
   return join12(plinthHome(), "_conflicts", workspaceSlug);
@@ -33968,8 +34362,10 @@ function stashConflict(args) {
 function fileConflictPath(args) {
   const { workspaceSlug, relPath, timestamp, side } = args;
   const iso = timestamp.toISOString().replace(/[:.]/g, "-");
-  const safe = relPath.replace(/[/\\]/g, "__");
-  return join12(conflictsRoot(workspaceSlug), `files.${safe}.${iso}.${side}`);
+  return join12(conflictsRoot(workspaceSlug), `${fileConflictStem(relPath)}.${iso}.${side}`);
+}
+function fileConflictStem(relPath) {
+  return `files.${relPath.replace(/[/\\]/g, "__")}`;
 }
 function stashFileConflict(args) {
   const target = fileConflictPath(args);
@@ -33977,6 +34373,26 @@ function stashFileConflict(args) {
   writeFileSync7(target, args.bytes, { mode: 384 });
   return target;
 }
+function stashFileConflictOnce(args) {
+  const dir = conflictsRoot(args.workspaceSlug);
+  const head = `${fileConflictStem(args.relPath)}.`;
+  const tail = new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}-\\d{2}-\\d{2}-\\d{3}Z\\.${args.side}$`);
+  let names = [];
+  try {
+    names = readdirSync6(dir);
+  } catch {
+    names = [];
+  }
+  const newest = names.filter((n) => n.startsWith(head) && tail.test(n.slice(head.length))).sort().pop();
+  if (newest !== undefined) {
+    const path5 = join12(dir, newest);
+    try {
+      if (Buffer.compare(args.bytes, readFileSync15(path5)) === 0)
+        return { path: path5, reused: true };
+    } catch {}
+  }
+  return { path: stashFileConflict(args), reused: false };
+}
 var STAMP_RE2 = /\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)(?:\.(local|cloud))?(?:\.md)?$/;
 function parseStamp(stamp) {
   const iso = stamp.replace(/T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/, "T$1:$2:$3.$4Z");
@@ -34032,7 +34448,7 @@ function listConflictStashes(workspaceSlug) {
 }
 
 // src/lib/files/push.ts
-import { readFileSync as readFileSync15, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync16, statSync as statSync7 } from "node:fs";
 
 // src/lib/files/content-hash.ts
 import { createHash as createHash3 } from "node:crypto";
@@ -34188,7 +34604,7 @@ async function pushFilesUpsert(args) {
         state: next
       };
     }
-    bytes = readFileSync15(absolutePath);
+    bytes = readFileSync16(absolutePath);
     hash2 = sha256Bytes(bytes);
     inode = st.ino;
   }
@@ -34279,8 +34695,14 @@ async function pushFilesUpsert(args) {
       cloudRow = undefined;
     }
   }
-  const stashPath = stashFileConflict({ workspaceSlug, relPath, timestamp: now(), bytes, side: "local" });
-  output?.log(fileConflictLine({ path: relPath, stash: stashPath }));
+  const { path: stashPath, reused } = stashFileConflictOnce({
+    workspaceSlug,
+    relPath,
+    timestamp: now(),
+    bytes,
+    side: "local"
+  });
+  output?.log(fileConflictLine({ path: relPath, stash: stashPath, reused }));
   if (existing) {
     nextState = await restoreFileFromCloud({
       workspaceSlug,
@@ -34357,7 +34779,7 @@ class PerIdMutex {
 
 // src/lib/push.ts
 var import_gray_matter10 = __toESM(require_gray_matter(), 1);
-import { existsSync as existsSync4, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync18, statSync as statSync8 } from "node:fs";
 import { basename as basename5, relative as relative5 } from "node:path";
 
 // src/lib/frontmatter-id.ts
@@ -34407,7 +34829,7 @@ function frontmatterIdWriteIsSound(next, id, expectedBody) {
 
 // src/lib/pull-write.ts
 var import_gray_matter9 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 function computeMirrorHashes(strategy, content) {
   const parsed = import_gray_matter9.default(content);
   const fm = parsed.data ?? {};
@@ -34451,7 +34873,7 @@ function relocateForSlugChange(args) {
   }
   let raw = null;
   try {
-    raw = readFileSync16(fromPath, "utf8");
+    raw = readFileSync17(fromPath, "utf8");
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") {
@@ -34522,7 +34944,7 @@ function writeMirrorWithBodyPreserve(workspaceSlug, strategy, doc2, suppressor,
     const target = entityFilePath(workspaceSlug, strategy.type, targetSlug);
     let existing = null;
     try {
-      existing = readFileSync16(target, "utf8");
+      existing = readFileSync17(target, "utf8");
     } catch (err) {
       if (err?.code !== "ENOENT")
         throw err;
@@ -34654,7 +35076,7 @@ function stampStateFromMirror(args) {
   const { strategy, workspaceSlug, doc: doc2, state, priorMemoryHash } = args;
   const targetSlug = args.pathSlug ?? doc2.slug;
   const mirrorPath = entityFilePath(workspaceSlug, strategy.type, targetSlug);
-  const mirrorRaw = readFileSync17(mirrorPath, "utf8");
+  const mirrorRaw = readFileSync18(mirrorPath, "utf8");
   const mirrorParsed = import_gray_matter10.default(mirrorRaw);
   const mirrorFm = mirrorParsed.data ?? {};
   const mirrorLifted = splitUserFrontmatter(strategy, mirrorFm);
@@ -34807,7 +35229,7 @@ async function pushFile(args) {
   }
   let raw;
   try {
-    raw = readFileSync17(absolutePath, "utf8");
+    raw = readFileSync18(absolutePath, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
       return runPushDelete({
@@ -35157,7 +35579,7 @@ async function runPushUpsert(args) {
     if (liveEntry !== snapshotEntry) {
       let onDisk = null;
       try {
-        onDisk = readFileSync17(args.absolutePath, "utf8");
+        onDisk = readFileSync18(args.absolutePath, "utf8");
       } catch {
         onDisk = null;
       }
@@ -35597,7 +36019,7 @@ function writeCreatedIdBack(args) {
     if (entityFilePath(args.workspaceSlug, args.strategy.type, args.slug) !== args.absolutePath) {
       return;
     }
-    const readBack = args.readBack ?? ((p) => readFileSync17(p, "utf8"));
+    const readBack = args.readBack ?? ((p) => readFileSync18(p, "utf8"));
     if (readBack(args.absolutePath) !== args.raw)
       return;
     args.suppressor?.registerWrite(args.absolutePath, computeMirrorHashes(args.strategy, write.content));
@@ -35949,7 +36371,7 @@ async function pushRename(args) {
       };
       if (!updated.body_hash || !updated.frontmatter_hash) {
         try {
-          const mirrorRaw = readFileSync17(toPath, "utf8");
+          const mirrorRaw = readFileSync18(toPath, "utf8");
           const mirrorParsed = import_gray_matter10.default(mirrorRaw);
           const renameFm = mirrorParsed.data ?? {};
           const renameLifted = splitUserFrontmatter(strategy, renameFm);
@@ -35986,7 +36408,7 @@ async function pushRename(args) {
     if (patchResult.reason === "slug_conflict") {
       let contents2 = "";
       try {
-        contents2 = readFileSync17(toPath, "utf8");
+        contents2 = readFileSync18(toPath, "utf8");
       } catch {}
       const stashPath2 = stashConflict({
         workspaceSlug,
@@ -36034,7 +36456,7 @@ async function pushRename(args) {
     }
     let contents = "";
     try {
-      contents = readFileSync17(toPath, "utf8");
+      contents = readFileSync18(toPath, "utf8");
     } catch {}
     const stashPath = stashConflict({
       workspaceSlug,
@@ -36167,7 +36589,7 @@ async function discardBatchOps(batch, deps) {
         const path5 = opPath(deps.workspaceSlug, op);
         let local = null;
         try {
-          local = readFileSync18(path5, "utf8");
+          local = readFileSync19(path5, "utf8");
         } catch {
           local = null;
         }
@@ -36206,7 +36628,7 @@ async function discardFileOp(op, deps) {
   const abs = filesSubtreePath(deps.workspaceSlug, op.path);
   let local = null;
   try {
-    local = readFileSync18(abs);
+    local = readFileSync19(abs);
   } catch {
     local = null;
   }
@@ -36276,20 +36698,29 @@ var FactCommonSchema = exports_external.object({
   body_md: exports_external.string(),
   fact_type: exports_external.string(),
   status: exports_external.string(),
-  superseded_by: exports_external.string().nullish(),
   generality: exports_external.string().nullish(),
   source: exports_external.string().nullish(),
   created_at: exports_external.string().nullish(),
-  updated_at: exports_external.string().nullish()
+  updated_at: exports_external.string().nullish(),
+  evidential_status: exports_external.string().nullish(),
+  assertion_revision: exports_external.number().nullish(),
+  support_revision: exports_external.number().nullish(),
+  trail: exports_external.string().nullish(),
+  current_fact_id: exports_external.string().nullish()
 });
 var WorkspaceFactWireSchema = FactCommonSchema.extend({
   artist_id: exports_external.string().nullish(),
   revision: exports_external.number().nullish()
 });
 var UserFactWireSchema = FactCommonSchema;
+var FeedWatermarkSchema = exports_external.object({
+  snapshot: exports_external.string().min(1),
+  taken_at: exports_external.string()
+});
 var MemoryFactsFeedSchema = exports_external.object({
   workspace_facts: exports_external.array(WorkspaceFactWireSchema),
-  user_facts: exports_external.array(UserFactWireSchema)
+  user_facts: exports_external.array(UserFactWireSchema),
+  watermark: FeedWatermarkSchema.nullish()
 });
 var ROUTE = "/api/sync/memory-facts";
 function baseHeaders2(pat) {
@@ -36322,6 +36753,272 @@ async function getMemoryFacts(args) {
   return parsed.data;
 }
 
+// src/lib/memory-facts/freshness-state.ts
+var FULL_PULL_FLOOR_MS = 3600000;
+var FAILURE_BACKOFF_MS = [30000, 60000, 120000, 300000];
+function failureBackoffMs(consecutiveFailures) {
+  const i = Math.min(Math.max(consecutiveFailures, 1), FAILURE_BACKOFF_MS.length) - 1;
+  return FAILURE_BACKOFF_MS[i];
+}
+function emptyFactsEntry(nowIso) {
+  return { fetched_at: nowIso, facts: {} };
+}
+function raisePullReason(entry2, reason) {
+  const pending = entry2.pull_pending ?? {};
+  const epoch = (entry2.pull_epoch ?? 0) + 1;
+  return { ...entry2, pull_epoch: epoch, pull_pending: { ...pending, [reason]: epoch } };
+}
+var COPY_SUSPECT_REASONS = ["incomplete_apply", "watcher_edit"];
+function copySuspectReason(entry2) {
+  const pending = entry2.pull_pending ?? {};
+  for (const reason of COPY_SUSPECT_REASONS) {
+    if (pending[reason] !== undefined)
+      return reason;
+  }
+  return null;
+}
+function pendingReasons(entry2) {
+  const pending = entry2.pull_pending ?? {};
+  return Object.keys(pending).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function clearAppliedReasons(entry2, upToEpoch) {
+  const pending = entry2.pull_pending ?? {};
+  const kept = {};
+  for (const key of Object.keys(pending)) {
+    const raised = pending[key];
+    if (raised !== undefined && raised > upToEpoch)
+      kept[key] = raised;
+  }
+  return { ...entry2, pull_pending: kept };
+}
+function floorDue(entry2, now, floorMs = FULL_PULL_FLOOR_MS) {
+  const last = entry2.last_full_pull_at;
+  if (!last)
+    return true;
+  const at = Date.parse(last);
+  if (!Number.isFinite(at))
+    return true;
+  return now.getTime() - at >= floorMs;
+}
+function mayAsk(entry2, now) {
+  if (!entry2.watermark?.snapshot)
+    return false;
+  const until = entry2.freshness_cooldown_until;
+  if (!until)
+    return true;
+  const at = Date.parse(until);
+  if (!Number.isFinite(at))
+    return true;
+  return now.getTime() >= at;
+}
+function stamp(before, next, nowIso) {
+  const moved = before.freshness !== next.freshness || (before.freshness_reason ?? null) !== (next.freshness_reason ?? null) || (before.watermark?.snapshot ?? null) !== (next.watermark?.snapshot ?? null);
+  return moved ? { ...next, freshness_checked_at: nowIso } : { ...next, freshness_checked_at: before.freshness_checked_at ?? nowIso };
+}
+function applyVerdict(entry2, verdict, now) {
+  const nowIso = now.toISOString();
+  const served = {
+    ...entry2,
+    freshness_failures: 0,
+    freshness_cooldown_until: null
+  };
+  switch (verdict.kind) {
+    case "answer": {
+      if (verdict.behind) {
+        return raisePullReason(stamp(entry2, { ...served, freshness: "behind", freshness_reason: "behind" }, nowIso), "behind");
+      }
+      const suspect = copySuspectReason(entry2);
+      if (suspect !== null) {
+        return stamp(entry2, {
+          ...served,
+          freshness: "unknown",
+          freshness_reason: suspect,
+          watermark: entry2.watermark ?? null
+        }, nowIso);
+      }
+      const movedOn = entry2.freshness !== "current" || !entry2.watermark;
+      return stamp(entry2, {
+        ...served,
+        freshness: "current",
+        freshness_reason: null,
+        watermark: movedOn ? verdict.watermark ?? entry2.watermark ?? null : entry2.watermark ?? null
+      }, nowIso);
+    }
+    case "bad_watermark": {
+      return raisePullReason(stamp(entry2, {
+        ...served,
+        freshness: "unknown",
+        freshness_reason: "bad_watermark",
+        watermark: null
+      }, nowIso), "bad_watermark");
+    }
+    case "unavailable": {
+      const failures = (entry2.freshness_failures ?? 0) + 1;
+      return {
+        ...stamp(entry2, { ...entry2, freshness: "unknown", freshness_reason: "watermark_unavailable" }, nowIso),
+        freshness_failures: failures,
+        freshness_cooldown_until: new Date(now.getTime() + failureBackoffMs(failures)).toISOString()
+      };
+    }
+    case "rate_limited": {
+      const waitMs = Math.max(verdict.retryAfterMs ?? 0, failureBackoffMs(1));
+      return {
+        ...stamp(entry2, { ...entry2, freshness: "unknown", freshness_reason: "rate_limited" }, nowIso),
+        freshness_cooldown_until: new Date(now.getTime() + waitMs).toISOString()
+      };
+    }
+    case "failed": {
+      const failures = (entry2.freshness_failures ?? 0) + 1;
+      return {
+        ...stamp(entry2, { ...entry2, freshness: "unknown", freshness_reason: "check_failed" }, nowIso),
+        freshness_failures: failures,
+        freshness_cooldown_until: new Date(now.getTime() + failureBackoffMs(failures)).toISOString()
+      };
+    }
+  }
+}
+function withdrawClaim(entry2) {
+  if (entry2.freshness === "unknown" && entry2.freshness_reason === "poll_failed") {
+    return entry2;
+  }
+  return { ...entry2, freshness: "unknown", freshness_reason: "poll_failed" };
+}
+function pullDecision(entry2, verdict) {
+  const reasons = pendingReasons(entry2);
+  const servedNotBehind = verdict !== null && verdict.kind === "answer" && !verdict.behind;
+  const pull = !(servedNotBehind && reasons.length === 0);
+  return { pull, reasons, entry: entry2, epochAtFetch: entry2.pull_epoch ?? 0 };
+}
+function bankPull(args) {
+  const { entry: entry2, complete, watermark, epochAtFetch, now } = args;
+  const nowIso = now.toISOString();
+  if (!complete) {
+    return raisePullReason({ ...entry2, freshness: "unknown", freshness_reason: "incomplete_apply" }, "incomplete_apply");
+  }
+  const cleared = clearAppliedReasons(entry2, epochAtFetch);
+  const survived = copySuspectReason(cleared);
+  if (!watermark) {
+    return stamp(entry2, {
+      ...cleared,
+      fetched_at: nowIso,
+      last_full_pull_at: nowIso,
+      watermark: null,
+      freshness: "unknown",
+      freshness_reason: "no_watermark"
+    }, nowIso);
+  }
+  if (survived !== null) {
+    return stamp(entry2, {
+      ...cleared,
+      fetched_at: nowIso,
+      last_full_pull_at: nowIso,
+      watermark: entry2.watermark ?? null,
+      freshness: "unknown",
+      freshness_reason: survived
+    }, nowIso);
+  }
+  return stamp(entry2, {
+    ...cleared,
+    fetched_at: nowIso,
+    last_full_pull_at: nowIso,
+    watermark,
+    freshness: "current",
+    freshness_reason: null
+  }, nowIso);
+}
+
+// src/lib/memory-facts/marker.ts
+function verdictLines(entry2) {
+  const freshness = entry2.freshness ?? "unknown";
+  if (freshness === "current") {
+    return [
+      "Plinth confirmed this machine's copy of the memory facts was up to date.",
+      "",
+      "That was confirmed at the time below, by asking the server whether anything",
+      "had changed since this copy was taken. It is not a promise about right now:",
+      "if the daemon has stopped, nothing has been checked since."
+    ];
+  }
+  if (freshness === "behind") {
+    return [
+      "The server says this copy is BEHIND: something you can read has changed",
+      "since it was taken.",
+      "",
+      "The daemon downloads the whole fact list to catch up, normally within",
+      "seconds. Until it does, treat the facts in this folder as slightly old -",
+      "they are not wrong, they are just not the latest."
+    ];
+  }
+  return [
+    "Whether this copy is up to date is UNKNOWN. This is not the same as",
+    "'unchanged': nobody has been able to check.",
+    "",
+    unknownBecause(entry2.freshness_reason ?? null),
+    "",
+    "Run `plinth status` to see whether the daemon is running."
+  ];
+}
+function unknownBecause(reason) {
+  switch (reason) {
+    case "poll_failed":
+      return "The last attempt to reach Plinth did not get through - usually no network.";
+    case "rate_limited":
+      return "Plinth asked this machine to slow down, so the check is waiting its turn.";
+    case "watermark_unavailable":
+      return "This Plinth server cannot answer freshness checks yet.";
+    case "bad_watermark":
+      return "The marker this machine was checking against is no longer one the server recognises, so it will download the full list to get a new one.";
+    case "no_watermark":
+      return "The last download carried no freshness marker, so there is nothing to compare against.";
+    case "incomplete_apply":
+      return "The last download did not fully land, so this copy is not the one the freshness marker describes.";
+    case "check_failed":
+      return "The freshness check did not complete.";
+    default:
+      return "No freshness check has succeeded yet on this machine.";
+  }
+}
+function renderFreshnessMarker(entry2) {
+  const freshness = entry2.freshness ?? "unknown";
+  const lines = [
+    "<!-- GENERATED by Plinth. Edits here are not saved: the next sync rewrites",
+    `     this file. It is not a memory fact and nothing reads it back. This`,
+    `     file is ${memoryFreshnessRelPath()}. -->`,
+    "",
+    "# Memory facts: is this copy current?",
+    "",
+    ...verdictLines(entry2),
+    "",
+    "```",
+    `freshness: ${freshness}`
+  ];
+  if (entry2.freshness_checked_at) {
+    lines.push(`answer established: ${entry2.freshness_checked_at}`);
+  }
+  if (entry2.last_full_pull_at && entry2.freshness_reason !== "no_watermark") {
+    lines.push(`full fact list last downloaded: ${entry2.last_full_pull_at}`);
+  }
+  if (freshness !== "current" && entry2.freshness_reason) {
+    lines.push(`reason: ${entry2.freshness_reason}`);
+  }
+  lines.push("```");
+  return lines.join(`
+`).replace(/\n*$/, "") + `
+`;
+}
+function writeFreshnessMarkerIfChanged(args) {
+  const rendered = renderFreshnessMarker(args.entry);
+  const onDisk = readMemoryFreshnessFile(args.workspaceSlug);
+  if (onDisk !== null && stableHash(onDisk) === stableHash(rendered))
+    return false;
+  args.suppressor?.registerWrite(memoryFreshnessFilePath(args.workspaceSlug), {
+    bodyHash: stableHash(rendered),
+    frontmatterHash: ""
+  });
+  writeMemoryFreshnessFile(args.workspaceSlug, rendered);
+  return true;
+}
+
 // src/lib/memory-facts/refusal.ts
 var MEMORY_IS_GENERATED_CODE = "memory_is_generated";
 var GeneratedRefusalSchema = exports_external.object({
@@ -36392,59 +37089,134 @@ function refuseGeneratedMemoryEdit(args) {
 }
 
 // src/lib/memory-facts/render.ts
-function yamlString(value) {
+function yamlString2(value) {
   const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\u0000-\u001f\u007f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
   return `"${escaped}"`;
 }
 var SOURCE_UNKNOWN = "unknown";
-function toRenderableWorkspaceFact(row, artistSlugById) {
+var UNKNOWN = "unknown";
+var EVIDENTIAL_STATUSES = new Set(["undisputed", "disputed", "resolved"]);
+var TRAIL_OUTCOMES = new Set([
+  "current",
+  "superseded",
+  "retired",
+  "dangling",
+  "cycle",
+  "withheld",
+  "not_found"
+]);
+function resolveTrail(row, slugById) {
+  const outcome = row.trail ?? null;
+  const rawSuccessor = row.current_fact_id ?? null;
+  const successor = rawSuccessor !== null && rawSuccessor.trim() !== "" ? rawSuccessor : null;
+  if (outcome === null)
+    return { trail: UNKNOWN, consistent: true };
+  if (!TRAIL_OUTCOMES.has(outcome))
+    return { trail: UNKNOWN, consistent: true };
+  if (outcome === "superseded") {
+    if (successor === null) {
+      return { trail: UNKNOWN, consistent: false };
+    }
+    const slug = slugById(successor);
+    if (slug === undefined) {
+      return { trail: UNKNOWN, consistent: false };
+    }
+    return {
+      trail: "superseded",
+      current_fact_id: successor,
+      current_slug: slug,
+      consistent: true
+    };
+  }
+  if (successor !== null)
+    return { trail: UNKNOWN, consistent: false };
+  return { trail: outcome, consistent: true };
+}
+function evidentialStatus(raw) {
+  return raw && EVIDENTIAL_STATUSES.has(raw) ? raw : UNKNOWN;
+}
+function revision(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) ? String(raw) : UNKNOWN;
+}
+function factSlugIndex(rows) {
+  const byId = new Map;
+  for (const row of rows) {
+    if (isWritableFactSlug(row.slug))
+      byId.set(row.id, row.slug);
+  }
+  return (id) => byId.get(id);
+}
+function toRenderableWorkspaceFact(row, artistSlugById, factSlugById) {
   const artistId = row.artist_id ?? null;
+  const trail = resolveTrail(row, factSlugById);
   return {
-    pile: "shared",
-    id: row.id,
-    slug: row.slug,
-    description: row.description,
-    fact_type: row.fact_type,
-    status: row.status,
-    source: row.source,
-    superseded_by: row.superseded_by,
-    generality: row.generality,
-    body_md: row.body_md,
-    artist_id: artistId,
-    artist_slug: artistId ? artistSlugById(artistId) : undefined
-  };
-}
-function toRenderableUserFact(row) {
+    consistent: trail.consistent,
+    fact: {
+      pile: "shared",
+      id: row.id,
+      slug: row.slug,
+      description: row.description,
+      fact_type: row.fact_type,
+      status: row.status,
+      source: row.source,
+      generality: row.generality,
+      body_md: row.body_md,
+      artist_id: artistId,
+      artist_slug: artistId ? artistSlugById(artistId) : undefined,
+      evidential_status: evidentialStatus(row.evidential_status),
+      trail: trail.trail,
+      current_fact_id: trail.current_fact_id,
+      current_slug: trail.current_slug,
+      assertion_revision: revision(row.assertion_revision),
+      support_revision: revision(row.support_revision)
+    }
+  };
+}
+function toRenderableUserFact(row, factSlugById) {
+  const trail = resolveTrail(row, factSlugById);
   return {
-    pile: "private",
-    id: row.id,
-    slug: row.slug,
-    description: row.description,
-    fact_type: row.fact_type,
-    status: row.status,
-    source: row.source,
-    superseded_by: row.superseded_by,
-    generality: row.generality,
-    body_md: row.body_md
+    consistent: trail.consistent,
+    fact: {
+      pile: "private",
+      id: row.id,
+      slug: row.slug,
+      description: row.description,
+      fact_type: row.fact_type,
+      status: row.status,
+      source: row.source,
+      generality: row.generality,
+      body_md: row.body_md,
+      evidential_status: evidentialStatus(row.evidential_status),
+      trail: trail.trail,
+      current_fact_id: trail.current_fact_id,
+      current_slug: trail.current_slug,
+      assertion_revision: revision(row.assertion_revision),
+      support_revision: revision(row.support_revision)
+    }
   };
 }
 function renderFactFile(fact) {
   const lines = ["---"];
-  lines.push(`id: ${yamlString(fact.id)}`);
-  lines.push(`name: ${yamlString(fact.slug)}`);
-  lines.push(`description: ${yamlString(fact.description)}`);
-  lines.push(`type: ${yamlString(fact.fact_type)}`);
-  lines.push(`status: ${yamlString(fact.status)}`);
-  lines.push(`source: ${yamlString(fact.source ?? SOURCE_UNKNOWN)}`);
+  lines.push(`id: ${yamlString2(fact.id)}`);
+  lines.push(`name: ${yamlString2(fact.slug)}`);
+  lines.push(`description: ${yamlString2(fact.description)}`);
+  lines.push(`type: ${yamlString2(fact.fact_type)}`);
+  lines.push(`status: ${yamlString2(fact.status)}`);
+  lines.push(`source: ${yamlString2(fact.source ?? SOURCE_UNKNOWN)}`);
+  lines.push(`evidential_status: ${yamlString2(fact.evidential_status)}`);
+  lines.push(`trail: ${yamlString2(fact.trail)}`);
+  if (fact.current_fact_id && fact.current_slug) {
+    lines.push(`current_fact_id: ${yamlString2(fact.current_fact_id)}`);
+    lines.push(`current: ${yamlString2(`[[${memoryFactLinkTarget(fact.pile, fact.current_slug)}]]`)}`);
+  }
+  lines.push(`assertion_revision: ${yamlString2(fact.assertion_revision)}`);
+  lines.push(`support_revision: ${yamlString2(fact.support_revision)}`);
   if (fact.generality)
-    lines.push(`generality: ${yamlString(fact.generality)}`);
+    lines.push(`generality: ${yamlString2(fact.generality)}`);
   if (fact.artist_id)
-    lines.push(`artist_id: ${yamlString(fact.artist_id)}`);
+    lines.push(`artist_id: ${yamlString2(fact.artist_id)}`);
   if (fact.artist_slug)
-    lines.push(`artist: ${yamlString(fact.artist_slug)}`);
-  if (fact.superseded_by) {
-    lines.push(`superseded_by: ${yamlString(fact.superseded_by)}`);
-  }
+    lines.push(`artist: ${yamlString2(fact.artist_slug)}`);
   lines.push("---");
   lines.push("");
   lines.push(...headerComment(fact));
@@ -36464,6 +37236,22 @@ function headerComment(fact) {
     `     ${factToolsFor(fact.pile)}`,
     `     with id ${fact.id}. This file is ${rel}.`
   ];
+  if (fact.trail === "superseded" && fact.current_slug) {
+    out.push(`     SUPERSEDED: the current version of this fact is`, `     ${memoryFactLinkTarget(fact.pile, fact.current_slug)}.`);
+  } else if (fact.trail === "withheld") {
+    out.push(`     SUPERSEDED: this fact was replaced, and the replacement is not one`, `     you can read. Nothing here names it.`);
+  } else if (fact.trail === "dangling") {
+    out.push(`     SUPERSEDED: the fact that replaced this one is no longer served, so`, `     there is no current version to follow.`);
+  } else if (fact.trail === "cycle") {
+    out.push(`     The correction trail for this fact loops back on itself, so no`, `     current version could be resolved.`);
+  } else if (fact.trail === UNKNOWN) {
+    out.push(`     Its correction trail is UNKNOWN to this mirror - not "unchanged".`, `     Ask Plinth directly if it matters which version is current.`);
+  }
+  if (fact.evidential_status === "disputed") {
+    out.push(`     DISPUTED: this fact is contested. It is still the current one.`);
+  } else if (fact.evidential_status === UNKNOWN) {
+    out.push(`     Whether it is disputed is UNKNOWN to this mirror, never assume not.`);
+  }
   if (fact.status !== "active") {
     out.push(`     STATUS ${fact.status.toUpperCase()}: this fact is no longer current and is not in any index.`);
   }
@@ -36480,24 +37268,45 @@ function artistSlugLookup(state) {
   return (id) => byId.get(id);
 }
 async function syncMemoryFacts(args) {
-  const { workspaceSlug, baseUrl, pat, fetchImpl, output, suppressor } = args;
+  const { workspaceSlug, baseUrl, pat, fetchImpl, output, suppressor, gate } = args;
   const now = args.now ?? (() => new Date);
   let state = args.state;
+  const decision = gate ? await gate.decide(now()) : pullDecision(state.memory_facts ?? emptyFactsEntry(now().toISOString()), null);
+  if (!decision.pull) {
+    return { state, written: 0, deleted: 0, refused: 0, facts: 0, pulled: false };
+  }
   let feed;
   try {
     feed = await getMemoryFacts({ baseUrl, pat, fetchImpl });
   } catch (err) {
     if (err instanceof ApiError && err.status === 404) {
       output?.log(`[MEMORY_FACTS ws=${workspaceSlug} skipped reason=route_absent]`);
-      return { state, written: 0, deleted: 0, refused: 0, facts: 0 };
+      return { state, written: 0, deleted: 0, refused: 0, facts: 0, pulled: false };
     }
     throw err;
   }
   const slugFor = artistSlugLookup(state);
-  const facts = [
-    ...feed.workspace_facts.map((row) => toRenderableWorkspaceFact(row, slugFor)),
-    ...feed.user_facts.map(toRenderableUserFact)
-  ];
+  const sharedIndex = factSlugIndex(feed.workspace_facts);
+  const privateIndex = factSlugIndex(feed.user_facts);
+  let complete = true;
+  const inconsistent = [];
+  const facts = [];
+  for (const row of feed.workspace_facts) {
+    const { fact, consistent } = toRenderableWorkspaceFact(row, slugFor, sharedIndex);
+    if (!consistent)
+      inconsistent.push(fact.slug);
+    facts.push(fact);
+  }
+  for (const row of feed.user_facts) {
+    const { fact, consistent } = toRenderableUserFact(row, privateIndex);
+    if (!consistent)
+      inconsistent.push(fact.slug);
+    facts.push(fact);
+  }
+  if (inconsistent.length > 0) {
+    complete = false;
+    output?.log(`[MEMORY_FACTS ws=${workspaceSlug} inconsistent_trail freshness=unknown ` + `facts=${inconsistent.slice(0, 10).join(",")}` + `${inconsistent.length > 10 ? `+${inconsistent.length - 10}` : ""}]`);
+  }
   const acked = getMemoryFactEntries(state);
   const registry3 = {};
   const live = new Set;
@@ -36505,14 +37314,16 @@ async function syncMemoryFacts(args) {
   let refused = 0;
   for (const fact of facts) {
     let relPath;
+    let rendered;
     try {
       relPath = memoryFactRelPath(fact.pile, fact.slug);
+      rendered = renderFactFile(fact);
     } catch {
       output?.warn(`Memory fact "${fact.slug}" has a slug this mirror cannot write - skipped.`);
+      complete = false;
       continue;
     }
     live.add(relPath);
-    const rendered = renderFactFile(fact);
     const renderedHash = stableHash(rendered);
     const onDisk = readMemoryFactFile(workspaceSlug, fact.pile, fact.slug);
     const ackedHash = acked[relPath]?.body_hash;
@@ -36559,15 +37370,46 @@ async function syncMemoryFacts(args) {
       deleted++;
     state = clearMemoryGeneratedRefusal(state, workspaceSlug, abs);
   }
-  const { state: next, changed } = setMemoryFactsState(state, {
-    fetched_at: now().toISOString(),
-    facts: registry3
-  });
-  state = changed ? commitState(state, next) : state;
+  const bankArgs = {
+    registry: registry3,
+    complete,
+    watermark: feed.watermark ?? null,
+    epochAtFetch: decision.epochAtFetch,
+    now: now()
+  };
+  let bankedFreshness;
+  if (gate) {
+    gate.bank(bankArgs);
+    bankedFreshness = "banked";
+  } else {
+    const banked = bankPull({
+      entry: { ...state.memory_facts ?? decision.entry, facts: registry3 },
+      complete,
+      watermark: bankArgs.watermark,
+      epochAtFetch: decision.epochAtFetch,
+      now: bankArgs.now
+    });
+    const { state: next, changed } = setMemoryFactsState(state, banked);
+    state = changed ? commitState(state, next) : state;
+    writeMarker(args, banked);
+    bankedFreshness = banked.freshness ?? "unknown";
+  }
   if (written > 0 || deleted > 0 || refused > 0) {
-    output?.log(`[MEMORY_FACTS ws=${workspaceSlug} facts=${facts.length} written=${written} deleted=${deleted} refused=${refused}]`);
+    output?.log(`[MEMORY_FACTS ws=${workspaceSlug} facts=${facts.length} written=${written} deleted=${deleted} refused=${refused} freshness=${bankedFreshness}]`);
+  }
+  return { state, written, deleted, refused, facts: facts.length, pulled: true };
+}
+function writeMarker(args, entry2) {
+  try {
+    writeFreshnessMarkerIfChanged({
+      workspaceSlug: args.workspaceSlug,
+      entry: entry2,
+      suppressor: args.suppressor
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    args.output?.log(`[MEMORY_FACTS marker_unwritten reason=${msg}]`);
   }
-  return { state, written, deleted, refused, facts: facts.length };
 }
 function writeFact(args, pile, slug, content) {
   const abs = memoryFactFilePath(args.workspaceSlug, pile, slug);
@@ -36595,8 +37437,14 @@ function classifyMemoryFactEvent(args) {
     return { kind: "ignore" };
   if (args.ownEcho)
     return { kind: "echo" };
+  if (args.kind === "unlink") {
+    return args.path.fact !== null && args.known ? { kind: "deleted", relPath: args.path.relPath, pile: args.path.fact.pile } : { kind: "ignore" };
+  }
   if (args.kind !== "upsert")
     return { kind: "ignore" };
+  if (args.path.relPath === memoryFreshnessRelPath()) {
+    return { kind: "marker", relPath: args.path.relPath };
+  }
   if (args.path.fact !== null && args.known) {
     return { kind: "generated", relPath: args.path.relPath, pile: args.path.fact.pile };
   }
@@ -36606,6 +37454,12 @@ function memoryFactEventWarning(v) {
   if (v.kind === "generated") {
     return `${v.relPath} is generated from a memory fact - your edit will be replaced ` + `on the next sync and kept in your conflicts folder. Change the fact with ` + `${factToolsFor(v.pile)}.`;
   }
+  if (v.kind === "deleted") {
+    return `${v.relPath} is generated from a memory fact - deleting the file does not ` + `delete the fact, so it will be written again on the next sync. Remove the ` + `fact itself with ${factToolsFor(v.pile)}.`;
+  }
+  if (v.kind === "marker") {
+    return `${v.relPath} is generated - it reports whether this machine's copy of ` + `your memory facts is up to date. Your edit will be replaced on the next ` + `sync and is not kept.`;
+  }
   if (v.kind === "unowned") {
     return `${v.relPath} is not synced: \`memory/\` holds files Plinth generates from ` + `memory facts. Put your own notes in \`files/\` instead.`;
   }
@@ -36743,7 +37597,7 @@ class FileDestructiveGate {
 }
 
 // src/lib/files/reconcile.ts
-import { readFileSync as readFileSync19, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync20, statSync as statSync10 } from "node:fs";
 
 // src/lib/unsynced.ts
 import { join as join13, relative as relative8 } from "node:path";
@@ -38777,7 +39631,7 @@ function readBlobForPush(args) {
   }
   let bytes;
   try {
-    bytes = readFileSync19(absolutePath);
+    bytes = readFileSync20(absolutePath);
   } catch (err) {
     if (err?.code === "ENOENT")
       return { kind: "gone" };
@@ -39377,6 +40231,1353 @@ async function reconcileArtistMemory(args) {
 // src/commands/start.ts
 init_output();
 
+// src/lib/memory/revalidate-api.ts
+var ROUTE2 = "/api/sync/memory/revalidate";
+var REVALIDATE_MAX_IDS_PER_ARM = 500;
+var REVALIDATE_TIMEOUT_MS = 20000;
+var SuccessorSchema = exports_external.object({
+  id: exports_external.string(),
+  slug: exports_external.string(),
+  description: exports_external.string().nullish(),
+  body_md: exports_external.string().nullish(),
+  assertion_revision: exports_external.number().nullish(),
+  support_revision: exports_external.number().nullish()
+});
+var WithheldSchema = exports_external.object({ withheld: exports_external.literal(true) });
+var StaleDependencySchema = exports_external.object({
+  store: exports_external.string(),
+  fact_id: exports_external.string(),
+  slug: exports_external.string(),
+  status: exports_external.string(),
+  evidential_status: exports_external.string().nullish(),
+  retired: exports_external.boolean().nullish(),
+  recorded_assertion_revision: exports_external.number().nullish(),
+  assertion_revision: exports_external.number().nullish(),
+  recorded_support_revision: exports_external.number().nullish(),
+  support_revision: exports_external.number().nullish(),
+  trail_outcome: exports_external.string().nullish(),
+  successor: SuccessorSchema.nullish()
+});
+var ProjectionSchema = exports_external.object({
+  projection_kind: exports_external.string().nullish(),
+  projection_id: exports_external.string().nullish(),
+  state: exports_external.string(),
+  state_revision: exports_external.number().nullish(),
+  retryable: exports_external.boolean().nullish(),
+  invalidated_at: exports_external.string().nullish(),
+  invalidated_by: exports_external.union([WithheldSchema, exports_external.object({ store: exports_external.string(), fact_id: exports_external.string() })]).nullish(),
+  refreshed_at: exports_external.string().nullish(),
+  refresh_attempts: exports_external.number().nullish(),
+  last_refresh_failed_at: exports_external.string().nullish(),
+  dependencies_not_current: exports_external.array(exports_external.union([WithheldSchema, StaleDependencySchema])).nullish()
+});
+var CorrectionSchema = exports_external.object({
+  store: exports_external.string(),
+  fact_id: exports_external.string(),
+  slug: exports_external.string(),
+  status: exports_external.string(),
+  evidential_status: exports_external.string().nullish(),
+  retired: exports_external.boolean().nullish(),
+  evidence_id: exports_external.string(),
+  heading_or_span: exports_external.string().nullish(),
+  excerpt: exports_external.string().nullish(),
+  redacted: exports_external.boolean().nullish(),
+  trail_outcome: exports_external.string().nullish(),
+  successor: SuccessorSchema.nullish()
+});
+var CorrectionsFieldSchema = exports_external.object({
+  coverage: exports_external.string(),
+  items: exports_external.array(CorrectionSchema)
+});
+var RevalidatedDocumentSchema = exports_external.object({
+  id: exports_external.string(),
+  projection: ProjectionSchema.nullish(),
+  corrections: CorrectionsFieldSchema.nullish()
+});
+var RevalidatedWorkspaceFileSchema = exports_external.object({
+  id: exports_external.string(),
+  corrections: CorrectionsFieldSchema.nullish()
+});
+var RevalidateEnvelopeSchema = exports_external.object({
+  documents: exports_external.array(exports_external.unknown()).nullish(),
+  workspace_files: exports_external.array(exports_external.unknown()).nullish(),
+  unavailable: exports_external.array(exports_external.string()).nullish()
+});
+function canonicaliseIds(ids) {
+  const seen = new Set;
+  const out = [];
+  for (const raw of ids) {
+    const id = raw.toLowerCase();
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    out.push(id);
+  }
+  return out;
+}
+function chunkRevalidateBatches(args) {
+  const max = args.max ?? REVALIDATE_MAX_IDS_PER_ARM;
+  const docs = canonicaliseIds(args.documents);
+  const files = canonicaliseIds(args.workspaceFiles);
+  const batches = [];
+  const count = Math.max(Math.ceil(docs.length / max), Math.ceil(files.length / max));
+  for (let i = 0;i < count; i++) {
+    const documents = docs.slice(i * max, (i + 1) * max);
+    const workspace_files = files.slice(i * max, (i + 1) * max);
+    if (documents.length === 0 && workspace_files.length === 0)
+      continue;
+    batches.push({ documents, workspace_files });
+  }
+  return batches;
+}
+function classifyStatus(status) {
+  if (status === 401 || status === 403)
+    return "unauthorised";
+  if (status === 429)
+    return "rate_limited";
+  if (status === 503)
+    return "unavailable";
+  if (status >= 400 && status < 500)
+    return "bad_request";
+  return "server_error";
+}
+async function revalidateMemorySources(args) {
+  const { baseUrl, pat, fetchImpl = fetch } = args;
+  const timeoutMs = args.timeoutMs ?? REVALIDATE_TIMEOUT_MS;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE2}`;
+  const documents = canonicaliseIds(args.documents);
+  const workspace_files = canonicaliseIds(args.workspaceFiles);
+  if (documents.length === 0 && workspace_files.length === 0) {
+    return { ok: true, documents: [], workspace_files: [], unavailable: [] };
+  }
+  const payload = {};
+  if (documents.length > 0)
+    payload.documents = documents;
+  if (workspace_files.length > 0)
+    payload.workspace_files = workspace_files;
+  const controller = new AbortController;
+  const deadline = setTimeout(() => {
+    controller.abort();
+  }, timeoutMs);
+  let res;
+  try {
+    res = await fetchImpl(url2, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${pat}`,
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+  } catch {
+    return { ok: false, reason: "offline", status: 0 };
+  } finally {
+    clearTimeout(deadline);
+  }
+  if (!res.ok) {
+    const reason = classifyStatus(res.status);
+    const retryAfterMs = res.status === 429 ? parseRetryAfterMs(res.headers.get("retry-after")) ?? await retryAfterFromBody(res) : undefined;
+    return { ok: false, reason, status: res.status, retryAfterMs };
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return { ok: false, reason: "malformed", status: res.status };
+  }
+  const parsed = RevalidateEnvelopeSchema.safeParse(body);
+  if (!parsed.success) {
+    return { ok: false, reason: "malformed", status: res.status };
+  }
+  const keepValid = (rows, schema) => {
+    const out = [];
+    for (const row of rows ?? []) {
+      const one = schema.safeParse(row);
+      if (one.success)
+        out.push(one.data);
+    }
+    return out;
+  };
+  return {
+    ok: true,
+    documents: keepValid(parsed.data.documents, RevalidatedDocumentSchema),
+    workspace_files: keepValid(parsed.data.workspace_files, RevalidatedWorkspaceFileSchema),
+    unavailable: parsed.data.unavailable ?? []
+  };
+}
+async function retryAfterFromBody(res) {
+  try {
+    const body = await res.json();
+    const seconds = body?.retry_after_seconds;
+    if (typeof seconds === "number" && Number.isFinite(seconds) && seconds >= 0) {
+      return Math.round(seconds * 1000);
+    }
+  } catch {}
+  return;
+}
+
+// src/lib/memory/revalidate.ts
+function sourceAnswerChanged(before, after) {
+  if (before === undefined)
+    return true;
+  if (before.state !== after.state)
+    return true;
+  if (before.state_revision !== after.state_revision)
+    return true;
+  if (before.corrections_hash !== after.corrections_hash)
+    return true;
+  return before.rendered !== after.rendered;
+}
+function correctionsDigest(items) {
+  if (items === null)
+    return null;
+  const sorted = [...items].sort((a, b) => a.evidence_id < b.evidence_id ? -1 : a.evidence_id > b.evidence_id ? 1 : 0);
+  return stableHash(sorted);
+}
+function toEntry(args) {
+  const { id, annotation } = args;
+  const lines = renderAnnotationLines(annotation);
+  return {
+    id,
+    state: annotation.state,
+    state_revision: annotation.stateRevision,
+    retryable: annotation.retryable,
+    corrections_hash: correctionsDigest(annotation.corrections),
+    corrections_count: annotation.corrections?.length ?? null,
+    checked_at: annotation.checkedAt,
+    rendered: lines.join(`
+`)
+  };
+}
+function withoutStamp(rendered) {
+  return rendered.split(`
+`).filter((l) => !l.startsWith("memory_checked_at:")).join(`
+`);
+}
+function sameAnswer(prior, next) {
+  if (prior === undefined)
+    return false;
+  return prior.state === next.state && prior.state_revision === next.state_revision && prior.corrections_hash === next.corrections_hash && withoutStamp(prior.rendered) === withoutStamp(next.rendered);
+}
+function answer(args) {
+  let entry2 = toEntry({ id: args.id, annotation: args.annotation });
+  if (args.prior !== undefined && sameAnswer(args.prior, entry2)) {
+    entry2 = toEntry({
+      id: args.id,
+      annotation: { ...args.annotation, checkedAt: args.prior.checked_at }
+    });
+  }
+  return {
+    arm: args.arm,
+    id: args.id,
+    entry: entry2,
+    lines: entry2.rendered === "" ? [] : entry2.rendered.split(`
+`)
+  };
+}
+function decideFromOutcome(args) {
+  const { outcome, now } = args;
+  const checkedAt = now.toISOString();
+  const answers = [];
+  if (!outcome.ok) {
+    for (const id of args.askedDocuments) {
+      answers.push({
+        ...answer({
+          arm: "documents",
+          id,
+          annotation: unknownAnnotation(args.priorDocuments[id]?.checked_at ?? null),
+          prior: args.priorDocuments[id]
+        })
+      });
+    }
+    for (const id of args.askedWorkspaceFiles) {
+      answers.push({
+        ...answer({
+          arm: "workspace_files",
+          id,
+          annotation: unknownAnnotation(args.priorWorkspaceFiles[id]?.checked_at ?? null, "workspace_file"),
+          prior: args.priorWorkspaceFiles[id]
+        })
+      });
+    }
+    return { answers, unavailable: [], served: false };
+  }
+  const docById = new Map(outcome.documents.map((d) => [d.id.toLowerCase(), d]));
+  const fileById = new Map(outcome.workspace_files.map((f) => [f.id.toLowerCase(), f]));
+  for (const id of args.askedDocuments) {
+    const served = docById.get(id);
+    if (served === undefined) {
+      answers.push(answer({
+        arm: "documents",
+        id,
+        annotation: unknownAnnotation(args.priorDocuments[id]?.checked_at ?? null),
+        prior: args.priorDocuments[id]
+      }));
+      continue;
+    }
+    answers.push(answer({
+      arm: "documents",
+      id,
+      annotation: annotationForDocument({
+        projection: served.projection,
+        corrections: served.corrections,
+        checkedAt
+      }),
+      prior: args.priorDocuments[id]
+    }));
+  }
+  for (const id of args.askedWorkspaceFiles) {
+    const served = fileById.get(id);
+    if (served === undefined) {
+      answers.push(answer({
+        arm: "workspace_files",
+        id,
+        annotation: unknownAnnotation(args.priorWorkspaceFiles[id]?.checked_at ?? null, "workspace_file"),
+        prior: args.priorWorkspaceFiles[id]
+      }));
+      continue;
+    }
+    answers.push(answer({
+      arm: "workspace_files",
+      id,
+      annotation: annotationForWorkspaceFile({
+        corrections: served.corrections,
+        checkedAt
+      }),
+      prior: args.priorWorkspaceFiles[id]
+    }));
+  }
+  return { answers, unavailable: outcome.unavailable, served: true };
+}
+async function runRevalidate(args) {
+  const now = args.now ?? (() => new Date);
+  const batches = chunkRevalidateBatches({
+    documents: args.documentIds,
+    workspaceFiles: args.workspaceFileIds
+  });
+  const answers = [];
+  const unavailable = new Set;
+  let anyServed = false;
+  for (const batch of batches) {
+    const outcome = await revalidateMemorySources({
+      baseUrl: args.baseUrl,
+      pat: args.pat,
+      documents: batch.documents,
+      workspaceFiles: batch.workspace_files,
+      fetchImpl: args.fetchImpl
+    });
+    const decided = decideFromOutcome({
+      outcome,
+      askedDocuments: batch.documents,
+      askedWorkspaceFiles: batch.workspace_files,
+      priorDocuments: args.priorDocuments,
+      priorWorkspaceFiles: args.priorWorkspaceFiles,
+      now: now()
+    });
+    answers.push(...decided.answers);
+    for (const u of decided.unavailable)
+      unavailable.add(u);
+    if (decided.served)
+      anyServed = true;
+    if (!outcome.ok && outcome.reason === "rate_limited") {
+      args.output?.log(`[MEMORY_REVALIDATE rate_limited retry_after_ms=${outcome.retryAfterMs ?? "unset"} remaining_batches=${batches.length - batches.indexOf(batch) - 1}]`);
+      for (const later of batches.slice(batches.indexOf(batch) + 1)) {
+        const rest = decideFromOutcome({
+          outcome,
+          askedDocuments: later.documents,
+          askedWorkspaceFiles: later.workspace_files,
+          priorDocuments: args.priorDocuments,
+          priorWorkspaceFiles: args.priorWorkspaceFiles,
+          now: now()
+        });
+        answers.push(...rest.answers);
+      }
+      break;
+    }
+  }
+  const changed = answers.filter((a) => sourceAnswerChanged(a.arm === "documents" ? args.priorDocuments[a.id] : args.priorWorkspaceFiles[a.id], a.entry));
+  return {
+    answers,
+    changed,
+    unavailable: [...unavailable].sort(),
+    whollyUnknown: !anyServed && answers.length > 0
+  };
+}
+function degradeAllToUnknown(args) {
+  const answers = [];
+  const docIds = new Set([
+    ...Object.keys(args.priorDocuments),
+    ...args.heldDocumentIds ?? []
+  ]);
+  const fileIds = new Set([
+    ...Object.keys(args.priorWorkspaceFiles),
+    ...args.heldWorkspaceFileIds ?? []
+  ]);
+  for (const id of docIds) {
+    answers.push(answer({
+      arm: "documents",
+      id,
+      annotation: unknownAnnotation(args.priorDocuments[id]?.checked_at ?? null)
+    }));
+  }
+  for (const id of fileIds) {
+    answers.push(answer({
+      arm: "workspace_files",
+      id,
+      annotation: unknownAnnotation(args.priorWorkspaceFiles[id]?.checked_at ?? null, "workspace_file")
+    }));
+  }
+  const changed = answers.filter((a) => sourceAnswerChanged(a.arm === "documents" ? args.priorDocuments[a.id] : args.priorWorkspaceFiles[a.id], a.entry));
+  return { answers, changed, unavailable: [], whollyUnknown: answers.length > 0 };
+}
+function applyDecision(args) {
+  const documents = { ...args.prior?.documents ?? {} };
+  const workspace_files = { ...args.prior?.workspace_files ?? {} };
+  for (const a of args.decision.answers) {
+    if (args.unwritten?.has(`${a.arm}:${a.id}`))
+      continue;
+    if (a.arm === "documents")
+      documents[a.id] = a.entry;
+    else
+      workspace_files[a.id] = a.entry;
+  }
+  return {
+    polled_at: args.polledAt,
+    ask_failed_at: args.askFailedAt ?? null,
+    write_interrupted: args.prior?.write_interrupted,
+    unwritten: args.prior?.unwritten,
+    documents,
+    workspace_files
+  };
+}
+function pruneUnheld(args) {
+  const held = {
+    documents: new Set(args.documentIds.map((i) => i.toLowerCase())),
+    workspace_files: new Set(args.workspaceFileIds.map((i) => i.toLowerCase()))
+  };
+  const keep = (arm) => Object.fromEntries(Object.entries(args.state[arm]).filter(([id]) => held[arm].has(id)));
+  return {
+    polled_at: args.state.polled_at,
+    ask_failed_at: args.state.ask_failed_at ?? null,
+    write_interrupted: args.state.write_interrupted,
+    unwritten: args.state.unwritten,
+    documents: keep("documents"),
+    workspace_files: keep("workspace_files")
+  };
+}
+function shouldRevalidate(args) {
+  if (args.anyUnknown) {
+    if (args.askFailedAt === undefined || args.askFailedAt === null)
+      return true;
+    const failed = Date.parse(args.askFailedAt);
+    if (Number.isNaN(failed))
+      return true;
+    return args.now.getTime() - failed >= (args.unknownRetryMs ?? UNKNOWN_RETRY_MS);
+  }
+  if (args.polledAt === undefined)
+    return true;
+  const last = Date.parse(args.polledAt);
+  if (Number.isNaN(last))
+    return true;
+  return args.now.getTime() - last >= args.intervalMs;
+}
+var UNKNOWN_RETRY_MS = 60000;
+function anyUnknown(state) {
+  if (state === undefined)
+    return false;
+  const isUnknown = (e) => e.state === "unknown";
+  return Object.values(state.documents).some(isUnknown) || Object.values(state.workspace_files).some(isUnknown);
+}
+
+// src/lib/memory/write.ts
+import { readFileSync as readFileSync21, statSync as statSync11 } from "node:fs";
+
+// src/lib/files/extracted-text.ts
+import { createHash as createHash4 } from "node:crypto";
+var DERIVED_TEXT_VERSION = 2;
+function yamlString3(value) {
+  return JSON.stringify(value);
+}
+var PARTIAL_WARNING = [
+  "> ⚠️ **PARTIAL EXTRACTION.** Some spans of this document came out as text and",
+  "> some did not. Which spans is NOT recorded, so this could be a clean document",
+  "> with mangled party names, or clean prose that degrades part-way through.",
+  "> Verify anything load-bearing against the source file."
+].join(`
+`);
+var NO_LOCAL_COPY_NOTE = [
+  "> ℹ️ **NO LOCAL COPY OF THIS FILE.** Plinth does not hold this file's bytes, so",
+  "> nothing was written under `files/` for it and the text below is the only copy",
+  "> in this mirror. The original lives wherever `source_uri` above points."
+].join(`
+`);
+function garbledBody(relPath, bytesInMirror) {
+  return [
+    "> \uD83D\uDD34 **NOT TEXT — body withheld.**",
+    ">",
+    "> Extraction produced characters that are not words. The usual cause is a PDF",
+    "> whose embedded fonts carry no ToUnicode map, so the glyph indices come out",
+    "> where the letters should be: a page reading *“Dated this 10th day of",
+    "> September”* extracts as `):-,:019`.",
+    ">",
+    "> The characters are NOT reproduced here on purpose. They read as text to a",
+    "> reader and to a search index, and they say nothing — writing them into the",
+    "> mirror would put a document into your corpus that appears readable and is",
+    "> not. They are excluded from Plinth's own search index for the same reason.",
+    ">",
+    bytesInMirror ? `> **Read the original instead:** \`files/${relPath}\`` : "> **There is no local original to read** — Plinth holds no bytes for this file." + " Follow `source_uri` above to the copy that has them."
+  ].join(`
+`);
+}
+function renderExtractedText(doc2) {
+  const withheld = doc2.quality === "garbled";
+  const frontmatter = [
+    "---",
+    "plinth_generated: true",
+    `source_file: ${doc2.bytesInMirror ? yamlString3(`files/${doc2.relPath}`) : "null"}`,
+    `source_uri: ${doc2.sourceUri === undefined ? "unknown" : doc2.sourceUri === null ? "null" : yamlString3(doc2.sourceUri)}`,
+    `content_quality: ${doc2.quality ?? "unchecked"}`,
+    `body_withheld: ${withheld}`,
+    `extracted_chars: ${withheld ? 0 : doc2.text.length}`,
+    "---",
+    "",
+    "<!-- Generated by Plinth from the source file above. This file is DERIVED:",
+    "     your edits here are overwritten on the next sync and are never uploaded.",
+    "     Edit the source file instead. -->",
+    ""
+  ].join(`
+`);
+  if (withheld) {
+    return `${frontmatter}${garbledBody(doc2.relPath, doc2.bytesInMirror)}
+`;
+  }
+  const notices = [
+    ...doc2.quality === "partial" ? [PARTIAL_WARNING] : [],
+    ...doc2.bytesInMirror ? [] : [NO_LOCAL_COPY_NOTE]
+  ];
+  if (notices.length > 0) {
+    return `${frontmatter}${notices.join(`
+
+`)}
+
+${doc2.text}
+`;
+  }
+  return `${frontmatter}${doc2.text}
+`;
+}
+function extractedTextHash(rendered) {
+  return createHash4("sha256").update(rendered, "utf8").digest("hex");
+}
+
+// src/lib/memory/splice.ts
+var import_gray_matter11 = __toESM(require_gray_matter(), 1);
+var OPEN_RE = /^---\r?\n/;
+function findFrontmatter(content) {
+  const open2 = OPEN_RE.exec(content);
+  if (!open2)
+    return null;
+  const start = open2[0].length;
+  const closeRe = /\r?\n---[ \t]*(\r?\n|$)/;
+  const rest = content.slice(start);
+  const close = closeRe.exec(rest);
+  if (!close)
+    return null;
+  return {
+    start,
+    end: start + close.index,
+    text: rest.slice(0, close.index)
+  };
+}
+function isAnnotationKeyLine(line) {
+  for (const key of MEMORY_ANNOTATION_KEYS) {
+    if (line.startsWith(`${key}:`))
+      return true;
+  }
+  return false;
+}
+function isContinuation(line) {
+  return /^[ \t]+\S/.test(line) || line.trimEnd() === "";
+}
+function stripAnnotation(lines) {
+  const out = [];
+  let dropping = false;
+  let pendingBlanks = [];
+  for (const line of lines) {
+    if (isAnnotationKeyLine(line)) {
+      dropping = true;
+      pendingBlanks = [];
+      continue;
+    }
+    if (dropping) {
+      if (line.trimEnd() === "") {
+        pendingBlanks.push(line);
+        continue;
+      }
+      if (isContinuation(line)) {
+        pendingBlanks = [];
+        continue;
+      }
+      dropping = false;
+      out.push(...pendingBlanks);
+      pendingBlanks = [];
+    }
+    out.push(line);
+  }
+  return out;
+}
+function spliceAnnotation(content, lines) {
+  const fm = findFrontmatter(content);
+  if (fm === null)
+    return { content, changed: false };
+  const existing = fm.text.split(`
+`);
+  const kept = stripAnnotation(existing);
+  const memberBlanks = [];
+  while (kept.length > 0 && kept[kept.length - 1].trimEnd() === "") {
+    memberBlanks.unshift(kept.pop());
+  }
+  const eol = fm.text.includes(`\r
+`) || content.startsWith(`---\r
+`) ? `\r
+` : `
+`;
+  const withEol = (l) => eol === `\r
+` && !l.endsWith("\r") ? `${l}\r` : l;
+  const next = lines.length === 0 ? [...kept, ...memberBlanks] : [...kept, ...memberBlanks, ...lines.map((l) => withEol(l))];
+  const nextText = next.join(`
+`);
+  if (nextText === fm.text)
+    return { content, changed: false };
+  const out = content.slice(0, fm.start) + nextText + content.slice(fm.end);
+  if (!parsesAsFrontmatter(out) || bodyAfterFrontmatter(out) !== bodyAfterFrontmatter(content)) {
+    return { content, changed: false };
+  }
+  return { content: out, changed: out !== content };
+}
+function parsesAsFrontmatter(content) {
+  try {
+    import_gray_matter11.default(content, { cache: false });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function bodyAfterFrontmatter(content) {
+  const fm = findFrontmatter(content);
+  if (fm === null)
+    return content;
+  const rest = content.slice(fm.end);
+  const close = /^\r?\n---[ \t]*(\r?\n|$)/.exec(rest);
+  return close ? rest.slice(close[0].length) : rest;
+}
+
+// src/lib/memory/write.ts
+function writeDocumentAnnotation(args) {
+  const strategy = getStrategy("documents");
+  if (strategy === undefined)
+    return { kind: "absent" };
+  let target;
+  try {
+    target = entityFilePath(args.workspaceSlug, "documents", args.slug);
+  } catch {
+    return { kind: "absent" };
+  }
+  let current;
+  try {
+    current = readFileSync21(target, "utf8");
+  } catch {
+    return { kind: "absent" };
+  }
+  const before = computeMirrorHashes(strategy, current);
+  if (before.bodyHash !== args.entry.body_hash || before.frontmatterHash !== args.entry.frontmatter_hash) {
+    return { kind: "diverged", relPath: strategy.mirrorRelativePath(args.slug) };
+  }
+  const spliced = spliceAnnotation(current, args.lines);
+  if (!spliced.changed)
+    return { kind: "unchanged" };
+  const after = computeMirrorHashes(strategy, spliced.content);
+  args.suppressor?.registerWrite(target, {
+    bodyHash: after.bodyHash,
+    frontmatterHash: after.frontmatterHash
+  });
+  writeMirrorFile(args.workspaceSlug, "documents", args.slug, spliced.content);
+  return { kind: "written" };
+}
+function inodeAfterWrite(workspaceSlug, entityType, slug) {
+  try {
+    return statSync11(entityFilePath(workspaceSlug, entityType, slug)).ino;
+  } catch {
+    return;
+  }
+}
+function onDiskTextHash(workspaceSlug, relPath) {
+  try {
+    const current = readExtractedText(workspaceSlug, relPath);
+    return current === null ? undefined : extractedTextHash(current);
+  } catch {
+    return;
+  }
+}
+function writeFileTextAnnotation(args) {
+  const current = readExtractedText(args.workspaceSlug, args.relPath);
+  if (current === null)
+    return { kind: "absent" };
+  if (args.textHash !== undefined && extractedTextHash(current) !== args.textHash) {
+    return { kind: "diverged", relPath: extractedTextRelPath(args.relPath) };
+  }
+  const spliced = spliceAnnotation(current, args.lines);
+  if (!spliced.changed)
+    return { kind: "unchanged" };
+  writeExtractedText(args.workspaceSlug, args.relPath, spliced.content);
+  return { kind: "written", textHash: extractedTextHash(spliced.content) };
+}
+function divergedNotice(relPath, state) {
+  return `${relPath}: its memory context is now "${state}", but the file has local ` + `edits so the marker was not written into it. Your edits are untouched. ` + `Resolve the edit and the next sync writes the marker.`;
+}
+function unreadableNotice(relPath, why) {
+  const reason = why.replace(/\s+/g, " ").trim().slice(0, 120);
+  return `${relPath}: its memory context could not be written because the file's ` + `frontmatter could not be read (${reason}). The file is untouched. Fix the ` + `frontmatter and the next sync writes the marker.`;
+}
+
+// src/lib/memory/lane.ts
+var DEFAULT_REVALIDATE_INTERVAL_MS = 300000;
+function revalidateIntervalMs() {
+  const raw = process.env.PLINTH_REVALIDATE_INTERVAL_MS;
+  if (raw !== undefined) {
+    const n = Number(raw);
+    if (Number.isFinite(n) && n > 0)
+      return n;
+  }
+  return DEFAULT_REVALIDATE_INTERVAL_MS;
+}
+var EMPTY = { documents: {}, workspace_files: {} };
+function heldDocuments(state) {
+  const entries = state.entries["documents"] ?? {};
+  return Object.values(entries).map((e) => ({ id: e.id.toLowerCase(), slug: e.slug }));
+}
+function heldFileTexts(state) {
+  const files = state.files ?? {};
+  return Object.values(files).filter((f) => f.text_hash !== undefined).map((f) => ({
+    id: f.id.toLowerCase(),
+    relPath: f.path,
+    textHash: f.text_hash
+  }));
+}
+async function writeChanged(args) {
+  const docs = new Map(heldDocuments(args.state).map((d) => [d.id, d.slug]));
+  const texts = new Map(heldFileTexts(args.state).map((f) => [f.id, f]));
+  let written = 0;
+  let diverged = 0;
+  const notices = [];
+  const textHashes = new Map;
+  const inodes = new Map;
+  const unwritten = new Set;
+  const report = [];
+  const clear = [];
+  for (const answer2 of args.changed) {
+    if (args.abortIfStale?.() === true) {
+      args.output?.log("[MEMORY_REVALIDATE stopped reason=poll_failed_mid_write]");
+      return { written, diverged, notices, textHashes, inodes, unwritten, report, clear, aborted: true };
+    }
+    if (answer2.arm === "documents") {
+      const slug = docs.get(answer2.id);
+      if (slug === undefined) {
+        unwritten.add(`documents:${answer2.id}`);
+        continue;
+      }
+      const entryAt = (state) => Object.values(state.entries["documents"] ?? {}).find((e) => e.id.toLowerCase() === answer2.id);
+      const entry2 = entryAt(args.state);
+      if (entry2 === undefined) {
+        unwritten.add(`documents:${answer2.id}`);
+        continue;
+      }
+      let outcome2;
+      try {
+        const under = await args.mutex.run(entry2.id, () => {
+          if (args.abortIfStale?.() === true)
+            return Promise.resolve("stale");
+          const fresh = args.getState !== undefined ? entryAt(args.getState()) : undefined;
+          const res = writeDocumentAnnotation({
+            workspaceSlug: args.workspaceSlug,
+            slug,
+            entry: fresh ?? entry2,
+            lines: answer2.lines,
+            suppressor: args.suppressor,
+            output: args.output
+          });
+          if (res.kind === "written") {
+            res.inode = inodeAfterWrite(args.workspaceSlug, "documents", slug);
+          }
+          if (res.kind !== "diverged" && res.kind !== "absent") {
+            args.onWritten?.("documents", answer2.id);
+          }
+          return Promise.resolve(res);
+        });
+        if (under === "stale") {
+          args.output?.log("[MEMORY_REVALIDATE stopped reason=poll_failed_in_lock]");
+          return { written, diverged, notices, textHashes, inodes, unwritten, report, clear, aborted: true };
+        }
+        outcome2 = under;
+      } catch (err) {
+        unwritten.add(`documents:${answer2.id}`);
+        const why = err instanceof Error ? err.message : String(err);
+        args.output?.log(`memory: could not annotate ${slug} (${why})`);
+        report.push({
+          path: getStrategy("documents").mirrorRelativePath(slug),
+          record: unreadableNotice(getStrategy("documents").mirrorRelativePath(slug), why)
+        });
+        continue;
+      }
+      if (outcome2.kind === "diverged" || outcome2.kind === "absent") {
+        unwritten.add(`documents:${answer2.id}`);
+      }
+      const docPath = getStrategy("documents").mirrorRelativePath(slug);
+      if (outcome2.kind === "diverged") {
+        report.push({ path: docPath, record: divergedNotice(docPath, answer2.entry.state) });
+      } else {
+        clear.push(docPath);
+      }
+      if (outcome2.kind === "written") {
+        written++;
+        if (outcome2.inode !== undefined) {
+          inodes.set(entry2.id, { slug, to: outcome2.inode });
+        }
+      } else if (outcome2.kind === "diverged") {
+        diverged++;
+        notices.push(divergedNotice(outcome2.relPath, answer2.entry.state));
+      }
+      continue;
+    }
+    const file2 = texts.get(answer2.id);
+    if (file2 === undefined) {
+      unwritten.add(`workspace_files:${answer2.id}`);
+      continue;
+    }
+    let outcome;
+    try {
+      const under = await args.mutex.run(`files:${file2.relPath}`, () => {
+        if (args.abortIfStale?.() === true)
+          return Promise.resolve("stale");
+        const res = writeFileTextAnnotation({
+          workspaceSlug: args.workspaceSlug,
+          relPath: file2.relPath,
+          textHash: args.freshTextHashes?.get(answer2.id) ?? file2.textHash,
+          lines: answer2.lines
+        });
+        if (res.kind !== "diverged" && res.kind !== "absent") {
+          args.onWritten?.("workspace_files", answer2.id, res.textHash);
+        }
+        return Promise.resolve(res);
+      });
+      if (under === "stale") {
+        args.output?.log("[MEMORY_REVALIDATE stopped reason=poll_failed_in_lock]");
+        return { written, diverged, notices, textHashes, inodes, unwritten, report, clear, aborted: true };
+      }
+      outcome = under;
+    } catch (err) {
+      unwritten.add(`workspace_files:${answer2.id}`);
+      const why = err instanceof Error ? err.message : String(err);
+      args.output?.log(`memory: could not annotate ${file2.relPath} (${why})`);
+      report.push({
+        path: extractedTextRelPath(file2.relPath),
+        record: unreadableNotice(extractedTextRelPath(file2.relPath), why)
+      });
+      continue;
+    }
+    if (outcome.kind === "diverged" || outcome.kind === "absent") {
+      unwritten.add(`workspace_files:${answer2.id}`);
+    }
+    const textPath = extractedTextRelPath(file2.relPath);
+    if (outcome.kind === "diverged") {
+      report.push({ path: textPath, record: divergedNotice(textPath, answer2.entry.state) });
+    } else {
+      clear.push(textPath);
+    }
+    if (outcome.kind === "written") {
+      written++;
+      if (outcome.textHash !== undefined) {
+        textHashes.set(file2.relPath, { to: outcome.textHash });
+      }
+    } else if (outcome.kind === "diverged") {
+      diverged++;
+      notices.push(divergedNotice(outcome.relPath, answer2.entry.state));
+    }
+  }
+  if (args.abortIfStale?.() === true) {
+    args.output?.log("[MEMORY_REVALIDATE stopped reason=poll_failed_after_write]");
+    return { written, diverged, notices, textHashes, inodes, unwritten, report, clear, aborted: true };
+  }
+  return { written, diverged, notices, textHashes, inodes, unwritten, report, clear, aborted: false };
+}
+function commit(args) {
+  const { state, changed } = setMemorySourcesState(args.state, args.next);
+  if (!changed && args.state === args.base)
+    return args.base;
+  return args.commitState(args.base, state);
+}
+async function revalidateTick(args) {
+  const now = args.now ?? (() => new Date);
+  const held = args.state.memory_sources ?? EMPTY;
+  const documents = heldDocuments(args.state);
+  const fileTexts = heldFileTexts(args.state);
+  if (documents.length === 0 && fileTexts.length === 0) {
+    return {
+      state: args.state,
+      written: 0,
+      diverged: 0,
+      notices: [],
+      unavailable: [],
+      ran: false
+    };
+  }
+  if (!shouldRevalidate({
+    polledAt: held.polled_at,
+    intervalMs: args.intervalMs ?? revalidateIntervalMs(),
+    now: now(),
+    anyUnknown: anyUnknown(held),
+    askFailedAt: held.ask_failed_at
+  })) {
+    return {
+      state: args.state,
+      written: 0,
+      diverged: 0,
+      notices: [],
+      unavailable: [],
+      ran: false
+    };
+  }
+  const decision = await runRevalidate({
+    baseUrl: args.baseUrl,
+    pat: args.pat,
+    documentIds: documents.map((d) => d.id),
+    workspaceFileIds: fileTexts.map((f) => f.id),
+    priorDocuments: getMemorySourceEntries(args.state, "documents"),
+    priorWorkspaceFiles: getMemorySourceEntries(args.state, "workspace_files"),
+    fetchImpl: args.fetchImpl,
+    now,
+    output: args.output
+  });
+  if (args.abortIfStale?.() === true) {
+    args.output?.log("[MEMORY_REVALIDATE dropped reason=poll_failed_in_flight]");
+    return {
+      state: args.state,
+      written: 0,
+      diverged: 0,
+      notices: [],
+      unavailable: [],
+      ran: false
+    };
+  }
+  return await settle({
+    ...args,
+    decision,
+    now,
+    clearInterrupted: true,
+    documents,
+    fileTexts,
+    held,
+    askFailedAt: decision.whollyUnknown ? now().toISOString() : null
+  });
+}
+async function degradeTick(args) {
+  const now = args.now ?? (() => new Date);
+  const held = args.state.memory_sources ?? EMPTY;
+  const interrupted = held.write_interrupted === true;
+  const sweep = interrupted;
+  const unbankedDocs = args.unbanked?.documents ?? [];
+  const unbankedFiles = (args.unbanked?.workspaceFiles ?? []).map((f) => f.id);
+  const freshTextHashes = new Map;
+  for (const f of args.unbanked?.workspaceFiles ?? []) {
+    if (f.textHash !== undefined)
+      freshTextHashes.set(f.id, f.textHash);
+  }
+  const decision = degradeAllToUnknown({
+    priorDocuments: held.documents,
+    priorWorkspaceFiles: held.workspace_files,
+    heldDocumentIds: sweep ? heldDocuments(args.state).map((d) => d.id) : unbankedDocs,
+    heldWorkspaceFileIds: sweep ? heldFileTexts(args.state).map((f) => f.id) : unbankedFiles
+  });
+  if (decision.changed.length === 0 && !sweep) {
+    return {
+      state: args.state,
+      written: 0,
+      diverged: 0,
+      notices: [],
+      unavailable: [],
+      ran: decision.answers.length > 0
+    };
+  }
+  return await settle({
+    ...args,
+    decision,
+    now,
+    freshTextHashes,
+    documents: heldDocuments(args.state),
+    fileTexts: heldFileTexts(args.state),
+    held,
+    keepPolledAt: true,
+    clearInterrupted: sweep
+  });
+}
+function nextUnwritten(args) {
+  const out = {};
+  const gone = new Set(args.cleared);
+  for (const [path5, rec] of Object.entries(args.prior ?? {})) {
+    if (!args.reachable.has(path5) || gone.has(path5))
+      continue;
+    out[path5] = rec;
+  }
+  for (const r of args.reported) {
+    const prior = out[r.path];
+    out[r.path] = prior !== undefined && prior.message === r.record ? prior : { path: r.path, message: r.record, recorded_at: args.now().toISOString() };
+  }
+  if (Object.keys(out).length === 0)
+    return args.prior === undefined ? undefined : {};
+  return out;
+}
+async function settle(args) {
+  const writes = await writeChanged({
+    onWritten: args.onWritten,
+    freshTextHashes: args.freshTextHashes,
+    workspaceSlug: args.workspaceSlug,
+    state: args.state,
+    abortIfStale: args.abortIfStale,
+    changed: args.decision.answers,
+    mutex: args.mutex,
+    suppressor: args.suppressor,
+    output: args.output,
+    getState: args.getState
+  });
+  const liveHeldNow = args.getState?.().memory_sources ?? args.held;
+  let state = args.state;
+  if (writes.textHashes.size > 0 || writes.inodes.size > 0) {
+    const files = { ...state.files ?? {} };
+    for (const [relPath, hash2] of writes.textHashes) {
+      const existing = files[relPath];
+      if (existing === undefined)
+        continue;
+      if (onDiskTextHash(args.workspaceSlug, relPath) !== hash2.to)
+        continue;
+      files[relPath] = { ...existing, text_hash: hash2.to };
+    }
+    const documents = { ...state.entries["documents"] ?? {} };
+    for (const [id, ino] of writes.inodes) {
+      const existing = documents[id];
+      if (existing === undefined)
+        continue;
+      if (inodeAfterWrite(args.workspaceSlug, "documents", ino.slug) !== ino.to)
+        continue;
+      documents[id] = { ...existing, inode: ino.to };
+    }
+    state = {
+      ...state,
+      files,
+      entries: { ...state.entries, documents }
+    };
+  }
+  if (writes.aborted) {
+    const abortedRecords = nextUnwritten({
+      prior: liveHeldNow.unwritten,
+      reachable: new Set([
+        ...args.documents.map((d) => getStrategy("documents").mirrorRelativePath(d.slug)),
+        ...args.fileTexts.map((f) => extractedTextRelPath(f.relPath))
+      ]),
+      cleared: writes.clear,
+      reported: writes.report,
+      now: args.now
+    });
+    return {
+      state: commit({
+        base: args.state,
+        state,
+        next: { ...liveHeldNow, write_interrupted: true, unwritten: abortedRecords },
+        commitState: args.commitState
+      }),
+      written: writes.written,
+      diverged: writes.diverged,
+      notices: writes.notices,
+      unavailable: args.decision.unavailable,
+      ran: false
+    };
+  }
+  const unwrittenRecords = nextUnwritten({
+    prior: liveHeldNow.unwritten,
+    reachable: new Set([
+      ...args.documents.map((d) => getStrategy("documents").mirrorRelativePath(d.slug)),
+      ...args.fileTexts.map((f) => extractedTextRelPath(f.relPath))
+    ]),
+    cleared: writes.clear,
+    reported: writes.report,
+    now: args.now
+  });
+  const applied = applyDecision({
+    unwritten: writes.unwritten,
+    askFailedAt: args.askFailedAt !== undefined ? args.askFailedAt : liveHeldNow.ask_failed_at,
+    prior: liveHeldNow,
+    decision: args.decision,
+    polledAt: args.keepPolledAt ? liveHeldNow.polled_at ?? args.now().toISOString() : args.now().toISOString()
+  });
+  const pruned = pruneUnheld({
+    state: {
+      ...args.clearInterrupted === true ? { ...applied, write_interrupted: false } : applied,
+      unwritten: unwrittenRecords
+    },
+    documentIds: args.documents.map((d) => d.id),
+    workspaceFileIds: args.fileTexts.map((f) => f.id)
+  });
+  const committed = commit({
+    base: args.state,
+    state,
+    next: pruned,
+    commitState: args.commitState
+  });
+  if (writes.written > 0 || writes.diverged > 0 || args.decision.unavailable.length > 0) {
+    args.output?.log(`[MEMORY_${args.keepPolledAt === true ? "DEGRADE" : "REVALIDATE"} ` + `ws=${args.workspaceSlug} sources=${args.decision.answers.length} ` + `written=${writes.written} diverged=${writes.diverged} ` + `unavailable=${args.decision.unavailable.join(",") || "none"}]`);
+  }
+  return {
+    state: committed,
+    written: writes.written,
+    diverged: writes.diverged,
+    notices: writes.notices,
+    unavailable: args.decision.unavailable,
+    ran: true
+  };
+}
+function memoryLaneCallback(args) {
+  let revalidating = false;
+  let pollFailures = 0;
+  const pending = new Set;
+  let inFlight = null;
+  const withdraw = async (stamped) => {
+    const degradeBase = args.getState();
+    try {
+      const degraded = await degradeTick({
+        workspaceSlug: args.workspaceSlug,
+        state: degradeBase,
+        mutex: args.mutex,
+        commitState: args.commitState,
+        now: args.now,
+        suppressor: args.suppressor,
+        output: args.output,
+        getState: args.getState,
+        unbanked: {
+          documents: [...stamped?.documents ?? []],
+          workspaceFiles: [...stamped?.workspaceFiles ?? []].map(([id, textHash]) => ({
+            id,
+            textHash
+          }))
+        }
+      });
+      args.setState(rebaseState(args.getState(), degradeBase, degraded.state));
+      for (const notice of degraded.notices)
+        args.warn(notice);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      args.output?.log(`[MEMORY_DEGRADE failed reason=${msg}]`);
+    }
+  };
+  const run = async (ok) => {
+    if (!ok) {
+      pollFailures++;
+      await withdraw(inFlight);
+      return;
+    }
+    if (revalidating)
+      return;
+    revalidating = true;
+    const written = {
+      documents: new Set,
+      workspaceFiles: new Map
+    };
+    inFlight = written;
+    const failuresAtStart = pollFailures;
+    try {
+      const revalidateBase = args.getState();
+      const result = await revalidateTick({
+        workspaceSlug: args.workspaceSlug,
+        baseUrl: args.baseUrl,
+        pat: args.pat,
+        state: revalidateBase,
+        mutex: args.mutex,
+        commitState: args.commitState,
+        fetchImpl: args.fetchImpl,
+        now: args.now,
+        intervalMs: args.intervalMs,
+        suppressor: args.suppressor,
+        output: args.output,
+        getState: args.getState,
+        abortIfStale: () => pollFailures !== failuresAtStart,
+        onWritten: (arm, id, textHash) => {
+          if (arm === "documents")
+            written.documents.add(id);
+          else
+            written.workspaceFiles.set(id, textHash);
+        }
+      });
+      args.setState(rebaseState(args.getState(), revalidateBase, result.state));
+      for (const notice of result.notices)
+        args.warn(notice);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      args.output?.log(`[MEMORY_REVALIDATE failed reason=${msg}]`);
+    } finally {
+      revalidating = false;
+      inFlight = null;
+    }
+  };
+  const callback = (ok) => {
+    const p = run(ok).finally(() => {
+      pending.delete(p);
+    });
+    pending.add(p);
+  };
+  callback.settled = async () => {
+    while (pending.size > 0)
+      await Promise.all([...pending]);
+  };
+  return callback;
+}
+
+// src/lib/memory-facts/freshness.ts
+var ROUTE3 = "/api/sync/memory-facts/freshness";
+var FRESHNESS_DEADLINE_MS = 20000;
+var FreshnessBodySchema = exports_external.object({
+  behind: exports_external.boolean(),
+  watermark: FeedWatermarkSchema.nullish()
+});
+var CodeBodySchema = exports_external.object({ code: exports_external.string().nullish() });
+async function checkFactFreshness(args) {
+  const { baseUrl, pat, snapshot, fetchImpl = fetch } = args;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE3}?watermark=${encodeURIComponent(snapshot)}`;
+  let res;
+  try {
+    res = await fetchImpl(url2, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${pat}`, Accept: "application/json" },
+      signal: args.signal ? AbortSignal.any([args.signal, AbortSignal.timeout(FRESHNESS_DEADLINE_MS)]) : AbortSignal.timeout(FRESHNESS_DEADLINE_MS)
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "network error";
+    return { kind: "failed", message: msg };
+  }
+  if (res.status === 429) {
+    let fromBody = null;
+    try {
+      const body2 = await res.json();
+      const seconds = body2?.retry_after_seconds;
+      if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0) {
+        fromBody = Math.round(seconds * 1000);
+      }
+    } catch {}
+    return {
+      kind: "rate_limited",
+      retryAfterMs: fromBody ?? parseRetryAfterMs(res.headers.get("retry-after")) ?? null
+    };
+  }
+  if (res.status === 400 || res.status === 503) {
+    let code = null;
+    try {
+      const body2 = await res.json();
+      code = CodeBodySchema.safeParse(body2).data?.code ?? null;
+    } catch {}
+    if (code === "bad_watermark")
+      return { kind: "bad_watermark" };
+    if (code === "watermark_unavailable")
+      return { kind: "unavailable" };
+    return {
+      kind: "failed",
+      message: `freshness check failed with HTTP ${res.status}`
+    };
+  }
+  if (!res.ok) {
+    return {
+      kind: "failed",
+      message: `freshness check failed with HTTP ${res.status}`
+    };
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return { kind: "failed", message: "freshness response was not JSON" };
+  }
+  const parsed = FreshnessBodySchema.safeParse(body);
+  if (!parsed.success) {
+    return {
+      kind: "failed",
+      message: "freshness response did not match the expected shape"
+    };
+  }
+  return {
+    kind: "answer",
+    behind: parsed.data.behind,
+    watermark: parsed.data.behind ? null : parsed.data.watermark ?? null
+  };
+}
+
+// src/lib/memory-facts/freshness-gate.ts
+function createFactFreshnessGate(args) {
+  const now = args.now ?? (() => new Date);
+  const mutate = (fn) => {
+    const before = args.getState();
+    const entry2 = before.memory_facts ?? emptyFactsEntry(now().toISOString());
+    const next = fn(entry2);
+    const { state, changed } = setMemoryFactsState(before, next);
+    if (changed) {
+      const committed = args.commitState(before, state);
+      args.setState(rebaseState(args.getState(), before, committed));
+    }
+    try {
+      writeFreshnessMarkerIfChanged({
+        workspaceSlug: args.workspaceSlug,
+        entry: next,
+        suppressor: args.suppressor
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      args.output?.log(`[MEMORY_FACTS marker_unwritten reason=${msg}]`);
+    }
+    return next;
+  };
+  return {
+    onPollFailed() {
+      mutate(withdrawClaim);
+    },
+    async decide(at) {
+      const withFloor = (e) => floorDue(e, at, args.floorMs) ? raisePullReason(e, "floor_due") : e;
+      const working = withFloor(args.getState().memory_facts ?? emptyFactsEntry(at.toISOString()));
+      if (!mayAsk(working, at)) {
+        return pullDecision(mutate(withFloor), null);
+      }
+      let verdict;
+      try {
+        verdict = await checkFactFreshness({
+          baseUrl: args.baseUrl,
+          pat: args.pat,
+          snapshot: working.watermark.snapshot,
+          fetchImpl: args.fetchImpl
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        verdict = { kind: "failed", message: msg };
+      }
+      return pullDecision(mutate((live) => applyVerdict(withFloor(live), verdict, at)), verdict);
+    },
+    bank(a) {
+      mutate((live) => bankPull({
+        entry: { ...live, facts: a.registry },
+        complete: a.complete,
+        watermark: a.watermark,
+        epochAtFetch: a.epochAtFetch,
+        now: a.now
+      }));
+    }
+  };
+}
+
 // src/lib/pull-loop.ts
 var DEFAULT_PULL_INTERVAL_MS = 15000;
 var PULL_BACKOFF_CAP_MS = 300000;
@@ -39391,11 +41592,29 @@ function pullIntervalMs() {
   }
   return DEFAULT_PULL_INTERVAL_MS;
 }
+function composeAfterPollOutcome(...arms) {
+  const composed = (ok) => {
+    for (const arm of arms) {
+      try {
+        arm(ok);
+      } catch {}
+    }
+  };
+  composed.settled = async () => {
+    for (const arm of arms) {
+      try {
+        await arm.settled?.();
+      } catch {}
+    }
+  };
+  return composed;
+}
 
 class PullLoop {
   runOnce;
   onApplied;
   afterPoll;
+  afterPollOutcome;
   notice;
   loginHint;
   intervalMs;
@@ -39414,6 +41633,7 @@ class PullLoop {
     this.runOnce = deps.runOnce;
     this.onApplied = deps.onApplied;
     this.afterPoll = deps.afterPoll;
+    this.afterPollOutcome = deps.afterPollOutcome;
     this.notice = deps.notice;
     this.loginHint = deps.loginHint;
     this.intervalMs = deps.intervalMs ?? pullIntervalMs();
@@ -39463,10 +41683,12 @@ class PullLoop {
       this.onApplied(result.applied);
     }
     this.afterPoll();
+    this.afterPollOutcome?.(true);
     return this.intervalMs;
   }
   onFailure(failure) {
     const kind = failure?.kind ?? "transient";
+    this.afterPollOutcome?.(false);
     if (kind === "auth") {
       if (!this.authAnnounced) {
         this.authAnnounced = true;
@@ -39862,7 +42084,7 @@ var OWNERSHIP_NOTE2 = [
 `);
 var DEFAULT_USER_LABEL = "the Plinth account this mirror syncs with";
 var FULL_BAND_DAYS = 14;
-function yamlString2(value) {
+function yamlString4(value) {
   return JSON.stringify(value);
 }
 function oneLine2(value, maxLength = 200) {
@@ -39955,14 +42177,14 @@ function windowLine(timeMin, timeMax) {
   return `${formatDay(from, -1)} to ${formatDay(to, -1)}`;
 }
 function statusLine(args) {
-  const { status, eventCount, error: error52, truncated, stamp, userLabel } = args;
+  const { status, eventCount, error: error52, truncated, stamp: stamp2, userLabel } = args;
   switch (status) {
     case "fetched": {
       if (eventCount === 0) {
-        return `**Read fine as of ${stamp}. Nothing in this window.** The diary really ` + `is clear across the dates above. This is a successful read of an empty ` + `calendar, not a failed read - if it had failed, this line would say so.`;
+        return `**Read fine as of ${stamp2}. Nothing in this window.** The diary really ` + `is clear across the dates above. This is a successful read of an empty ` + `calendar, not a failed read - if it had failed, this line would say so.`;
       }
       const truncatedNote = truncated ? " **This list is INCOMPLETE**: Google had more entries than one page and the rest were not collected." : "";
-      return `**Read fine as of ${stamp}.** ${eventCount} ` + `${eventCount === 1 ? "entry" : "entries"} in the window.${truncatedNote}`;
+      return `**Read fine as of ${stamp2}.** ${eventCount} ` + `${eventCount === 1 ? "entry" : "entries"} in the window.${truncatedNote}`;
     }
     case "no-token":
       return `**NOT READ - Google is not connected for ${userLabel}.** Nothing is listed ` + `below because Plinth could not look, NOT because the diary is clear. ` + `Connect Google in Plinth to fill this in, and until then treat this ` + `calendar as unknown rather than empty.`;
@@ -40010,19 +42232,19 @@ function renderArtistCalendar(args) {
   const { row, generatedAt, window: window2 } = args;
   const userLabel = args.userLabel ?? DEFAULT_USER_LABEL;
   const events = row.events ?? [];
-  const stamp = humanStamp(generatedAt);
+  const stamp2 = humanStamp(generatedAt);
   const referenceYear = new Date(Date.parse(generatedAt) || 0).getUTCFullYear();
   const title = rowDisplayName(row);
   const header = [
     "---",
     "plinth_generated: true",
     "view: calendar",
-    `artist_slug: ${row.artist_slug === null ? "null" : yamlString2(row.artist_slug)}`,
-    `artist_name: ${row.artist_name === null ? "null" : yamlString2(row.artist_name)}`,
-    `calendar_name: ${yamlString2(row.calendar_name)}`,
-    `generated_at: ${yamlString2(generatedAt)}`,
-    `window_start: ${yamlString2(window2.time_min)}`,
-    `window_end: ${yamlString2(window2.time_max)}`,
+    `artist_slug: ${row.artist_slug === null ? "null" : yamlString4(row.artist_slug)}`,
+    `artist_name: ${row.artist_name === null ? "null" : yamlString4(row.artist_name)}`,
+    `calendar_name: ${yamlString4(row.calendar_name)}`,
+    `generated_at: ${yamlString4(generatedAt)}`,
+    `window_start: ${yamlString4(window2.time_min)}`,
+    `window_end: ${yamlString4(window2.time_max)}`,
     `status: ${row.status}`,
     "fetch_state: fresh",
     `entry_count: ${events.length}`,
@@ -40042,7 +42264,7 @@ function renderArtistCalendar(args) {
       eventCount: events.length,
       error: row.error,
       truncated: row.truncated,
-      stamp,
+      stamp: stamp2,
       userLabel
     }),
     "",
@@ -40089,7 +42311,7 @@ function renderUpcoming(args) {
     mappedArtistCount,
     internalName
   } = args;
-  const stamp = humanStamp(generatedAt);
+  const stamp2 = humanStamp(generatedAt);
   const referenceYear = new Date(Date.parse(generatedAt) || 0).getUTCFullYear();
   const fetched = rows.filter((r) => r.status === "fetched");
   const failed = rows.filter((r) => r.status !== "fetched");
@@ -40103,9 +42325,9 @@ function renderUpcoming(args) {
     "plinth_generated: true",
     "view: calendar",
     "scope: workspace",
-    `generated_at: ${yamlString2(generatedAt)}`,
-    `window_start: ${yamlString2(window2.time_min)}`,
-    `window_end: ${yamlString2(window2.time_max)}`,
+    `generated_at: ${yamlString4(generatedAt)}`,
+    `window_start: ${yamlString4(window2.time_min)}`,
+    `window_end: ${yamlString4(window2.time_max)}`,
     `artist_count: ${artistCount}`,
     `mapped_artist_count: ${mappedArtistCount}`,
     `calendars_read: ${fetched.length}`,
@@ -40122,7 +42344,7 @@ function renderUpcoming(args) {
 `);
   const preamble = [
     "",
-    `**As of ${stamp}.** Window ${windowLine(window2.time_min, window2.time_max)}.`,
+    `**As of ${stamp2}.** Window ${windowLine(window2.time_min, window2.time_max)}.`,
     "",
     failed.length === 0 ? `**All ${fetched.length} mapped ${fetched.length === 1 ? "calendar was" : "calendars were"} read.**` : `**${fetched.length} of ${rows.length} mapped ${rows.length === 1 ? "calendar" : "calendars"} read; ${failed.length} could NOT be read.**` + ` Anything on an unread calendar is missing from the lists below - unknown, not absent.`,
     "",
@@ -40196,13 +42418,13 @@ function renderStaleFile(existing, args) {
   const fmMatch = /^---\n([\s\S]*?)\n---\n/.exec(split.header);
   const carried = (fmMatch?.[1] ?? "").split(`
 `).filter((line) => !/^(fetch_state|last_refresh_attempt|last_refresh_error):/.test(line));
-  const stamp = previousGeneratedAt ? humanStamp(previousGeneratedAt) : "an earlier refresh";
+  const stamp2 = previousGeneratedAt ? humanStamp(previousGeneratedAt) : "an earlier refresh";
   const header = [
     "---",
     ...carried,
     "fetch_state: stale",
-    `last_refresh_attempt: ${yamlString2(args.attemptedAt)}`,
-    `last_refresh_error: ${yamlString2(oneLine2(args.reason, 300))}`,
+    `last_refresh_attempt: ${yamlString4(args.attemptedAt)}`,
+    `last_refresh_error: ${yamlString4(oneLine2(args.reason, 300))}`,
     "---",
     "",
     OWNERSHIP_NOTE2,
@@ -40211,7 +42433,7 @@ function renderStaleFile(existing, args) {
     "",
     `**STALE - the last refresh FAILED and nothing below was updated.** Attempted ` + `${humanStamp(args.attemptedAt)} and it did not succeed: ` + `${oneLine2(args.reason, 300)}`,
     "",
-    `**What is below was last read at ${stamp}** and has not moved since. Anything ` + `changed in Google after that is not here, and something cancelled after that ` + `is still listed. Say the age out loud rather than briefing it as current.`,
+    `**What is below was last read at ${stamp2}** and has not moved since. Anything ` + `changed in Google after that is not here, and something cancelled after that ` + `is still listed. Say the age out loud rather than briefing it as current.`,
     ""
   ].join(`
 `);
@@ -40396,8 +42618,8 @@ class PullSuppressor {
 }
 
 // src/lib/discover-entities.ts
-var import_gray_matter11 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
+var import_gray_matter12 = __toESM(require_gray_matter(), 1);
+import { readFileSync as readFileSync22, statSync as statSync12 } from "node:fs";
 var DISCOVERY_WRITE_CAP_DEFAULT = 10;
 function discoveryWriteCap() {
   const raw = process.env.PLINTH_DISCOVERY_WRITE_CAP;
@@ -40431,7 +42653,7 @@ function classifyRenameDestination(args) {
   }
   return { kind: "rename" };
 }
-var EMPTY = {
+var EMPTY2 = {
   discovered: 0,
   created: 0,
   collisions: 0,
@@ -40467,7 +42689,7 @@ function planDiscoveryWrites(args) {
       continue;
     let liveInode;
     try {
-      liveInode = statSync11(absolutePath).ino;
+      liveInode = statSync12(absolutePath).ino;
     } catch {
       continue;
     }
@@ -40496,7 +42718,7 @@ function planDiscoveryWrites(args) {
     counts.discovered++;
     let frontmatter;
     try {
-      frontmatter = import_gray_matter11.default(readFileSync20(absolutePath, "utf8")).data ?? {};
+      frontmatter = import_gray_matter12.default(readFileSync22(absolutePath, "utf8")).data ?? {};
     } catch {
       counts.discovered--;
       continue;
@@ -40517,7 +42739,7 @@ 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 };
+  const counts = { ...EMPTY2 };
   let mirrorRootPath;
   try {
     mirrorRootPath = workspaceMirrorPath(workspaceSlug);
@@ -40537,7 +42759,7 @@ async function discoverUntrackedEntities(args) {
   } 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 };
+    return { state, ...EMPTY2 };
   }
   const cap = discoveryWriteCap();
   const creates = planned.filter((w) => w.kind === "create");
@@ -40724,8 +42946,8 @@ function recordDiscoveryFailure(args) {
 }
 
 // src/lib/frontmatter-id-backfill.ts
-var import_gray_matter12 = __toESM(require_gray_matter(), 1);
-import { readFileSync as readFileSync21, statSync as statSync12 } from "node:fs";
+var import_gray_matter13 = __toESM(require_gray_matter(), 1);
+import { readFileSync as readFileSync23, statSync as statSync13 } from "node:fs";
 var FRONTMATTER_ID_BACKFILL_VERSION = 1;
 function backfillWorthReporting(r) {
   return r.written > 0 || r.failed > 0 || r.skipped.foreignId > 0 || r.skipped.unwritable > 0 || r.skipped.slugCollision > 0;
@@ -40760,7 +42982,7 @@ function heldByAnyBatch(workspaceSlug) {
 }
 function safeInode3(path5) {
   try {
-    return statSync12(path5).ino;
+    return statSync13(path5).ino;
   } catch {
     return;
   }
@@ -40768,7 +42990,7 @@ function safeInode3(path5) {
 function backfillFrontmatterIds(args) {
   const { workspaceSlug, state } = args;
   const compose = args.compose ?? withFrontmatterId;
-  const readRaw = args.readFile ?? ((p) => readFileSync21(p, "utf8"));
+  const readRaw = args.readFile ?? ((p) => readFileSync23(p, "utf8"));
   const result = emptyResult();
   if (state.frontmatter_id_backfill_version === FRONTMATTER_ID_BACKFILL_VERSION) {
     return result;
@@ -40817,7 +43039,7 @@ function backfillFrontmatterIds(args) {
       let rawBody;
       let parsedData;
       try {
-        const parsed = import_gray_matter12.default(raw);
+        const parsed = import_gray_matter13.default(raw);
         parsedData = parsed.data ?? {};
         existing = parsedData["id"];
         rawBody = parsed.content;
@@ -40896,7 +43118,7 @@ function backfillFrontmatterIds(args) {
 }
 
 // src/lib/reconcile.ts
-import { readFileSync as readFileSync22, statSync as statSync13 } from "node:fs";
+import { readFileSync as readFileSync24, statSync as statSync14 } from "node:fs";
 async function reconcileDivergedRows(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl, output, isFrozen } = args;
   const now = args.now ?? (() => new Date);
@@ -40995,7 +43217,7 @@ async function reconcileDivergedRows(args) {
       }
       let liveInode;
       try {
-        liveInode = statSync13(absolutePath).ino;
+        liveInode = statSync14(absolutePath).ino;
       } catch {
         liveInode = undefined;
       }
@@ -41008,7 +43230,7 @@ async function reconcileDivergedRows(args) {
       }
       let content;
       try {
-        content = readFileSync22(absolutePath, "utf8");
+        content = readFileSync24(absolutePath, "utf8");
       } catch (err) {
         if (err?.code === "ENOENT") {
           state = clearEntityCloudRowDeleted(state, strategy.mirrorRelativePath(entry2.slug));
@@ -41128,10 +43350,10 @@ var PreconditionSchema2 = exports_external.object({
 function baseHeaders3(pat) {
   return { Authorization: `Bearer ${pat}`, Accept: "application/json" };
 }
-var ROUTE2 = "/api/sync/workspace-rules";
+var ROUTE4 = "/api/sync/workspace-rules";
 async function getWorkspaceRules(args) {
   const { baseUrl, pat, fetchImpl = fetch } = args;
-  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE2}`;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE4}`;
   let res;
   try {
     res = await fetchImpl(url2, { method: "GET", headers: baseHeaders3(pat) });
@@ -41157,7 +43379,7 @@ async function getWorkspaceRules(args) {
 }
 async function putWorkspaceRules(args) {
   const { baseUrl, pat, bodyMd, expectedUpdatedAt, fetchImpl = fetch } = args;
-  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE2}`;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE4}`;
   const headers = {
     ...baseHeaders3(pat),
     "Content-Type": "application/json"
@@ -41415,10 +43637,10 @@ var PreconditionSchema3 = exports_external.object({
 function baseHeaders4(pat) {
   return { Authorization: `Bearer ${pat}`, Accept: "application/json" };
 }
-var ROUTE3 = "/api/sync/workspace-memory";
+var ROUTE5 = "/api/sync/workspace-memory";
 async function getWorkspaceMemory(args) {
   const { baseUrl, pat, fetchImpl = fetch } = args;
-  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE3}`;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE5}`;
   let res;
   try {
     res = await fetchImpl(url2, { method: "GET", headers: baseHeaders4(pat) });
@@ -41444,7 +43666,7 @@ async function getWorkspaceMemory(args) {
 }
 async function putWorkspaceMemory(args) {
   const { baseUrl, pat, bodyMd, expectedUpdatedAt, fetchImpl = fetch } = args;
-  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE3}`;
+  const url2 = `${baseUrl.replace(/\/$/, "")}${ROUTE5}`;
   const headers = {
     ...baseHeaders4(pat),
     "Content-Type": "application/json"
@@ -42360,8 +44582,8 @@ function createThrottledFetch(baseFetch, opts = {}) {
 import {
   existsSync as existsSync8,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync25,
-  statSync as statSync16,
+  readFileSync as readFileSync27,
+  statSync as statSync17,
   unlinkSync as unlinkSync8
 } from "node:fs";
 import { join as join17 } from "node:path";
@@ -42544,87 +44766,8 @@ function refreshConflictsView(workspaceSlug) {
 }
 
 // src/lib/files/pull.ts
-import { existsSync as existsSync7, readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
-
-// src/lib/files/extracted-text.ts
-import { createHash as createHash4 } from "node:crypto";
-var DERIVED_TEXT_VERSION = 2;
-function yamlString3(value) {
-  return JSON.stringify(value);
-}
-var PARTIAL_WARNING = [
-  "> ⚠️ **PARTIAL EXTRACTION.** Some spans of this document came out as text and",
-  "> some did not. Which spans is NOT recorded, so this could be a clean document",
-  "> with mangled party names, or clean prose that degrades part-way through.",
-  "> Verify anything load-bearing against the source file."
-].join(`
-`);
-var NO_LOCAL_COPY_NOTE = [
-  "> ℹ️ **NO LOCAL COPY OF THIS FILE.** Plinth does not hold this file's bytes, so",
-  "> nothing was written under `files/` for it and the text below is the only copy",
-  "> in this mirror. The original lives wherever `source_uri` above points."
-].join(`
-`);
-function garbledBody(relPath, bytesInMirror) {
-  return [
-    "> \uD83D\uDD34 **NOT TEXT — body withheld.**",
-    ">",
-    "> Extraction produced characters that are not words. The usual cause is a PDF",
-    "> whose embedded fonts carry no ToUnicode map, so the glyph indices come out",
-    "> where the letters should be: a page reading *“Dated this 10th day of",
-    "> September”* extracts as `):-,:019`.",
-    ">",
-    "> The characters are NOT reproduced here on purpose. They read as text to a",
-    "> reader and to a search index, and they say nothing — writing them into the",
-    "> mirror would put a document into your corpus that appears readable and is",
-    "> not. They are excluded from Plinth's own search index for the same reason.",
-    ">",
-    bytesInMirror ? `> **Read the original instead:** \`files/${relPath}\`` : "> **There is no local original to read** — Plinth holds no bytes for this file." + " Follow `source_uri` above to the copy that has them."
-  ].join(`
-`);
-}
-function renderExtractedText(doc2) {
-  const withheld = doc2.quality === "garbled";
-  const frontmatter = [
-    "---",
-    "plinth_generated: true",
-    `source_file: ${doc2.bytesInMirror ? yamlString3(`files/${doc2.relPath}`) : "null"}`,
-    `source_uri: ${doc2.sourceUri === undefined ? "unknown" : doc2.sourceUri === null ? "null" : yamlString3(doc2.sourceUri)}`,
-    `content_quality: ${doc2.quality ?? "unchecked"}`,
-    `body_withheld: ${withheld}`,
-    `extracted_chars: ${withheld ? 0 : doc2.text.length}`,
-    "---",
-    "",
-    "<!-- Generated by Plinth from the source file above. This file is DERIVED:",
-    "     your edits here are overwritten on the next sync and are never uploaded.",
-    "     Edit the source file instead. -->",
-    ""
-  ].join(`
-`);
-  if (withheld) {
-    return `${frontmatter}${garbledBody(doc2.relPath, doc2.bytesInMirror)}
-`;
-  }
-  const notices = [
-    ...doc2.quality === "partial" ? [PARTIAL_WARNING] : [],
-    ...doc2.bytesInMirror ? [] : [NO_LOCAL_COPY_NOTE]
-  ];
-  if (notices.length > 0) {
-    return `${frontmatter}${notices.join(`
-
-`)}
-
-${doc2.text}
-`;
-  }
-  return `${frontmatter}${doc2.text}
-`;
-}
-function extractedTextHash(rendered) {
-  return createHash4("sha256").update(rendered, "utf8").digest("hex");
-}
-
-// src/lib/files/pull.ts
+import { existsSync as existsSync7, lstatSync as lstatSync4, readFileSync as readFileSync25, statSync as statSync15 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 async function pullFiles(args) {
   const { workspaceSlug, baseUrl, pat, fetchImpl } = args;
   let state = args.state;
@@ -42636,6 +44779,7 @@ async function pullFiles(args) {
   let textUnknown = 0;
   let pointerRows = 0;
   let symlinkRefused = 0;
+  let stashFailed = 0;
   let cursor = args.cursor;
   let lastCursor = args.cursor;
   let cursorBlocked = false;
@@ -42657,7 +44801,8 @@ async function pullFiles(args) {
         suppressor: args.suppressor,
         isFileFrozen: args.isFileFrozen,
         loggedTombstoneSkips: args.loggedTombstoneSkips,
-        forceTextRewalk: args.forceTextRewalk
+        forceTextRewalk: args.forceTextRewalk,
+        loggedStashNotices: args.loggedStashNotices
       });
       state = outcome.state;
       if (!outcome.symlinkRefused) {
@@ -42679,6 +44824,10 @@ async function pullFiles(args) {
         symlinkRefused++;
         pageTextFailed = true;
       }
+      if (outcome.stashFailed) {
+        stashFailed++;
+        pageTextFailed = true;
+      }
     }
     if (args.commit && state !== pageBase)
       state = args.commit(pageBase, state);
@@ -42699,6 +44848,9 @@ async function pullFiles(args) {
   if (symlinkRefused > 0) {
     args.output?.warn(`${symlinkRefused} file ${symlinkRefused === 1 ? "row was" : "rows were"} left alone because a symlink sits on the path under files/ — syncing ${symlinkRefused === 1 ? "it" : "them"} would read or write outside your Plinth folder. Run \`plinth status\` to see which. Replace the link with a real folder or file and the next sync picks ${symlinkRefused === 1 ? "it" : "them"} up.`);
   }
+  if (stashFailed > 0) {
+    args.output?.warn(`${stashFailed} file ${stashFailed === 1 ? "was" : "were"} not updated from Plinth because the local copy could not be kept first — see the FILE_STASH_FAILED ${stashFailed === 1 ? "line" : "lines"}. Nothing local was replaced; the next sync tries again.`);
+  }
   return {
     state,
     fetched,
@@ -42709,6 +44861,7 @@ async function pullFiles(args) {
     textUnknown,
     pointerRows,
     symlinkRefused,
+    stashFailed,
     lastCursor
   };
 }
@@ -42722,7 +44875,16 @@ async function applyExtractedText(args) {
   }
 }
 async function materialiseExtractedText(args) {
-  const { workspaceSlug, baseUrl, pat, row, relPath, bytesInMirror, fetchImpl, output } = args;
+  const {
+    workspaceSlug,
+    baseUrl,
+    pat,
+    row,
+    relPath,
+    bytesInMirror,
+    fetchImpl,
+    output
+  } = args;
   const signal = extractedTextSignal(row);
   if (signal === "absent") {
     const removed = deleteExtractedText(workspaceSlug, relPath);
@@ -42815,7 +44977,7 @@ async function applyFileRow(args) {
     }
     let localBytes;
     try {
-      localBytes = readFileSync23(abs);
+      localBytes = readFileSync25(abs);
     } catch {
       localBytes = undefined;
     }
@@ -42910,20 +45072,30 @@ async function applyFileRow(args) {
       output
     });
   }
-  if (!suppressor && existing && existing.content_hash !== row.content_hash && existsSync7(abs)) {
-    try {
-      const localBytes = readFileSync23(abs);
-      if (sha256Bytes(localBytes) !== existing.content_hash) {
-        const stashPath = stashFileConflict({ workspaceSlug, relPath, timestamp: now(), bytes: localBytes, side: "local" });
-        output?.warn(`Conflict on files/${relPath} → stashed local edit to ${stashPath} (cloud-wins on boot).`);
-      }
-    } catch {}
-  }
   const bytes = await downloadBytes(got.row.download_url, fetchImpl);
   if (sha256Bytes(bytes) !== row.content_hash) {
     output?.warn(`Integrity check failed for files/${relPath} (hash mismatch) — skipped this pull.`);
     return { state, action: "skipped" };
   }
+  const stashFailure = stashUnpushedLocalEdit({
+    workspaceSlug,
+    relPath,
+    abs,
+    existing,
+    rowHash: row.content_hash,
+    ambient: suppressor !== undefined,
+    now,
+    output,
+    loggedStashNotices: args.loggedStashNotices
+  });
+  if (stashFailure) {
+    const key = `failed:${relPath}:${stashFailure.reason}:${stashFailure.code ?? ""}`;
+    if (!args.loggedStashNotices?.has(key)) {
+      args.loggedStashNotices?.add(key);
+      output?.log(fileStashFailedLine({ path: relPath, ...stashFailure }));
+    }
+    return { state, action: "skipped", stashFailed: true };
+  }
   suppressor?.registerWrite(abs, { bodyHash: row.content_hash, frontmatterHash: "" });
   writeFilesBytes(workspaceSlug, relPath, bytes);
   let text;
@@ -42953,7 +45125,7 @@ async function applyFileRow(args) {
   }
   let inode;
   try {
-    inode = statSync14(abs).ino;
+    inode = statSync15(abs).ino;
   } catch {
     inode = undefined;
   }
@@ -43005,6 +45177,54 @@ async function applyPointerRow(args) {
     pointer: true
   };
 }
+function stashUnpushedLocalEdit(args) {
+  const { workspaceSlug, relPath, abs, existing, output } = args;
+  if (hasSymlinkedComponent(workspaceSlug, dirname12(abs)))
+    return { reason: "symlink" };
+  let st;
+  try {
+    st = lstatSync4(abs);
+  } catch (err) {
+    if (err?.code === "ENOENT")
+      return null;
+    return { reason: "unreadable", code: errCode(err) };
+  }
+  if (!st.isFile())
+    return { reason: "not_a_file" };
+  let localBytes;
+  try {
+    localBytes = readFileSync25(abs);
+  } catch (err) {
+    return { reason: "unreadable", code: errCode(err) };
+  }
+  const localHash = sha256Bytes(localBytes);
+  if (localHash === args.rowHash || localHash === existing?.content_hash)
+    return null;
+  let stashed;
+  try {
+    stashed = stashFileConflictOnce({
+      workspaceSlug,
+      relPath,
+      timestamp: args.now(),
+      bytes: localBytes,
+      side: "local"
+    });
+  } catch (err) {
+    return { reason: "stash_io", code: errCode(err) };
+  }
+  const key = `reused:${stashed.path}:${args.rowHash}`;
+  if (stashed.reused && args.loggedStashNotices?.has(key))
+    return null;
+  if (stashed.reused)
+    args.loggedStashNotices?.add(key);
+  output?.log(fileConflictLine({ path: relPath, stash: stashed.path, via: "pull", reused: stashed.reused }));
+  output?.warn(stashed.reused ? `Conflict on files/${relPath} → your local edit is already kept at ${stashed.path}.` : `Conflict on files/${relPath} → stashed local edit to ${stashed.path} (cloud-wins${args.ambient ? "" : " on boot"}).`);
+  return null;
+}
+function errCode(err) {
+  const code = err?.code;
+  return typeof code === "string" ? code : undefined;
+}
 function textIsCurrent(existing, row, workspaceSlug, relPath) {
   const signal = extractedTextSignal(row);
   if (signal === "unknown")
@@ -43021,7 +45241,7 @@ function textIsCurrent(existing, row, workspaceSlug, relPath) {
 }
 
 // src/lib/files/rejection-sync.ts
-import { readFileSync as readFileSync24, statSync as statSync15 } from "node:fs";
+import { readFileSync as readFileSync26, statSync as statSync16 } from "node:fs";
 
 // src/lib/files/rejections-api.ts
 var RejectionsFeedSchema = exports_external.object({
@@ -43141,7 +45361,7 @@ function settledDisposition(args) {
   }
   let size = null;
   try {
-    const st = statSync15(absolute2);
+    const st = statSync16(absolute2);
     size = st.isFile() ? st.size : null;
   } catch {
     size = null;
@@ -43154,7 +45374,7 @@ function settledDisposition(args) {
     return null;
   let bytes;
   try {
-    bytes = readFileSync24(absolute2);
+    bytes = readFileSync26(absolute2);
   } catch {
     return null;
   }
@@ -43270,7 +45490,7 @@ function unlinkIfProvablyOurs(workspaceSlug, strategy, entry2, suppressor) {
   }
   let raw;
   try {
-    raw = readFileSync25(target, "utf8");
+    raw = readFileSync27(target, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") {
       return { didUnlink: false };
@@ -43499,6 +45719,7 @@ async function runSync(workspaceSlug, deps = {}) {
       suppressor: deps.suppressor,
       isFileFrozen: deps.isFileFrozen,
       loggedTombstoneSkips: deps.loggedTombstoneSkips,
+      loggedStashNotices: deps.loggedStashNotices,
       commit: commitState,
       forceTextRewalk: needsDerivedTextRewalk
     });
@@ -43596,7 +45817,8 @@ async function runSync(workspaceSlug, deps = {}) {
       fetchImpl,
       now,
       output: out,
-      suppressor: deps.suppressor
+      suppressor: deps.suppressor,
+      gate: deps.factFreshnessGate
     });
     if (factsResult.state !== state) {
       state = factsResult.state;
@@ -43853,7 +46075,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   if (!suppressor && existingEntry && existingEntry.updated_at !== live.updated_at && relocation.kind !== "moved") {
     let localRaw = null;
     try {
-      localRaw = readFileSync25(entityFilePath(workspaceSlug, strategy.type, writeSlug), "utf8");
+      localRaw = readFileSync27(entityFilePath(workspaceSlug, strategy.type, writeSlug), "utf8");
     } catch {
       localRaw = null;
     }
@@ -43877,7 +46099,7 @@ function applyRow(workspaceSlug, strategy, row, state, out, suppressor, now = ()
   const hashes = computeMirrorHashes(strategy, content);
   let inode;
   try {
-    inode = statSync16(entityFilePath(workspaceSlug, strategy.type, writeSlug)).ino;
+    inode = statSync17(entityFilePath(workspaceSlug, strategy.type, writeSlug)).ino;
   } catch {
     inode = undefined;
   }
@@ -43978,7 +46200,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) => statSync17(p)) {
+function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync18(p)) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -44011,7 +46233,7 @@ function backfillStateInodes(workspaceSlug, state, statFn = (p) => statSync17(p)
     return { state, changed: false };
   return { state: { ...state, entries: nextEntries }, changed: true };
 }
-function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync26(p, "utf8")) {
+function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync28(p, "utf8")) {
   let changed = false;
   const nextEntries = {};
   for (const [entityType, bucket] of Object.entries(state.entries)) {
@@ -44023,7 +46245,7 @@ function backfillBodyLengths(workspaceSlug, state, readFn = (p) => readFileSync2
       }
       try {
         const path5 = entityFilePath(workspaceSlug, entityType, entry2.slug);
-        const bodyLen = import_gray_matter13.default(readFn(path5)).content.length;
+        const bodyLen = import_gray_matter14.default(readFn(path5)).content.length;
         nextBucket[id] = { ...entry2, body_len: bodyLen };
         changed = true;
       } catch {
@@ -44059,18 +46281,22 @@ function makeWatchHandler(deps) {
     applyState(base2, update(base2));
   };
   const handleFilesEvent = async (relPath, absolutePath, exists) => {
+    const eventOp = exists ? "upsert" : "delete";
     try {
-      if (isFileFrozen?.(relPath))
+      if (isFileFrozen?.(relPath)) {
+        output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "frozen" }));
         return;
+      }
       try {
         filesSubtreePath(workspaceSlug, relPath);
       } catch (err) {
         if (!(err instanceof MirrorSymlinkError))
           throw err;
+        output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "symlink" }));
         applyFromCurrent((base2) => recordFileSymlinkRefused({
           state: base2,
           relPath,
-          op: exists ? "upsert" : "delete",
+          op: eventOp,
           now: now ?? (() => new Date)
         }));
         spinner.warn(`files/${relPath} was not synced: a symlink on its path would read or write outside your Plinth folder. Run \`plinth status\`.`);
@@ -44089,6 +46315,7 @@ function makeWatchHandler(deps) {
         if (fileGate) {
           const op = classifyFileDestructive({ relPath, absolutePath, exists: false }, getState());
           if (op) {
+            output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "held" }));
             fileGate.consider(op);
             return;
           }
@@ -44103,6 +46330,9 @@ function makeWatchHandler(deps) {
             state: base2,
             deps: { fetchImpl, now, output, suppressor }
           });
+          if (result.outcome.kind === "ignored") {
+            output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "untracked" }));
+          }
           applyState(base2, clearReportedSafeFileRejected(result.state, relPath));
           reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
         });
@@ -44110,15 +46340,18 @@ function makeWatchHandler(deps) {
       }
       let st;
       try {
-        st = statSync17(absolutePath);
+        st = statSync18(absolutePath);
       } catch (err) {
-        if (err?.code === "ENOENT")
+        if (err?.code === "ENOENT") {
+          output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "vanished" }));
           return;
+        }
         throw err;
       }
       if (st.size > MAX_WORKSPACE_FILE_BYTES) {
         const tracked = getFileEntry(getState(), relPath);
         if (tracked && tracked.size_bytes === st.size) {
+          output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "over_cap_acked" }));
           spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
           return;
         }
@@ -44141,17 +46374,19 @@ function makeWatchHandler(deps) {
         spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
         return;
       }
-      const bytes = readFileSync26(absolutePath);
+      const bytes = readFileSync28(absolutePath);
       const hash2 = sha256Bytes(bytes);
       if (suppressor?.shouldSuppressUpsert(absolutePath, {
         bodyHash: hash2,
         frontmatterHash: ""
       })) {
+        output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "pull_echo" }));
         return;
       }
       if (fileGate) {
         const op = classifyFileDestructive({ relPath, absolutePath, exists: true, size: st.size, hash: hash2 }, getState());
         if (op) {
+          output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "held" }));
           fileGate.consider(op);
           return;
         }
@@ -44168,6 +46403,9 @@ function makeWatchHandler(deps) {
           prepared: { bytes, hash: hash2, size: st.size, inode: st.ino },
           deps: { fetchImpl, now, output, suppressor }
         });
+        if (result.outcome.kind === "noop") {
+          output?.log(filePushSkippedLine({ path: relPath, op: eventOp, reason: "unchanged" }));
+        }
         applyState(base2, result.outcome.kind === "over_cap" ? result.state : clearFileRejected(result.state, relPath));
         reportFileOutcome(spinner, workspaceSlug, getState(), result.outcome);
       });
@@ -44179,7 +46417,7 @@ function makeWatchHandler(deps) {
         applyFromCurrent((base2) => recordFileUnsynced({
           state: base2,
           relPath,
-          op: exists ? "upsert" : "delete",
+          op: eventOp,
           err,
           now: now ?? (() => new Date)
         }));
@@ -44187,7 +46425,7 @@ function makeWatchHandler(deps) {
         applyFromCurrent((base2) => recordFileRejected({
           state: base2,
           relPath,
-          op: exists ? "upsert" : "delete",
+          op: eventOp,
           err,
           now: now ?? (() => new Date)
         }));
@@ -44200,7 +46438,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync26(absolutePath, "utf8");
+        raw = readFileSync28(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -44239,7 +46477,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync26(absolutePath, "utf8");
+        raw = readFileSync28(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -44278,7 +46516,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync26(absolutePath, "utf8");
+        raw = readFileSync28(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -44317,7 +46555,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync26(absolutePath, "utf8");
+        raw = readFileSync28(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -44356,7 +46594,7 @@ function makeWatchHandler(deps) {
     if (suppressor) {
       let raw = null;
       try {
-        raw = readFileSync26(absolutePath, "utf8");
+        raw = readFileSync28(absolutePath, "utf8");
       } catch {
         raw = null;
       }
@@ -44402,7 +46640,7 @@ function makeWatchHandler(deps) {
           const strategy = getStrategy(classifiedFrom.entityType);
           let toRaw = null;
           try {
-            toRaw = readFileSync26(event.toPath, "utf8");
+            toRaw = readFileSync28(event.toPath, "utf8");
           } catch {
             toRaw = null;
           }
@@ -44471,19 +46709,26 @@ function makeWatchHandler(deps) {
         if (event.kind === "upsert") {
           try {
             ownEcho = suppressor?.shouldSuppressUpsert(absolutePath, {
-              bodyHash: stableHash(readFileSync26(absolutePath, "utf8")),
+              bodyHash: stableHash(readFileSync28(absolutePath, "utf8")),
               frontmatterHash: ""
             }) === true;
           } catch {
             ownEcho = true;
           }
         }
-        const warning2 = memoryFactEventWarning(classifyMemoryFactEvent({
+        const verdict = classifyMemoryFactEvent({
           path: factPath,
           kind: event.kind === "upsert" ? "upsert" : "unlink",
           ownEcho,
           known: getMemoryFactEntry(getState(), factPath.relPath) !== undefined
-        }));
+        });
+        if (verdict.kind === "generated" || verdict.kind === "deleted") {
+          applyFromCurrent((base3) => {
+            const raised = raiseFactPullReason(base3, "watcher_edit", (now ?? (() => new Date))().toISOString());
+            return raised === base3 ? base3 : commitState(base3, raised);
+          });
+        }
+        const warning2 = memoryFactEventWarning(verdict);
         if (warning2)
           spinner.warn(warning2);
         spinner.update(`Watching ${workspaceSlug} · ${watchingSummary(getState())}`);
@@ -44519,7 +46764,7 @@ function makeWatchHandler(deps) {
           if (strategy) {
             let raw = null;
             try {
-              raw = readFileSync26(absolutePath, "utf8");
+              raw = readFileSync28(absolutePath, "utf8");
             } catch {
               raw = null;
             }
@@ -44964,6 +47209,7 @@ async function runStart(workspaceSlug, deps = {}) {
     out.warn(`Artist memory reconcile skipped: ${msg}`);
   }
   const loggedTombstoneSkips = new Set;
+  const loggedStashNotices = new Set;
   const initial = await runSync(workspaceSlug, {
     fetchImpl,
     keychain,
@@ -44973,7 +47219,8 @@ async function runStart(workspaceSlug, deps = {}) {
     logSink: daemonLog,
     isFrozen,
     isFileFrozen,
-    loggedTombstoneSkips
+    loggedTombstoneSkips,
+    loggedStashNotices
   });
   if (initial.exitCode !== 0)
     return initial;
@@ -45045,6 +47292,21 @@ async function runStart(workspaceSlug, deps = {}) {
     return r ? { entityType: r.entityType, slug: r.entitySlug } : null;
   };
   const suppressor = new PullSuppressor;
+  const setDaemonState = (next) => {
+    state = next;
+  };
+  const factFreshnessGate = createFactFreshnessGate({
+    workspaceSlug: slug,
+    baseUrl: entry2.api_base_url,
+    pat,
+    getState: () => state,
+    setState: setDaemonState,
+    commitState,
+    fetchImpl,
+    now: deps.now,
+    suppressor,
+    output: daemonLog
+  });
   const flushHeldOp = (op) => flushHeldEntityOp({
     echo: { watcher: "live", suppressor },
     workspaceSlug: slug,
@@ -45204,9 +47466,11 @@ async function runStart(workspaceSlug, deps = {}) {
         sink: quietSink,
         logSink: daemonLog,
         suppressor,
+        factFreshnessGate,
         isFrozen,
         isFileFrozen,
-        loggedTombstoneSkips
+        loggedTombstoneSkips,
+        loggedStashNotices
       });
       if (result.exitCode === 0) {
         const applied = result.applied ?? 0;
@@ -45226,6 +47490,23 @@ async function runStart(workspaceSlug, deps = {}) {
       spinner.success(`↓ ${n} ${n === 1 ? "change" : "changes"} from cloud`);
       spinner.update(`Watching ${slug} · ${watchingSummary(state)}`);
     },
+    afterPollOutcome: composeAfterPollOutcome((ok) => {
+      if (!ok)
+        factFreshnessGate.onPollFailed();
+    }, memoryLaneCallback({
+      workspaceSlug: slug,
+      baseUrl: entry2.api_base_url,
+      pat,
+      mutex,
+      commitState,
+      getState: () => state,
+      setState: setDaemonState,
+      warn: (notice) => spinner.warn(notice),
+      fetchImpl,
+      now: deps.now,
+      suppressor,
+      output: daemonLog
+    })),
     afterPoll: () => {
       (async () => {
         state = loadState(slug);
@@ -45707,7 +47988,7 @@ var startCommand = defineCommand({
 });
 
 // src/commands/status.ts
-import { statSync as statSync19 } from "node:fs";
+import { statSync as statSync20 } from "node:fs";
 
 // src/lib/context/context-walls.ts
 function prepare(raw) {
@@ -46010,8 +48291,8 @@ function assessContextWalls(workspaceSlug, deps = {}) {
 
 // src/lib/build-stamp.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync11, readFileSync as readFileSync27, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync11, readFileSync as readFileSync29, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname13, join as join18 } from "node:path";
 import { fileURLToPath } from "node:url";
 var BUILD_STAMP_FILENAME = "build-stamp.json";
 function stampPath(distDir) {
@@ -46034,7 +48315,7 @@ function readHead(repoDir) {
 }
 function readBuildStamp(distDir) {
   try {
-    const parsed = JSON.parse(readFileSync27(stampPath(distDir), "utf8"));
+    const parsed = JSON.parse(readFileSync29(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 };
     }
@@ -46048,7 +48329,7 @@ function findRepoRoot(fromDir) {
   for (;; ) {
     if (existsSync10(join18(dir, ".git")))
       return dir;
-    const parent = dirname12(dir);
+    const parent = dirname13(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -46072,35 +48353,35 @@ function checkBuildStaleness(deps = {}) {
   const metaUrl = deps.metaUrl ?? import.meta.url;
   let distDir;
   try {
-    distDir = dirname12(fileURLToPath(metaUrl));
+    distDir = dirname13(fileURLToPath(metaUrl));
   } catch {
     return { kind: "unknown" };
   }
-  const stamp = readStamp(distDir);
-  if (!stamp)
+  const stamp2 = readStamp(distDir);
+  if (!stamp2)
     return { kind: "unknown" };
   const repoDir = findRepo(distDir);
   if (!repoDir)
     return { kind: "unknown" };
-  const head = probe2(repoDir, stamp.sha);
+  const head = probe2(repoDir, stamp2.sha);
   if (!head)
     return { kind: "unknown" };
-  if (head.sha !== stamp.sha) {
-    return { kind: "stale", reason: "head-moved", stamp, head };
+  if (head.sha !== stamp2.sha) {
+    return { kind: "stale", reason: "head-moved", stamp: stamp2, head };
   }
-  if (head.dirty && !stamp.dirty) {
-    return { kind: "stale", reason: "tree-dirty", stamp, head };
+  if (head.dirty && !stamp2.dirty) {
+    return { kind: "stale", reason: "tree-dirty", stamp: stamp2, head };
   }
-  return { kind: "fresh", stamp, head };
+  return { kind: "fresh", stamp: stamp2, head };
 }
 
 // src/lib/memory-links.ts
-import { readFileSync as readFileSync28 } from "node:fs";
+import { readFileSync as readFileSync30 } from "node:fs";
 import { relative as relative15, sep as sep8 } from "node:path";
 var MEMORY_FILE_RE = /^(workspace-memory\.md|user-memory\.md|artists\/[^/]+\/memory\.md|memory\/[^/]+\.md|memory\/private\/[^/]+\.md)$/i;
 function scanMemoryLinks(deps) {
   const listFiles = deps.listFiles ?? ((r) => walkSubtreeFiles(r, isVcsInternal));
-  const readFile = deps.readFile ?? ((p) => readFileSync28(p, "utf8"));
+  const readFile = deps.readFile ?? ((p) => readFileSync30(p, "utf8"));
   let root;
   let absPaths;
   try {
@@ -46144,10 +48425,10 @@ function scanMemoryLinks(deps) {
 init_output();
 
 // src/lib/pending-writes.ts
-import { readFileSync as readFileSync29, statSync as statSync18 } from "node:fs";
+import { readFileSync as readFileSync31, statSync as statSync19 } from "node:fs";
 import { relative as relative16 } from "node:path";
-var import_gray_matter14 = __toESM(require_gray_matter(), 1);
-var EMPTY2 = { writes: [], count: 0 };
+var import_gray_matter15 = __toESM(require_gray_matter(), 1);
+var EMPTY3 = { writes: [], count: 0 };
 function reportedElsewhere(state) {
   const entities = new Set;
   const files = new Set;
@@ -46165,7 +48446,7 @@ function scanPendingWrites(args) {
   try {
     mirrorRootPath = workspaceMirrorPath(workspaceSlug);
   } catch {
-    return EMPTY2;
+    return EMPTY3;
   }
   const ignored = watcherIgnoreMatcher(mirrorRootPath);
   const reported = reportedElsewhere(state);
@@ -46184,7 +48465,7 @@ function scanPendingWrites(args) {
       const entry3 = getFileEntry(state, fileMatch.relPath);
       let size;
       try {
-        size = statSync18(absolutePath).size;
+        size = statSync19(absolutePath).size;
       } catch {
         continue;
       }
@@ -46192,7 +48473,7 @@ function scanPendingWrites(args) {
         continue;
       let hash2;
       try {
-        hash2 = sha256Bytes(readFileSync29(absolutePath));
+        hash2 = sha256Bytes(readFileSync31(absolutePath));
       } catch {
         continue;
       }
@@ -46213,7 +48494,7 @@ function scanPendingWrites(args) {
       continue;
     let liveInode;
     try {
-      liveInode = statSync18(absolutePath).ino;
+      liveInode = statSync19(absolutePath).ino;
     } catch {
       liveInode = undefined;
     }
@@ -46223,14 +48504,14 @@ function scanPendingWrites(args) {
       continue;
     let content;
     try {
-      content = readFileSync29(absolutePath, "utf8");
+      content = readFileSync31(absolutePath, "utf8");
     } catch {
       continue;
     }
     if (!entry2) {
       let frontmatter;
       try {
-        frontmatter = import_gray_matter14.default(content).data ?? {};
+        frontmatter = import_gray_matter15.default(content).data ?? {};
       } catch {
         continue;
       }
@@ -46461,7 +48742,7 @@ function renderBuild(out, staleness) {
 }
 function lastActivity(now) {
   try {
-    const mtimeMs = statSync19(daemonLogPath()).mtimeMs;
+    const mtimeMs = statSync20(daemonLogPath()).mtimeMs;
     return formatRelative(now.getTime() - mtimeMs);
   } catch {
     return null;
@@ -46617,7 +48898,32 @@ async function runStatus(args, deps = {}) {
     }
   }
   out.info("");
+  const factFreshness = localState.memory_facts?.freshness;
+  if (factFreshness !== undefined) {
+    const at = localState.memory_facts?.freshness_checked_at;
+    const stamp2 = at ? readStamp(at) : undefined;
+    const asOf = stamp2 ? ` (as of ${stamp2})` : "";
+    const daemonLive = daemon !== null || daemonHolder()?.role === "daemon";
+    if (factFreshness === "current") {
+      out.info(row("Memory facts", `up to date${asOf}.`));
+      if (!daemonLive) {
+        out.info(cont(`The daemon is not running, so nothing has been checked since` + `${stamp2 ? ` ${stamp2}` : ""}. Start it with \`plinth start\`.`));
+      } else if (!stamp2) {
+        out.info(cont(`When that was last confirmed is not recorded.`));
+      }
+    } else if (factFreshness === "behind") {
+      out.info(row("Memory facts", `behind${asOf} - the daemon is downloading the latest.`));
+      if (!daemonLive) {
+        out.info(cont(`Start it with \`plinth start\` and the copy catches up.`));
+      }
+    } else {
+      out.info(row("Memory facts", `not checked${asOf} - whether this copy is up to date is unknown.`));
+      out.info(cont(daemonLive ? "The daemon keeps trying; the facts you have are still readable." : `The daemon is not running. Start it with \`plinth start\`.`));
+    }
+    out.info("");
+  }
   const rejected = listRejected(localState);
+  const freshness = Object.values(localState.memory_sources?.unwritten ?? {}).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   const localRejectedPaths = new Set(rejected.filter((r) => r.target === "file").map((r) => r.path));
   const teamRejected = listTeamRejected(localState).filter((r) => !localRejectedPaths.has(r.path));
   const MAX_SHOWN = 10;
@@ -46636,6 +48942,15 @@ async function runStatus(args, deps = {}) {
       out.info(cont(`…and ${rejected.length - MAX_SHOWN} more (see ~/.plinth/daemon.log).`));
     }
   }
+  if (freshness.length > 0) {
+    out.info(row("Memory context", `${freshness.length} file${freshness.length === 1 ? "" : "s"} could not be marked with ${freshness.length === 1 ? "its" : "their"} current memory state. Your edits are untouched.`));
+    for (const r of freshness.slice(0, MAX_SHOWN)) {
+      out.info(cont(r.message));
+    }
+    if (freshness.length > MAX_SHOWN) {
+      out.info(cont(`…and ${freshness.length - MAX_SHOWN} more (see ~/.plinth/daemon.log).`));
+    }
+  }
   if (teamRejected.length > 0) {
     out.info(cont(""));
     out.info(cont(teamRejectedHeadline(teamRejected.length, localState)));
@@ -47073,7 +49388,7 @@ var versionCommand = defineCommand({
 });
 
 // src/commands/voice-gate.ts
-import { readFileSync as readFileSync32 } from "node:fs";
+import { readFileSync as readFileSync34 } from "node:fs";
 
 // src/lib/voice-gate/api.ts
 var VoiceGateSurfaces = [
@@ -47178,7 +49493,7 @@ async function callVoiceGate(req) {
 import { createHash as createHash5 } from "node:crypto";
 import {
   mkdirSync as mkdirSync12,
-  readFileSync as readFileSync30,
+  readFileSync as readFileSync32,
   renameSync as renameSync8,
   unlinkSync as unlinkSync9,
   writeFileSync as writeFileSync9
@@ -47209,7 +49524,7 @@ function emptyFile() {
 }
 function load2(workspaceSlug) {
   try {
-    const raw = readFileSync30(attemptsPath(workspaceSlug), "utf8");
+    const raw = readFileSync32(attemptsPath(workspaceSlug), "utf8");
     const parsed = AttemptsFileSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : emptyFile();
   } catch {
@@ -47372,7 +49687,7 @@ function denyUngated(detail) {
 }
 
 // src/lib/voice-gate/payload.ts
-import { readFileSync as readFileSync31, statSync as statSync20 } from "node:fs";
+import { readFileSync as readFileSync33, statSync as statSync21 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { isAbsolute as isAbsolute4, resolve as resolve6 } from "node:path";
 var MAX_BODY_BYTES = 256 * 1024;
@@ -47529,11 +49844,11 @@ function isHelperInvocation(tokens) {
   return helperIndex === start + 1 && /(^|\/)python[0-9.]*$/.test(prev);
 }
 function defaultReadBodyFile(path5) {
-  const stat4 = statSync20(path5);
+  const stat4 = statSync21(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 readFileSync31(path5, "utf8");
+  return readFileSync33(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);
@@ -47893,7 +50208,7 @@ async function runVoiceGateDirect(args, deps = {}) {
   let text;
   if (args.file) {
     try {
-      text = readFileSync32(args.file, "utf8");
+      text = readFileSync34(args.file, "utf8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
       out.error(`Could not read ${args.file}: ${msg}`);