@remnic/plugin-openclaw 1.0.2 → 1.0.4

package/dist/{chunk-Y7JG2Q3V.js → chunk-5VTGFKKU.js}

@@ -1,23 +1,30 @@
 import {
   log
-} from "./chunk-DMGIUDBO.js";
+} from "./chunk-UFU5GGGA.js";
 
 // ../remnic-core/src/storage.ts
-import { access, readdir, readFile as readFile2, stat as stat2, writeFile as writeFile2, mkdir as mkdir2, unlink, rename, appendFile } from "fs/promises";
+import { access as access2, readdir, readFile as readFile3, stat as stat2, writeFile as writeFile3, mkdir as mkdir3, unlink as unlink2, rename, appendFile } from "fs/promises";
 import { appendFileSync, mkdirSync, statSync } from "fs";
-import { createHash } from "crypto";
-import path4 from "path";
+import { createHash as createHash2 } from "crypto";
+import path5 from "path";
 
 // ../remnic-core/src/memory-cache.ts
 var entityCacheByDir = /* @__PURE__ */ new Map();
-function getCachedEntities(baseDir, currentVersion) {
+function buildEntityCacheKey(baseDir, schemaKey = "") {
+  return `${baseDir}\0${schemaKey}`;
+}
+function getCachedEntities(baseDir, currentVersion, schemaKey = "") {
   if (currentVersion === 0) return null;
-  const entry = entityCacheByDir.get(baseDir);
+  const entry = entityCacheByDir.get(buildEntityCacheKey(baseDir, schemaKey));
   if (!entry || entry.version !== currentVersion) return null;
   return entry.entities;
 }
-function setCachedEntities(baseDir, entities, version) {
-  entityCacheByDir.set(baseDir, { entities, version, loadedAt: Date.now() });
+function setCachedEntities(baseDir, entities, version, schemaKey = "") {
+  entityCacheByDir.set(buildEntityCacheKey(baseDir, schemaKey), {
+    entities,
+    version,
+    loadedAt: Date.now()
+  });
 }
 var episodeMapByDir = /* @__PURE__ */ new Map();
 var ruleMemoriesByDir = /* @__PURE__ */ new Map();
@@ -166,6 +173,474 @@ function sanitizeMemoryContent(text) {
   };
 }
 
+// ../remnic-core/src/page-versioning.ts
+import { createHash } from "crypto";
+import path2 from "path";
+import {
+  access,
+  mkdir as mkdir2,
+  readFile as readFile2,
+  writeFile as writeFile2,
+  unlink
+} from "fs/promises";
+var NOOP_LOGGER = {
+  debug: () => {
+  },
+  warn: () => {
+  }
+};
+var writeLocks = /* @__PURE__ */ new Map();
+function withPageLock(pageKey, fn) {
+  const prev = writeLocks.get(pageKey) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  writeLocks.set(pageKey, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function sidecarKey(pagePath) {
+  const withoutExt = pagePath.replace(/\.md$/i, "");
+  return withoutExt.replace(/[\\/]/g, "__");
+}
+function sidecarDir(memoryDir, sidecar, pagePath) {
+  return path2.join(memoryDir, sidecar, sidecarKey(pagePath));
+}
+function manifestPath(memoryDir, sidecar, pagePath) {
+  return path2.join(sidecarDir(memoryDir, sidecar, pagePath), "manifest.json");
+}
+async function readManifest(memoryDir, sidecar, pagePath) {
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  try {
+    const raw = await readFile2(mp, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { pagePath, versions: [], currentVersion: "0" };
+    }
+    const obj = parsed;
+    const versions = Array.isArray(obj.versions) ? obj.versions : [];
+    const currentVersion = typeof obj.currentVersion === "string" ? obj.currentVersion : "0";
+    return { pagePath: typeof obj.pagePath === "string" ? obj.pagePath : pagePath, versions, currentVersion };
+  } catch {
+    return { pagePath, versions: [], currentVersion: "0" };
+  }
+}
+async function writeManifest(memoryDir, sidecar, pagePath, history) {
+  const dir = sidecarDir(memoryDir, sidecar, pagePath);
+  await mkdir2(dir, { recursive: true });
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  await writeFile2(mp, JSON.stringify(history, null, 2) + "\n", "utf-8");
+}
+async function createVersion(pagePath, content, trigger, config, log2 = NOOP_LOGGER, note, memoryDir) {
+  const { sidecarDir: sidecar, maxVersionsPerPage } = config;
+  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);
+  const mPath = manifestPath(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+  return withPageLock(mPath, async () => {
+    const history = await readManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    const nextId = String(history.versions.length > 0 ? Math.max(...history.versions.map((v) => Number(v.versionId))) + 1 : 1);
+    const hash = contentHash(content);
+    const version = {
+      versionId: nextId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      contentHash: hash,
+      sizeBytes: Buffer.byteLength(content, "utf-8"),
+      trigger,
+      ...note !== void 0 ? { note } : {}
+    };
+    const dir = sidecarDir(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    await mkdir2(dir, { recursive: true });
+    const ext = path2.extname(pagePath) || ".md";
+    const snapshotPath = path2.join(dir, `${nextId}${ext}`);
+    await writeFile2(snapshotPath, content, "utf-8");
+    history.versions.push(version);
+    history.currentVersion = nextId;
+    if (maxVersionsPerPage > 0 && history.versions.length > maxVersionsPerPage) {
+      const toRemove = history.versions.splice(0, history.versions.length - maxVersionsPerPage);
+      for (const old of toRemove) {
+        const oldPath = path2.join(dir, `${old.versionId}${ext}`);
+        try {
+          await unlink(oldPath);
+        } catch {
+          log2.debug(`page-versioning: could not remove old snapshot ${oldPath}`);
+        }
+      }
+    }
+    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);
+    log2.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);
+    return version;
+  });
+}
+function resolveMemoryDir(pagePath) {
+  const knownSubdirs = /* @__PURE__ */ new Set([
+    "facts",
+    "corrections",
+    "entities",
+    "state",
+    "artifacts",
+    "questions",
+    "profiles"
+  ]);
+  let dir = path2.dirname(pagePath);
+  for (let depth = 0; depth < 5; depth++) {
+    const base = path2.basename(dir);
+    if (knownSubdirs.has(base) || /^\d{4}-\d{2}-\d{2}$/.test(base)) {
+      dir = path2.dirname(dir);
+    } else {
+      break;
+    }
+  }
+  return dir;
+}
+function relPath(pagePath, memoryDir) {
+  return path2.relative(memoryDir, pagePath);
+}
+
+// ../remnic-core/src/entity-schema.ts
+var DEFAULT_ENTITY_SCHEMAS = {
+  person: {
+    sections: [
+      {
+        key: "beliefs",
+        title: "Beliefs",
+        description: "",
+        aliases: ["belief", "beliefs", "believe", "believes"]
+      },
+      {
+        key: "communication_style",
+        title: "Communication Style",
+        description: "",
+        aliases: ["communication", "communication style", "communicate", "writes", "writing style"]
+      },
+      {
+        key: "building",
+        title: "Building / Working On",
+        description: "",
+        aliases: ["building", "working on", "work on", "projects"]
+      }
+    ]
+  },
+  project: {
+    sections: [
+      { key: "status", title: "Status", description: "" },
+      {
+        key: "building",
+        title: "Building / Working On",
+        description: "",
+        aliases: ["building", "working on", "work on"]
+      },
+      { key: "risks", title: "Risks", description: "" },
+      { key: "notes", title: "Notes", description: "" }
+    ]
+  }
+};
+function normalizeEntityText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function toSnakeCase(value) {
+  return normalizeEntityText(value).replace(/\s+/g, "_");
+}
+function titleFromKey(key) {
+  return key.split("_").filter(Boolean).map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join(" ");
+}
+function tokenizeNormalized(value) {
+  return normalizeEntityText(value).split(/\s+/).filter(Boolean);
+}
+function normalizeSectionDefinition(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const value = raw;
+  const keySource = typeof value.key === "string" ? value.key : typeof value.title === "string" ? value.title : "";
+  const titleSource = typeof value.title === "string" ? value.title : typeof value.key === "string" ? value.key : "";
+  const key = toSnakeCase(keySource);
+  const title = titleSource.trim() || titleFromKey(key);
+  if (!key || !title) return null;
+  const description = typeof value.description === "string" ? value.description : "";
+  const aliases = Array.isArray(value.aliases) ? value.aliases.filter((alias) => typeof alias === "string").map((alias) => alias.trim()).filter((alias) => alias.length > 0) : [];
+  return aliases.length > 0 ? { key, title, description, aliases } : { key, title, description };
+}
+function normalizeEntitySchemas(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const result = {};
+  for (const [entityType, schema] of Object.entries(raw)) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) continue;
+    const rawSections = schema.sections;
+    if (!Array.isArray(rawSections)) continue;
+    const sections = rawSections.map((section) => normalizeSectionDefinition(section)).filter((section) => section !== null);
+    if (sections.length === 0) continue;
+    result[toSnakeCase(entityType)] = { sections };
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function mergeEntitySchemaDefinitions(defaults, overrides) {
+  const overrideByKey = new Map(overrides.sections.map((section) => [section.key, section]));
+  const mergedSections = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const section of defaults.sections) {
+    const override = overrideByKey.get(section.key);
+    const mergedAliases = Array.from(/* @__PURE__ */ new Set([...section.aliases ?? [], ...override?.aliases ?? []]));
+    const nextSection = override ? {
+      ...section,
+      ...override,
+      ...mergedAliases.length > 0 ? { aliases: mergedAliases } : {}
+    } : section;
+    mergedSections.push(nextSection);
+    seen.add(nextSection.key);
+  }
+  for (const section of overrides.sections) {
+    if (seen.has(section.key)) continue;
+    mergedSections.push(section);
+    seen.add(section.key);
+  }
+  return { sections: mergedSections };
+}
+function getEntitySchema(entityType, entitySchemas) {
+  const normalizedType = toSnakeCase(entityType);
+  const defaults = DEFAULT_ENTITY_SCHEMAS[normalizedType];
+  const overrides = entitySchemas?.[normalizedType];
+  if (!defaults) return overrides;
+  if (!overrides) return defaults;
+  return mergeEntitySchemaDefinitions(defaults, overrides);
+}
+function matchEntitySchemaSection(entityType, title, entitySchemas) {
+  const normalizedTitle = normalizeEntityText(title);
+  if (!normalizedTitle) return null;
+  const schema = getEntitySchema(entityType, entitySchemas);
+  if (!schema) return null;
+  for (const section of schema.sections) {
+    const aliases = [section.title, section.key, ...section.aliases ?? []];
+    if (aliases.some((alias) => normalizeEntityText(alias) === normalizedTitle)) {
+      return section;
+    }
+  }
+  return null;
+}
+function normalizeEntityStructuredSection(entityType, section, entitySchemas) {
+  const matchedSection = matchEntitySchemaSection(entityType, section.title, entitySchemas) ?? matchEntitySchemaSection(entityType, section.key, entitySchemas);
+  if (matchedSection) {
+    return {
+      key: matchedSection.key,
+      title: matchedSection.title
+    };
+  }
+  const key = toSnakeCase(section.key || section.title);
+  return {
+    key,
+    title: section.title.trim() || titleFromKey(key)
+  };
+}
+function queryMentionsAlias(query, alias) {
+  const queryTokens = tokenizeNormalized(query);
+  const aliasTokens = tokenizeNormalized(alias);
+  if (queryTokens.length === 0 || aliasTokens.length === 0) return false;
+  if (aliasTokens.length > queryTokens.length) return false;
+  for (let index = 0; index <= queryTokens.length - aliasTokens.length; index += 1) {
+    let matched = true;
+    for (let offset = 0; offset < aliasTokens.length; offset += 1) {
+      if (queryTokens[index + offset] !== aliasTokens[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) return true;
+  }
+  return false;
+}
+function resolveRequestedEntitySectionKeys(query, entityType, availableSections, entitySchemas) {
+  if (availableSections.length === 0) return [];
+  const availableKeys = new Set(availableSections.map((section) => toSnakeCase(section.key)));
+  const schema = getEntitySchema(entityType, entitySchemas);
+  if (!schema) return [];
+  const matches = [];
+  for (const section of schema.sections) {
+    const key = toSnakeCase(section.key);
+    if (!availableKeys.has(key)) continue;
+    const aliases = [section.title, section.key, ...section.aliases ?? []];
+    if (aliases.some((alias) => queryMentionsAlias(query, alias))) {
+      matches.push(key);
+    }
+  }
+  return matches;
+}
+function sortStructuredSectionsBySchema(entityType, sections, entitySchemas) {
+  const schema = getEntitySchema(entityType, entitySchemas);
+  if (!schema || sections.length <= 1) return sections;
+  const order = new Map(schema.sections.map((section, index) => [toSnakeCase(section.key), index]));
+  return [...sections].sort((left, right) => {
+    const leftRank = order.get(toSnakeCase(left.key)) ?? Number.MAX_SAFE_INTEGER;
+    const rightRank = order.get(toSnakeCase(right.key)) ?? Number.MAX_SAFE_INTEGER;
+    if (leftRank !== rightRank) return leftRank - rightRank;
+    return left.title.localeCompare(right.title);
+  });
+}
+
+// ../remnic-core/src/source-attribution.ts
+var DEFAULT_CITATION_FORMAT = "[Source: agent={agent}, session={sessionId}, ts={ts}]";
+var CITATION_UNKNOWN = "unknown";
+function defaultCitationMatcher() {
+  return /\[Source:\s*([^\]\n]+?)\]/gi;
+}
+function deriveSessionId(session) {
+  if (!session) return void 0;
+  const trimmed = session.trim();
+  if (trimmed.length === 0) return void 0;
+  const parts = trimmed.split(":").filter((p) => p.length > 0);
+  if (parts.length === 0) return trimmed;
+  return parts[parts.length - 1];
+}
+function formatCitation(ctx, template = DEFAULT_CITATION_FORMAT) {
+  const session = ctx.session ?? "";
+  const sessionId = ctx.sessionId ?? deriveSessionId(session) ?? CITATION_UNKNOWN;
+  const ts = ctx.ts ?? CITATION_UNKNOWN;
+  const agent = ctx.agent && ctx.agent.trim().length > 0 ? ctx.agent : CITATION_UNKNOWN;
+  const date = ts && ts !== CITATION_UNKNOWN ? ts.slice(0, 10) : CITATION_UNKNOWN;
+  const sessionForTemplate = session.trim().length > 0 ? session : CITATION_UNKNOWN;
+  const values = {
+    agent,
+    session: sessionForTemplate,
+    sessionId,
+    ts,
+    date
+  };
+  return template.replace(/\{([a-zA-Z_][\w]*)\}/g, (match, name) => {
+    return Object.prototype.hasOwnProperty.call(values, name) ? values[name] : match;
+  });
+}
+function hasCitation(text) {
+  if (typeof text !== "string" || text.length === 0) return false;
+  return defaultCitationMatcher().test(text);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function escapeRegExpCharClass(ch) {
+  if (ch === "]") return "\\]";
+  if (ch === "\\") return "\\\\";
+  if (ch === "^") return "\\^";
+  if (ch === "-") return "\\-";
+  return escapeRegExp(ch);
+}
+function buildTokenPattern(nonWordSepChars) {
+  const base = "\\n\\s";
+  if (nonWordSepChars.size === 0) {
+    return `[^\\n]+?`;
+  }
+  const escaped = [...nonWordSepChars].map(escapeRegExpCharClass).join("");
+  return `[^${base}${escaped}]+?`;
+}
+var PLACEHOLDER_REGEX = /\{[a-zA-Z_][\w]*\}/g;
+function templateMatcher(template) {
+  const parts = template.split(PLACEHOLDER_REGEX);
+  if (parts.length <= 1) return null;
+  const prefix = parts[0] ?? "";
+  const suffix = parts[parts.length - 1] ?? "";
+  if (prefix.length > 0 || suffix.length > 0) {
+    const escapedPrefix = escapeRegExp(prefix);
+    const escapedSuffix = escapeRegExp(suffix);
+    const innerParts = parts.slice(1, -1);
+    const nonWordSepChars = /* @__PURE__ */ new Set();
+    for (const sep of innerParts) {
+      for (const ch of sep) {
+        if (!/\w/.test(ch)) {
+          nonWordSepChars.add(ch);
+        }
+      }
+    }
+    const interToken = buildTokenPattern(nonWordSepChars);
+    const lastToken = buildTokenPattern(/* @__PURE__ */ new Set());
+    const middle = innerParts.length === 0 ? lastToken : interToken + innerParts.slice(0, -1).map((sep) => escapeRegExp(sep) + interToken).join("") + escapeRegExp(innerParts[innerParts.length - 1]) + lastToken;
+    const pattern = escapedPrefix + middle + escapedSuffix;
+    return new RegExp(pattern, "i");
+  }
+  const middleLiterals = parts.slice(1, -1);
+  const hasNonEmptyMiddle = middleLiterals.some((p) => p.length > 0);
+  if (!hasNonEmptyMiddle) {
+    return null;
+  }
+  const idToken = "[\\w.:-]+";
+  const body = idToken + middleLiterals.map((lit) => escapeRegExp(lit) + idToken).join("");
+  const separatorText = middleLiterals.join("");
+  if (/\s/.test(separatorText)) {
+    const opener = "[\\[\\(\\<]";
+    const closer = "[\\]\\)\\>]";
+    return new RegExp(opener + body + closer, "i");
+  }
+  const leadAnchor = "(?:(?<=[\\[\\(\\<])|(?<!\\S))";
+  const trailAnchor = "(?:(?=[\\]\\)\\>])|(?=\\s*$))";
+  return new RegExp(leadAnchor + body + trailAnchor, "i");
+}
+function hasCitationForTemplate(text, template) {
+  if (typeof text !== "string" || text.length === 0) return false;
+  if (hasCitation(text)) return true;
+  if (template === DEFAULT_CITATION_FORMAT) return false;
+  if (!PLACEHOLDER_REGEX.test(template)) {
+    PLACEHOLDER_REGEX.lastIndex = 0;
+    return text.includes(template);
+  }
+  PLACEHOLDER_REGEX.lastIndex = 0;
+  const matcher = templateMatcher(template);
+  if (!matcher) {
+    return false;
+  }
+  return matcher.test(text);
+}
+function attachCitation(text, ctx, template = DEFAULT_CITATION_FORMAT) {
+  if (typeof text !== "string") return text;
+  if (hasCitationForTemplate(text, template)) return text;
+  const trimmedEnd = text.replace(/\s+$/u, "");
+  if (trimmedEnd.length === 0) return text;
+  const citation = formatCitation(ctx, template);
+  const trailing = text.slice(trimmedEnd.length);
+  return `${trimmedEnd} ${citation}${trailing}`;
+}
+function stripCitation(text) {
+  if (typeof text !== "string" || text.length === 0) return text;
+  if (!hasCitation(text)) return text;
+  const matcher = defaultCitationMatcher();
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = matcher.exec(text)) !== null) {
+    const before = text.slice(lastIndex, match.index).replace(/[ \t]+$/, "");
+    result += before;
+    lastIndex = match.index + match[0].length;
+  }
+  const after = text.slice(lastIndex).replace(/^[ \t]+/, "");
+  if (after.length > 0) {
+    if (result.length > 0) result += " ";
+    result += after;
+  }
+  return result.trimEnd();
+}
+function stripCitationForTemplate(text, template) {
+  if (typeof text !== "string" || text.length === 0) return text;
+  if (hasCitation(text)) return stripCitation(text);
+  if (!hasCitationForTemplate(text, template)) return text;
+  const matcher = templateMatcher(template);
+  if (!matcher) return stripCitation(text);
+  const globalMatcher = new RegExp(
+    matcher.source,
+    matcher.flags.includes("g") ? matcher.flags : matcher.flags + "g"
+  );
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = globalMatcher.exec(text)) !== null) {
+    const before = text.slice(lastIndex, match.index).replace(/[ \t]+$/, "");
+    result += before;
+    lastIndex = match.index + match[0].length;
+    if (match[0].length === 0) {
+      globalMatcher.lastIndex++;
+    }
+  }
+  const after = text.slice(lastIndex).replace(/^[ \t]+/, "");
+  if (after.length > 0) {
+    if (result.length > 0) result += " ";
+    result += after;
+  }
+  return result.trimEnd();
+}
+
 // ../remnic-core/src/types.ts
 function confidenceTier(score) {
   if (score >= 0.95) return "explicit";
@@ -176,7 +651,7 @@ function confidenceTier(score) {
 var SPECULATIVE_TTL_DAYS = 30;
 
 // ../remnic-core/src/memory-projection-store.ts
-import path2 from "path";
+import path3 from "path";
 import { readFileSync } from "fs";
 
 // ../remnic-core/src/runtime/better-sqlite.ts
@@ -209,7 +684,7 @@ function openBetterSqlite3(file, options) {
 // ../remnic-core/src/memory-projection-store.ts
 var MEMORY_PROJECTION_SCHEMA_VERSION = 2;
 function getMemoryProjectionPath(memoryDir) {
-  return path2.join(memoryDir, "state", "memory-projection.sqlite");
+  return path3.join(memoryDir, "state", "memory-projection.sqlite");
 }
 function listTableColumns(db, tableName) {
   try {
@@ -441,7 +916,7 @@ function parseCurrentRow(memoryDir, row) {
     category: row.category,
     status: row.status,
     lifecycleState: typeof row.lifecycle_state === "string" ? row.lifecycle_state : void 0,
-    path: path2.join(memoryDir, row.path_rel),
+    path: path3.join(memoryDir, row.path_rel),
     pathRel: row.path_rel,
     created: row.created_at,
     updated: row.updated_at,
@@ -602,7 +1077,7 @@ function readProjectedMemoryBrowse(memoryDir, options) {
           return true;
         }
         try {
-          const filePath = path2.join(memoryDir, row.path_rel);
+          const filePath = path3.join(memoryDir, row.path_rel);
           const content = readFileSync(filePath, "utf-8").toLowerCase();
           return content.includes(normalizedQuery);
         } catch {
@@ -616,7 +1091,7 @@ function readProjectedMemoryBrowse(memoryDir, options) {
           (row) => typeof row.memory_id === "string" && typeof row.path_rel === "string" && typeof row.category === "string" && typeof row.status === "string"
         ).map((row) => ({
           id: row.memory_id,
-          path: path2.join(memoryDir, row.path_rel),
+          path: path3.join(memoryDir, row.path_rel),
           category: row.category,
           status: row.status,
           created: typeof row.created_at === "string" ? row.created_at : void 0,
@@ -650,7 +1125,7 @@ function readProjectedMemoryBrowse(memoryDir, options) {
         (row) => typeof row.memory_id === "string" && typeof row.path_rel === "string" && typeof row.category === "string" && typeof row.status === "string"
       ).map((row) => ({
         id: row.memory_id,
-        path: path2.join(memoryDir, row.path_rel),
+        path: path3.join(memoryDir, row.path_rel),
         category: row.category,
         status: row.status,
         created: typeof row.created_at === "string" ? row.created_at : void 0,
@@ -866,7 +1341,7 @@ function readProjectedGovernanceRecord(memoryDir) {
 }
 
 // ../remnic-core/src/memory-lifecycle-ledger-utils.ts
-import path3 from "path";
+import path4 from "path";
 var MEMORY_LIFECYCLE_RULE_VERSION = "memory-lifecycle-ledger.v1";
 var MEMORY_LIFECYCLE_EVENT_SORT_ORDER = {
   created: 0,
@@ -882,8 +1357,8 @@ var MEMORY_LIFECYCLE_EVENT_SORT_ORDER = {
   archived: 10
 };
 function toMemoryPathRel(baseDir, filePath) {
-  if (!baseDir) return filePath.split(path3.sep).join("/");
-  return path3.relative(baseDir, filePath).split(path3.sep).join("/");
+  if (!baseDir) return filePath.split(path4.sep).join("/");
+  return path4.relative(baseDir, filePath).split(path4.sep).join("/");
 }
 function isArchivedMemoryPath(pathRel) {
   return pathRel === "archive" || pathRel.startsWith("archive/");
@@ -1315,6 +1790,7 @@ function serializeFrontmatter(fm) {
   if (fm.structuredAttributes && Object.keys(fm.structuredAttributes).length > 0) {
     lines.push(`structuredAttributes: ${JSON.stringify(fm.structuredAttributes)}`);
   }
+  if (fm.contentHash) lines.push(`contentHash: ${fm.contentHash}`);
   lines.push("---");
   return lines.join("\n");
 }
@@ -1449,7 +1925,9 @@ function parseFrontmatter2(raw) {
       // v8.0 Phase 2B: HiMem episode/note classification
       memoryKind: fm.memoryKind || void 0,
       // Structured attributes (JSON on a single line)
-      structuredAttributes: parseStructuredAttributes(fm.structuredAttributes)
+      structuredAttributes: parseStructuredAttributes(fm.structuredAttributes),
+      // Raw-content dedup hash (format-agnostic archive/consolidation cleanup)
+      contentHash: fm.contentHash || void 0
     },
     content
   };
@@ -1472,14 +1950,47 @@ function parseFrontmatter2(raw) {
   }
   return result;
 }
-function normalizeFrontmatterForPath(frontmatter, pathRel) {
-  if (isArchivedMemoryPath(pathRel) && (!frontmatter.status || frontmatter.status === "active")) {
+function inferEntityTypeFromContent(content) {
+  const typeMatch = content.match(/^\*\*Type:\*\*\s*([^\n]+)/m)?.[1]?.trim().toLowerCase();
+  return typeMatch || void 0;
+}
+var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set([
+  "company",
+  "other",
+  "person",
+  "place",
+  "project",
+  "tool",
+  "topic"
+]);
+function inferEntityTypeFromFilename(pathRel) {
+  const basename = path5.basename(pathRel, ".md").toLowerCase();
+  const separator = basename.indexOf("-");
+  if (separator <= 0) return void 0;
+  const candidate = basename.slice(0, separator);
+  return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
+}
+function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
+  const normalizedPath = pathRel.split(path5.sep).join("/");
+  let normalizedFrontmatter = frontmatter;
+  if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
+    const basename = path5.basename(pathRel, ".md");
+    const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
+    const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
+    normalizedFrontmatter = {
+      ...normalizedFrontmatter,
+      id: typeof normalizedFrontmatter.id === "string" && normalizedFrontmatter.id.trim().length > 0 ? normalizedFrontmatter.id : basename,
+      category: "entity",
+      tags: existingTags.includes(inferredType) ? existingTags : [...existingTags, inferredType]
+    };
+  }
+  if (isArchivedMemoryPath(pathRel) && (!normalizedFrontmatter.status || normalizedFrontmatter.status === "active")) {
     return {
-      ...frontmatter,
+      ...normalizedFrontmatter,
       status: "archived"
     };
   }
-  return frontmatter;
+  return normalizedFrontmatter;
 }
 function inferCurrentStateStatus(frontmatter, pathRel, fallbackStatus) {
   return inferMemoryStatus(frontmatter, pathRel, fallbackStatus);
@@ -1528,12 +2039,12 @@ var ContentHashIndex = class _ContentHashIndex {
   dirty = false;
   filePath;
   constructor(stateDir) {
-    this.filePath = path4.join(stateDir, "fact-hashes.txt");
+    this.filePath = path5.join(stateDir, "fact-hashes.txt");
   }
   /** Load existing hashes from disk. Safe to call multiple times. */
   async load() {
     try {
-      const raw = await readFile2(this.filePath, "utf-8");
+      const raw = await readFile3(this.filePath, "utf-8");
       for (const line of raw.split("\n")) {
         const trimmed = line.trim();
         if (trimmed.length > 0) {
@@ -1563,8 +2074,8 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed. */
   async save() {
     if (!this.dirty) return;
-    await mkdir2(path4.dirname(this.filePath), { recursive: true });
-    await writeFile2(this.filePath, [...this.hashes].join("\n") + "\n", "utf-8");
+    await mkdir3(path5.dirname(this.filePath), { recursive: true });
+    await writeFile3(this.filePath, [...this.hashes].join("\n") + "\n", "utf-8");
     this.dirty = false;
     log.debug(`content-hash index: saved ${this.hashes.size} hashes`);
   }
@@ -1575,6 +2086,33 @@ var ContentHashIndex = class _ContentHashIndex {
       this.dirty = true;
     }
   }
+  /**
+   * Remove a pre-computed SHA-256 hash directly from the index without
+   * re-hashing.  Use this when the caller already holds the stored hash
+   * (e.g. `memory.frontmatter.contentHash`) to avoid the double-hash bug
+   * where `remove(hash)` would compute `hash(hash)` and never match the
+   * entry.
+   */
+  removeByHash(hash) {
+    if (this.hashes.delete(hash)) {
+      this.dirty = true;
+    }
+  }
+  /**
+   * Add a pre-computed SHA-256 hash directly to the index without re-hashing.
+   * Use this when the caller already holds the stored hash
+   * (e.g. `memory.frontmatter.contentHash`) so that the index records the raw
+   * content hash rather than re-hashing the citation-annotated body.
+   *
+   * @internal Only called from `StorageManager.ensureFactHashIndexAuthoritative`.
+   * Not part of the public API — prefer `add(content)` for external callers.
+   */
+  addByHash(hash) {
+    if (!this.hashes.has(hash)) {
+      this.hashes.add(hash);
+      this.dirty = true;
+    }
+  }
   /** Normalize content and compute SHA-256 hash. */
   static normalizeContent(content) {
     return content.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -1582,39 +2120,601 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Normalize content and compute SHA-256 hash. */
   static computeHash(content) {
     const normalized = _ContentHashIndex.normalizeContent(content);
-    return createHash("sha256").update(normalized).digest("hex");
+    return createHash2("sha256").update(normalized).digest("hex");
   }
 };
-function parseEntityFile(content) {
-  const lines = content.split("\n");
+function normalizeAttributePairs(pairs) {
+  return Object.entries(pairs).map(([k, v]) => [k.trim().toLowerCase(), v.trim()]).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join("; ");
+}
+function parseEntityFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: raw };
+  }
+  const values = {};
+  const extraLines = [];
+  const recognizedKeys = /* @__PURE__ */ new Set([
+    "created",
+    "updated",
+    "synthesis_updated_at",
+    "synthesis_timeline_count",
+    "synthesis_structured_fact_count",
+    "synthesis_structured_fact_digest",
+    "synthesis_version"
+  ]);
+  for (const line of match[1].split(/\r?\n/)) {
+    if (/^\s/.test(line)) {
+      extraLines.push(line);
+      continue;
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) {
+      extraLines.push(line);
+      continue;
+    }
+    const key = line.slice(0, colonIdx).trim();
+    if (!recognizedKeys.has(key)) {
+      extraLines.push(line);
+      continue;
+    }
+    const value = parseManagedFrontmatterValue(line.slice(colonIdx + 1));
+    values[key] = value;
+  }
+  const synthesisTimelineCount = Number.parseInt(values.synthesis_timeline_count ?? "", 10);
+  const synthesisStructuredFactCount = Number.parseInt(values.synthesis_structured_fact_count ?? "", 10);
+  const synthesisVersion = Number.parseInt(values.synthesis_version ?? "", 10);
+  return {
+    frontmatter: {
+      created: values.created || void 0,
+      updated: values.updated || void 0,
+      synthesisUpdatedAt: values.synthesis_updated_at || void 0,
+      synthesisTimelineCount: Number.isFinite(synthesisTimelineCount) ? synthesisTimelineCount : void 0,
+      synthesisStructuredFactCount: Number.isFinite(synthesisStructuredFactCount) ? synthesisStructuredFactCount : void 0,
+      synthesisStructuredFactDigest: values.synthesis_structured_fact_digest || void 0,
+      synthesisVersion: Number.isFinite(synthesisVersion) ? synthesisVersion : void 0,
+      extraLines
+    },
+    body: match[2]
+  };
+}
+function parseManagedFrontmatterValue(rawValue) {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return "";
+  const openingQuote = trimmed[0];
+  if (openingQuote === '"' || openingQuote === "'") {
+    let escaped = false;
+    for (let index = 1; index < trimmed.length; index += 1) {
+      const char = trimmed[index];
+      if (openingQuote === '"' && !escaped && char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (!escaped && char === openingQuote) {
+        return trimmed.slice(1, index);
+      }
+      escaped = false;
+    }
+    return trimmed.slice(1).replace(new RegExp(`${openingQuote}$`), "");
+  }
+  for (let index = 0; index < trimmed.length; index += 1) {
+    if (trimmed[index] === "#" && (index === 0 || /\s/.test(trimmed[index - 1] ?? ""))) {
+      return trimmed.slice(0, index).trimEnd();
+    }
+  }
+  return trimmed;
+}
+function readEntitySectionText(lines, sectionNames, options = {}) {
+  const normalizedSections = new Set(sectionNames.map((name) => name.toLowerCase()));
+  let section = "";
+  const sectionLines = [];
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      const nextSection = line.slice(3).trim().toLowerCase();
+      if (section && !normalizedSections.has(nextSection)) break;
+      section = normalizedSections.has(nextSection) ? nextSection : "";
+      continue;
+    }
+    if (!section) continue;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (options.preserveBullets === true && sectionLines.length > 0 && sectionLines[sectionLines.length - 1] !== "") {
+        sectionLines.push("");
+      }
+      continue;
+    }
+    if (options.skipTimelineBullets === true && trimmed.startsWith("- ") && isEntitySynthesisTimelinePromotionBullet(trimmed.slice(2))) {
+      continue;
+    }
+    if (trimmed.startsWith("- ") && options.preserveBullets !== true) continue;
+    sectionLines.push(options.preserveBullets === true ? line.trimEnd() : trimmed);
+  }
+  while (sectionLines[sectionLines.length - 1] === "") {
+    sectionLines.pop();
+  }
+  if (sectionLines.length === 0) return void 0;
+  return sectionLines.join(options.preserveBullets === true ? "\n" : " ");
+}
+function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
+  const trimmed = bullet.trim();
+  if (!trimmed) return null;
+  let rest = trimmed;
+  const entry = {
+    timestamp: trimmed.startsWith("[") ? "" : fallbackTimestamp,
+    text: ""
+  };
+  const consumedMetadataSegments = [];
+  let literalSingleSourceSegment;
+  if (!trimmed.startsWith("[")) {
+    entry.text = trimmed;
+    return entry.text ? entry : null;
+  }
+  const firstEnd = trimmed.indexOf("]");
+  if (firstEnd === -1) {
+    entry.text = trimmed;
+    return entry.text ? entry : null;
+  }
+  const firstToken = trimmed.slice(1, firstEnd).trim();
+  const parsedTimestamp = Date.parse(firstToken);
+  if (Number.isFinite(parsedTimestamp)) {
+    entry.timestamp = firstToken || fallbackTimestamp;
+    rest = trimmed.slice(firstEnd + 1).trimStart();
+  }
+  while (rest.startsWith("[")) {
+    const end = findEntityTimelineTokenEnd(rest);
+    if (end === -1) break;
+    const rawSegment = rest.slice(0, end + 1);
+    const token = rest.slice(1, end).trim();
+    const equalsIdx = token.indexOf("=");
+    if (equalsIdx === -1) {
+      if (rest === trimmed) {
+        entry.text = trimmed;
+        return entry.text ? entry : null;
+      }
+      break;
+    }
+    const key = token.slice(0, equalsIdx).trim().toLowerCase();
+    const value = unescapeEntityTimelineMetadataValue(token.slice(equalsIdx + 1).trim());
+    if (!value) break;
+    const nextRest = rest.slice(end + 1).trimStart();
+    switch (key) {
+      case "source_meta":
+        entry.source = value;
+        break;
+      case "source":
+        if (consumedMetadataSegments.length === 0 && !nextRest.startsWith("[") && nextRest.length > 0 && !isManagedEntityTimelineSource(value)) {
+          literalSingleSourceSegment = rawSegment;
+          rest = nextRest;
+          break;
+        }
+        entry.source = value;
+        break;
+      case "session":
+      case "sessionkey":
+        entry.sessionKey = value;
+        break;
+      case "principal":
+        entry.principal = value;
+        break;
+      default:
+        entry.text = rest.trim();
+        return entry.text ? entry : null;
+    }
+    if (literalSingleSourceSegment) break;
+    consumedMetadataSegments.push(rawSegment);
+    rest = nextRest;
+  }
+  if (literalSingleSourceSegment) {
+    return {
+      timestamp: entry.timestamp,
+      text: `${literalSingleSourceSegment} ${rest}`.trim()
+    };
+  }
+  entry.text = rest.trim();
+  if (!entry.text) return null;
+  return entry;
+}
+function isEntitySynthesisTimelinePromotionBullet(bullet) {
+  const trimmed = bullet.trim();
+  if (!trimmed.startsWith("[")) return false;
+  const firstEnd = findEntityTimelineTokenEnd(trimmed);
+  if (firstEnd === -1) return false;
+  const firstToken = trimmed.slice(1, firstEnd).trim();
+  return looksLikeEntityTimelineTimestamp(firstToken);
+}
+function looksLikeEntityTimelineTimestamp(token) {
+  if (!/^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$/.test(token)) return false;
+  return Number.isFinite(Date.parse(token));
+}
+function isManagedEntityTimelineSource(source) {
+  switch (source.trim().toLowerCase()) {
+    case "artifact":
+    case "chunking":
+    case "cli-migrate":
+    case "compounding-promotion":
+    case "consolidation":
+    case "contradiction-detection":
+    case "entity_extraction":
+    case "explicit":
+    case "explicit-inline":
+    case "explicit-inline-review":
+    case "explicit-review":
+    case "extraction":
+    case "extraction-shared-promotion":
+    case "manual":
+    case "migration":
+    case "migration-rechunk":
+    case "proactive":
+    case "replay":
+    case "semantic-consolidation":
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+function findEntityTimelineTokenEnd(input) {
+  let escaped = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "]") return index;
+  }
+  return -1;
+}
+function escapeEntityTimelineMetadataValue(value) {
+  let escaped = "";
+  for (const char of value) {
+    switch (char) {
+      case "\\":
+        escaped += "\\\\";
+        break;
+      case "]":
+        escaped += "\\]";
+        break;
+      case "\n":
+        escaped += "\\n";
+        break;
+      case "\r":
+        escaped += "\\r";
+        break;
+      case "	":
+        escaped += "\\t";
+        break;
+      default: {
+        const codePoint = char.codePointAt(0) ?? 0;
+        if (codePoint < 32) {
+          escaped += `\\u${codePoint.toString(16).padStart(4, "0")}`;
+        } else {
+          escaped += char;
+        }
+      }
+    }
+  }
+  return escaped;
+}
+function unescapeEntityTimelineMetadataValue(value) {
+  if (!value.includes("\\")) return value;
+  let result = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char !== "\\") {
+      result += char;
+      continue;
+    }
+    const next = value[index + 1];
+    if (!next) {
+      result += "\\";
+      break;
+    }
+    switch (next) {
+      case "n":
+        result += "\n";
+        index += 1;
+        break;
+      case "r":
+        result += "\r";
+        index += 1;
+        break;
+      case "t":
+        result += "	";
+        index += 1;
+        break;
+      case "u": {
+        const hex = value.slice(index + 2, index + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
+          result += String.fromCharCode(parseInt(hex, 16));
+          index += 5;
+          break;
+        }
+        result += "u";
+        index += 1;
+        break;
+      }
+      default:
+        result += next;
+        index += 1;
+        break;
+    }
+  }
+  return result;
+}
+function serializeEntityTimelineEntry(entry) {
+  const tokens = [];
+  if (entry.timestamp.trim().length > 0) {
+    tokens.push(`[${entry.timestamp}]`);
+  }
+  if (entry.source) {
+    const sourceKey = isManagedEntityTimelineSource(entry.source) ? "source" : "source_meta";
+    tokens.push(`[${sourceKey}=${escapeEntityTimelineMetadataValue(entry.source)}]`);
+  }
+  if (entry.sessionKey) {
+    tokens.push(`[session=${escapeEntityTimelineMetadataValue(entry.sessionKey)}]`);
+  }
+  if (entry.principal) {
+    tokens.push(`[principal=${escapeEntityTimelineMetadataValue(entry.principal)}]`);
+  }
+  const serializedMetadata = tokens.length > 0 ? `${tokens.join(" ")} ` : "";
+  return `- ${serializedMetadata}${entry.text}`.trimEnd();
+}
+function dedupeEntityTimelineFacts(timeline) {
+  return [...new Set(
+    timeline.map((entry) => entry.text.trim()).filter((entry) => entry.length > 0)
+  )];
+}
+function normalizeEntitySectionFact(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeStructuredSectionFacts(facts) {
+  return [...new Set(
+    facts.map((fact) => normalizeEntitySectionFact(fact)).filter((fact) => fact.length > 0)
+  )];
+}
+function collectStructuredSectionFacts(structuredSections) {
+  const facts = [];
+  for (const section of structuredSections) {
+    for (const fact of section.facts) {
+      const normalized = normalizeEntitySectionFact(fact);
+      if (!normalized) continue;
+      facts.push(normalized);
+    }
+  }
+  return [...new Set(facts)];
+}
+function compileEntityFacts(timeline, structuredSections) {
+  const facts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const fact of dedupeEntityTimelineFacts(timeline)) {
+    if (seen.has(fact)) continue;
+    seen.add(fact);
+    facts.push(fact);
+  }
+  for (const fact of collectStructuredSectionFacts(structuredSections)) {
+    if (seen.has(fact)) continue;
+    seen.add(fact);
+    facts.push(fact);
+  }
+  return facts;
+}
+function parseEntityStructuredSectionFacts(lines) {
+  const facts = [];
+  let currentBlock = [];
+  const flushCurrentBlock = () => {
+    const normalized = normalizeEntitySectionFact(currentBlock.join(" "));
+    if (normalized.length > 0) facts.push(normalized);
+    currentBlock = [];
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) {
+      flushCurrentBlock();
+      continue;
+    }
+    if (line.startsWith("- ")) {
+      flushCurrentBlock();
+      currentBlock = [line.slice(2).trim()];
+      continue;
+    }
+    currentBlock.push(line);
+  }
+  flushCurrentBlock();
+  return [...new Set(facts)];
+}
+function looksLikeStructuredSectionFactList(lines) {
+  const firstNonBlank = lines.find((line) => line.trim().length > 0)?.trim() ?? "";
+  return firstNonBlank.startsWith("- ");
+}
+function partitionEntityStructuredSections(entityType, extraSections, entitySchemas) {
+  const structuredSections = [];
+  const remainingExtraSections = [];
+  const structuredSectionIndex = /* @__PURE__ */ new Map();
+  for (const section of extraSections) {
+    const matchedSection = matchEntitySchemaSection(entityType, section.title, entitySchemas);
+    if (!matchedSection && !looksLikeStructuredSectionFactList(section.lines)) {
+      remainingExtraSections.push(section);
+      continue;
+    }
+    const facts = parseEntityStructuredSectionFacts(section.lines);
+    if (!matchedSection && facts.length === 0) {
+      remainingExtraSections.push(section);
+      continue;
+    }
+    const normalizedSection = matchedSection ? { key: matchedSection.key, title: matchedSection.title } : normalizeEntityStructuredSection(
+      entityType,
+      { key: section.title, title: section.title },
+      entitySchemas
+    );
+    if (facts.length === 0) {
+      remainingExtraSections.push(section);
+      continue;
+    }
+    const existing = structuredSectionIndex.get(normalizedSection.key);
+    if (existing) {
+      existing.facts = normalizeStructuredSectionFacts([...existing.facts, ...facts]);
+      continue;
+    }
+    const structuredSection = {
+      key: normalizedSection.key,
+      title: normalizedSection.title,
+      facts: normalizeStructuredSectionFacts(facts)
+    };
+    structuredSections.push(structuredSection);
+    structuredSectionIndex.set(normalizedSection.key, structuredSection);
+  }
+  return {
+    structuredSections,
+    remainingExtraSections
+  };
+}
+function latestEntityTimelineTimestamp(entity) {
+  let latestRaw;
+  for (const entry of entity.timeline) {
+    const timestamp = entry.timestamp.trim();
+    if (!timestamp) continue;
+    if (!latestRaw || compareEntityTimestamps(timestamp, latestRaw) > 0) {
+      latestRaw = timestamp;
+    }
+  }
+  return latestRaw;
+}
+function compareEntityTimestamps(left, right) {
+  const leftValue = left?.trim() ?? "";
+  const rightValue = right?.trim() ?? "";
+  if (!leftValue && !rightValue) return 0;
+  if (!leftValue) return -1;
+  if (!rightValue) return 1;
+  const leftMs = Date.parse(leftValue);
+  const rightMs = Date.parse(rightValue);
+  const leftParsed = Number.isFinite(leftMs);
+  const rightParsed = Number.isFinite(rightMs);
+  if (leftParsed && rightParsed) {
+    if (leftMs === rightMs) return 0;
+    return leftMs > rightMs ? 1 : -1;
+  }
+  if (leftParsed) return 1;
+  if (rightParsed) return -1;
+  return leftValue.localeCompare(rightValue);
+}
+function countEntityStructuredFacts(entity) {
+  return (entity.structuredSections ?? []).reduce((count, section) => count + section.facts.length, 0);
+}
+function fingerprintEntityStructuredFacts(entity) {
+  const normalizedSections = (entity.structuredSections ?? []).map((section) => ({
+    key: section.key.trim().toLowerCase(),
+    title: section.title.replace(/\s+/g, " ").trim(),
+    facts: normalizeStructuredSectionFacts(section.facts).slice().sort((left, right) => left.localeCompare(right))
+  })).filter((section) => section.facts.length > 0).sort((left, right) => left.key.localeCompare(right.key) || left.title.localeCompare(right.title) || left.facts.join("\n").localeCompare(right.facts.join("\n")));
+  if (normalizedSections.length === 0) return void 0;
+  return createHash2("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+}
+function isEntitySynthesisStale(entity) {
+  const structuredFactCount = countEntityStructuredFacts(entity);
+  const structuredFactDigest = fingerprintEntityStructuredFacts(entity);
+  const storedStructuredFactDigest = entity.synthesisStructuredFactDigest?.trim() || void 0;
+  if (entity.timeline.length === 0 && structuredFactCount === 0) return false;
+  if (!entity.synthesis?.trim()) return true;
+  if (entity.synthesisTimelineCount === void 0) return true;
+  if (structuredFactCount > 0 && entity.synthesisStructuredFactCount === void 0) return true;
+  if (structuredFactCount > 0 && !storedStructuredFactDigest) return true;
+  const latestTimelineTimestamp = latestEntityTimelineTimestamp(entity);
+  if (!latestTimelineTimestamp) {
+    return entity.timeline.length > entity.synthesisTimelineCount || structuredFactCount > (entity.synthesisStructuredFactCount ?? 0) || structuredFactDigest !== storedStructuredFactDigest;
+  }
+  if (!entity.synthesisUpdatedAt?.trim()) return true;
+  const timelineFreshness = compareEntityTimestamps(latestTimelineTimestamp, entity.synthesisUpdatedAt);
+  if (timelineFreshness > 0) return true;
+  return entity.timeline.length > entity.synthesisTimelineCount || structuredFactCount > (entity.synthesisStructuredFactCount ?? 0) || structuredFactDigest !== storedStructuredFactDigest;
+}
+function parseEntityFile(content, entitySchemas) {
+  const { frontmatter, body } = parseEntityFrontmatter(content);
+  const lines = body.split("\n");
+  const recognizedSections = /* @__PURE__ */ new Set([
+    "facts",
+    "timeline",
+    "summary",
+    "synthesis",
+    "connected to",
+    "activity",
+    "aliases"
+  ]);
   let name = "";
   let type = "other";
+  let created = frontmatter.created ?? "";
   let updated = "";
-  let summary;
-  const facts = [];
+  const legacyFacts = [];
   const relationships = [];
   const activity = [];
   const aliases = [];
+  const timeline = [];
+  const extraSections = [];
   const headingLine = lines.find((l) => l.startsWith("# "));
   if (headingLine) name = headingLine.slice(2).trim();
   const typeLine = lines.find((l) => l.startsWith("**Type:**"));
   if (typeLine) type = typeLine.replace("**Type:**", "").trim();
   const updatedLine = lines.find((l) => l.startsWith("**Updated:**"));
   if (updatedLine) updated = updatedLine.replace("**Updated:**", "").trim();
+  if (!updated) updated = frontmatter.updated ?? frontmatter.created ?? "";
+  if (!created) created = updated;
+  const headingLineIndex = lines.findIndex((l) => l.startsWith("# "));
+  const firstSectionIndex = lines.findIndex((l) => l.startsWith("## "));
+  const preSectionStartIndex = headingLineIndex > -1 ? headingLineIndex + 1 : 0;
+  const preSectionCandidates = firstSectionIndex > -1 ? lines.slice(preSectionStartIndex, firstSectionIndex) : lines.slice(preSectionStartIndex);
+  const preSectionLines = preSectionCandidates.filter(
+    (line) => !line.startsWith("**Type:**") && !line.startsWith("**Updated:**")
+  );
+  const normalizedPreSectionLines = [...preSectionLines];
+  while (normalizedPreSectionLines[0] === "") {
+    normalizedPreSectionLines.shift();
+  }
+  const preservedPreSectionLines = normalizedPreSectionLines.some((line) => line.trim().length > 0) ? normalizedPreSectionLines : [];
+  const fallbackTimestamp = updated || created || "";
   let section = "";
+  let currentExtraSection = null;
   for (const line of lines) {
     if (line.startsWith("## ")) {
-      section = line.slice(3).trim().toLowerCase();
+      const heading = line.slice(3).trim();
+      section = heading.toLowerCase();
+      if (recognizedSections.has(section)) {
+        currentExtraSection = null;
+      } else {
+        currentExtraSection = { title: heading, lines: [] };
+        extraSections.push(currentExtraSection);
+      }
       continue;
     }
+    if (currentExtraSection) {
+      currentExtraSection.lines.push(line);
+    }
     if (!line.startsWith("- ")) continue;
     const bullet = line.slice(2).trim();
     if (!bullet) continue;
     switch (section) {
       case "facts":
-        facts.push(bullet);
+        legacyFacts.push(bullet);
         break;
+      case "timeline": {
+        const parsed = parseEntityTimelineBullet(
+          bullet,
+          fallbackTimestamp
+        );
+        if (parsed) timeline.push(parsed);
+        break;
+      }
       case "summary":
+      case "synthesis":
+        if (isEntitySynthesisTimelinePromotionBullet(bullet)) {
+          const parsed = parseEntityTimelineBullet(
+            bullet,
+            fallbackTimestamp
+          );
+          if (parsed) timeline.push(parsed);
+        }
         break;
       case "connected to": {
         const relMatch = bullet.match(/^\[\[([^\]]+)\]\]\s*[—–-]\s*(.+)$/);
@@ -1635,34 +2735,128 @@ function parseEntityFile(content) {
         break;
     }
   }
-  const summaryIdx = lines.findIndex((l) => l.startsWith("## Summary"));
-  if (summaryIdx !== -1) {
-    const summaryLines = [];
-    for (let i = summaryIdx + 1; i < lines.length; i++) {
-      if (lines[i].startsWith("## ")) break;
-      const trimmed = lines[i].trim();
-      if (trimmed) summaryLines.push(trimmed);
-    }
-    if (summaryLines.length > 0) summary = summaryLines.join(" ");
-  }
-  return { name, type, updated, facts, summary, relationships, activity, aliases };
+  const legacyFactTimelineEntries = legacyFacts.map((fact) => ({
+    timestamp: fallbackTimestamp,
+    text: fact,
+    source: "migration"
+  }));
+  if (legacyFactTimelineEntries.length > 0) {
+    const existingTimelineFacts = new Set(
+      timeline.map((entry) => entry.text.trim()).filter((entry) => entry.length > 0)
+    );
+    for (const fact of legacyFactTimelineEntries) {
+      const normalizedFact = fact.text.trim();
+      if (!normalizedFact || existingTimelineFacts.has(normalizedFact)) continue;
+      timeline.push(fact);
+      existingTimelineFacts.add(normalizedFact);
+    }
+  }
+  const synthesis = readEntitySectionText(lines, ["Synthesis"], { preserveBullets: true, skipTimelineBullets: true }) ?? readEntitySectionText(lines, ["Summary"], { preserveBullets: true, skipTimelineBullets: true });
+  const synthesisUpdatedAt = frontmatter.synthesisUpdatedAt || void 0;
+  const synthesisTimelineCount = frontmatter.synthesisTimelineCount;
+  const synthesisStructuredFactCount = frontmatter.synthesisStructuredFactCount;
+  const synthesisStructuredFactDigest = frontmatter.synthesisStructuredFactDigest;
+  const { structuredSections, remainingExtraSections } = partitionEntityStructuredSections(
+    type,
+    extraSections,
+    entitySchemas
+  );
+  const facts = compileEntityFacts(timeline, structuredSections);
+  return {
+    name,
+    type,
+    created,
+    updated,
+    extraFrontmatterLines: frontmatter.extraLines ?? [],
+    preSectionLines: preservedPreSectionLines,
+    facts,
+    summary: synthesis,
+    synthesis,
+    synthesisUpdatedAt,
+    synthesisTimelineCount,
+    synthesisStructuredFactCount,
+    synthesisStructuredFactDigest,
+    synthesisVersion: frontmatter.synthesisVersion,
+    timeline,
+    structuredSections,
+    relationships,
+    activity,
+    aliases,
+    extraSections: remainingExtraSections
+  };
 }
-function serializeEntityFile(entity) {
+function serializeEntityFile(entity, entitySchemas) {
+  const synthesis = entity.synthesis || entity.summary || "";
+  const created = entity.created?.trim() || entity.updated || (/* @__PURE__ */ new Date()).toISOString();
+  const updated = entity.updated || created;
+  const timeline = entity.timeline;
+  const structuredSections = sortStructuredSectionsBySchema(
+    entity.type,
+    (entity.structuredSections ?? []).map((section) => ({
+      ...section,
+      facts: normalizeStructuredSectionFacts(section.facts)
+    })).filter((section) => section.facts.length > 0),
+    entitySchemas
+  );
+  const sectionFacts = new Set(collectStructuredSectionFacts(structuredSections));
+  const legacyFacts = timeline.length === 0 ? [...new Set(
+    entity.facts.map((fact) => normalizeEntitySectionFact(fact)).filter((fact) => fact.length > 0 && !sectionFacts.has(fact))
+  )] : [];
+  const synthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || "";
+  const synthesisTimelineCount = entity.synthesisTimelineCount;
+  const synthesisStructuredFactCount = entity.synthesisStructuredFactCount;
+  const synthesisStructuredFactDigest = entity.synthesisStructuredFactDigest?.trim() || "";
+  const synthesisVersion = entity.synthesisVersion ?? (synthesis ? 1 : 0);
   const lines = [
+    "---",
+    `created: ${created}`,
+    `updated: ${updated}`,
+    `synthesis_updated_at: "${synthesisUpdatedAt}"`,
+    ...synthesisTimelineCount === void 0 ? [] : [`synthesis_timeline_count: ${synthesisTimelineCount}`],
+    ...synthesisStructuredFactCount === void 0 ? [] : [`synthesis_structured_fact_count: ${synthesisStructuredFactCount}`],
+    ...synthesisStructuredFactDigest ? [`synthesis_structured_fact_digest: "${synthesisStructuredFactDigest}"`] : [],
+    `synthesis_version: ${synthesisVersion}`,
+    ...entity.extraFrontmatterLines ?? [],
+    "---",
+    "",
     `# ${entity.name}`,
     "",
     `**Type:** ${entity.type}`,
-    `**Updated:** ${entity.updated || (/* @__PURE__ */ new Date()).toISOString()}`,
+    `**Updated:** ${updated}`,
     ""
   ];
-  if (entity.summary) {
-    lines.push("## Summary", "", entity.summary, "");
+  if ((entity.preSectionLines ?? []).length > 0) {
+    lines.push(...entity.preSectionLines ?? []);
+    if (entity.preSectionLines?.[entity.preSectionLines.length - 1] !== "") {
+      lines.push("");
+    }
   }
-  lines.push("## Facts", "");
-  for (const f of entity.facts) {
-    lines.push(`- ${f}`);
+  lines.push("## Synthesis", "");
+  if (synthesis) {
+    lines.push(synthesis);
   }
   lines.push("");
+  if (timeline.length > 0 || legacyFacts.length === 0) {
+    lines.push("## Timeline", "");
+    for (const entry of timeline) {
+      lines.push(serializeEntityTimelineEntry(entry));
+    }
+    lines.push("");
+  }
+  if (legacyFacts.length > 0) {
+    lines.push("## Facts", "");
+    for (const fact of legacyFacts) {
+      lines.push(`- ${fact}`);
+    }
+    lines.push("");
+  }
+  for (const section of structuredSections) {
+    lines.push(`## ${section.title}`, "");
+    for (const fact of section.facts) {
+      lines.push(`- ${fact}`);
+    }
+    lines.push("");
+  }
   if (entity.relationships.length > 0) {
     lines.push("## Connected to", "");
     for (const rel of entity.relationships) {
@@ -1684,13 +2878,37 @@ function serializeEntityFile(entity) {
     }
     lines.push("");
   }
+  for (const section of entity.extraSections ?? []) {
+    lines.push(`## ${section.title}`);
+    lines.push(...section.lines);
+    if (section.lines.length > 0 && section.lines[section.lines.length - 1] !== "") {
+      lines.push("");
+    }
+  }
   return lines.join("\n");
 }
+function buildEntitySchemaCacheKey(entitySchemas) {
+  if (!entitySchemas) return "";
+  const normalized = Object.entries(entitySchemas).sort(([left], [right]) => left.localeCompare(right)).map(([entityType, schema]) => [
+    entityType,
+    {
+      sections: schema.sections.map((section) => ({
+        key: section.key,
+        title: section.title,
+        description: section.description,
+        aliases: section.aliases ? [...section.aliases] : void 0
+      }))
+    }
+  ]);
+  return JSON.stringify(normalized);
+}
 var StorageManager = class _StorageManager {
-  constructor(baseDir) {
+  constructor(baseDir, entitySchemas) {
     this.baseDir = baseDir;
+    this.entitySchemas = entitySchemas;
   }
   baseDir;
+  entitySchemas;
   knowledgeIndexCache = null;
   static KNOWLEDGE_INDEX_CACHE_TTL_MS = 6e5;
   // 10 minutes (entity mutations invalidate)
@@ -1699,6 +2917,9 @@ var StorageManager = class _StorageManager {
   // 1 minute
   static artifactWriteVersionByDir = /* @__PURE__ */ new Map();
   static memoryStatusVersionByDir = /* @__PURE__ */ new Map();
+  // In-process fallback for the cold-write sentinel (used when the disk file
+  // is not accessible).  The canonical source of truth is state/cold-write.log.
+  static coldWriteVersionByDir = /* @__PURE__ */ new Map();
   // Module-level cache for readAllMemories() keyed by base directory.
   // Shared across all StorageManager instances to avoid duplicate I/O when
   // multiple concurrent callers (e.g. verifiedRecall + verifiedRules) read the
@@ -1710,6 +2931,29 @@ var StorageManager = class _StorageManager {
   // refresh.  This eliminates the 13-60 s cold-scan penalty that would otherwise
   // block recall requests every 5 minutes on large memory collections (80k+ files).
   static allMemoriesInFlight = /* @__PURE__ */ new Map();
+  // Cache for readAllColdMemories() — keyed by cold root directory path.
+  // Prevents an uncached full-tree directory scan on every structured-attribute
+  // write (Finding UOGi, PR #402 round-6).  The cache is only invalidated when
+  // cold-tier content actually changes (via invalidateColdMemoriesCache), NOT
+  // on every hot-tier write.  It also expires after COLD_SCAN_CACHE_TTL_MS as
+  // a safety net.
+  //
+  // Finding UvUy (PR #402 round-11): cache entries now carry a `coldVersion`
+  // sentinel that is bumped (via a file-size counter in state/cold-write.log)
+  // on every write that modifies cold-tier content.  Before serving a cached
+  // result, readAllColdMemories() reads the sentinel from disk and compares.
+  // If they differ the entry is dropped and the cold tree is re-scanned.  This
+  // makes the cache correct across process boundaries (gateway + CLI): a second
+  // process that writes a new cold memory bumps the sentinel on disk, so the
+  // first process's next readAllColdMemories() sees the change within one call
+  // (rather than waiting up to 30s for TTL expiry).
+  //
+  // After Finding UTsP broadened readAllColdMemories to scan the entire cold/
+  // subtree (not just facts/+corrections/), amortizing this I/O across
+  // back-to-back writes in the same burst is even more important.
+  static COLD_SCAN_CACHE_TTL_MS = 3e4;
+  // 30 seconds
+  static coldMemoriesCache = /* @__PURE__ */ new Map();
   // Cache for readQuestions() — avoids serially re-reading tens of thousands of
   // question files on every recall.  60-second TTL is intentionally short so that
   // newly written questions surface quickly.
@@ -1720,19 +2964,39 @@ var StorageManager = class _StorageManager {
   factHashIndexLoadPromise = null;
   factHashIndexAuthoritative = null;
   factHashIndexAuthoritativePromise = null;
+  /** Optional: set by the orchestrator after construction to enable template-aware citation stripping during legacy hash rebuild. */
+  citationTemplate = DEFAULT_CITATION_FORMAT;
+  /** Page-versioning configuration.  Set by the orchestrator after construction. */
+  _versioningConfig = null;
+  /** Set the page-versioning configuration.  When `enabled` is false (default), all versioning calls are no-ops. */
+  setVersioningConfig(config) {
+    this._versioningConfig = config;
+  }
+  /**
+   * Snapshot the current content of a page before overwriting.
+   * No-op when versioning is disabled or the file does not yet exist.
+   */
+  async snapshotBeforeWrite(filePath, trigger) {
+    if (!this._versioningConfig || !this._versioningConfig.enabled) return;
+    try {
+      const existing = await readFile3(filePath, "utf-8");
+      await createVersion(filePath, existing, trigger, this._versioningConfig, log, void 0, this.baseDir);
+    } catch {
+    }
+  }
   /** The root directory of this storage instance. */
   get dir() {
     return this.baseDir;
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path4.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path5.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path4.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path5.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    const fileName = kind === "memory-status" ? ".memory-status-version.log" : ".artifact-write-version.log";
-    return path4.join(this.stateDir, fileName);
+    const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : ".cold-write-version.log";
+    return path5.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -1769,19 +3033,22 @@ var StorageManager = class _StorageManager {
     return this.readSharedVersion("artifact-write", _StorageManager.artifactWriteVersionByDir);
   }
   get factsDir() {
-    return path4.join(this.baseDir, "facts");
+    return path5.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path4.join(this.baseDir, "corrections");
+    return path5.join(this.baseDir, "corrections");
   }
   get entitiesDir() {
-    return path4.join(this.baseDir, "entities");
+    return path5.join(this.baseDir, "entities");
   }
   get stateDir() {
-    return path4.join(this.baseDir, "state");
+    return path5.join(this.baseDir, "state");
+  }
+  get entitySynthesisQueuePath() {
+    return path5.join(this.stateDir, "entity-synthesis-queue.json");
   }
   get factHashIndexReadyPath() {
-    return path4.join(this.stateDir, "fact-hashes.ready");
+    return path5.join(this.stateDir, "fact-hashes.ready");
   }
   async getFactHashIndex() {
     if (this.factHashIndex) {
@@ -1809,21 +3076,46 @@ var StorageManager = class _StorageManager {
     }
     this.factHashIndexAuthoritativePromise = (async () => {
       try {
-        await access(this.factHashIndexReadyPath);
+        await access2(this.factHashIndexReadyPath);
         this.factHashIndexAuthoritative = true;
         return;
       } catch {
       }
       const factHashIndex = await this.getFactHashIndex();
       const existing = await this.readAllMemories();
+      let legacyRecovered = 0;
       for (const memory of existing) {
         if (memory.frontmatter.category !== "fact") continue;
         if (inferMemoryStatus(memory.frontmatter, memory.path) !== "active") continue;
-        factHashIndex.add(memory.content);
+        if (memory.frontmatter.contentHash) {
+          factHashIndex.addByHash(memory.frontmatter.contentHash);
+          continue;
+        }
+        const content = memory.content;
+        const stripped = stripCitationForTemplate(content, this.citationTemplate);
+        if (stripped !== content) {
+          factHashIndex.addByHash(
+            ContentHashIndex.computeHash(sanitizeMemoryContent(stripped).text)
+          );
+          continue;
+        }
+        if (!hasCitation(content)) {
+          factHashIndex.addByHash(
+            ContentHashIndex.computeHash(sanitizeMemoryContent(content).text)
+          );
+          continue;
+        }
+        legacyRecovered++;
+        continue;
+      }
+      if (legacyRecovered > 0) {
+        log.info(
+          `ensureFactHashIndexAuthoritative: skipped ${legacyRecovered} legacy fact(s) with no contentHash in frontmatter`
+        );
       }
       await factHashIndex.save();
-      await mkdir2(path4.dirname(this.factHashIndexReadyPath), { recursive: true });
-      await writeFile2(this.factHashIndexReadyPath, "v1\n", "utf-8");
+      await mkdir3(path5.dirname(this.factHashIndexReadyPath), { recursive: true });
+      await writeFile3(this.factHashIndexReadyPath, "v1\n", "utf-8");
       this.factHashIndexAuthoritative = true;
     })().finally(() => {
       this.factHashIndexAuthoritativePromise = null;
@@ -1831,55 +3123,55 @@ var StorageManager = class _StorageManager {
     await this.factHashIndexAuthoritativePromise;
   }
   get questionsDir() {
-    return path4.join(this.baseDir, "questions");
+    return path5.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path4.join(this.baseDir, "artifacts");
+    return path5.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path4.join(this.baseDir, "identity");
+    return path5.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path4.join(this.identityDir, "identity-anchor.md");
+    return path5.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path4.join(this.identityDir, "incidents");
+    return path5.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path4.join(this.identityDir, "audits", "weekly");
+    return path5.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path4.join(this.identityDir, "audits", "monthly");
+    return path5.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path4.join(this.identityDir, "improvement-loops.md");
+    return path5.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path4.join(this.identityDir, "reflections.md");
+    return path5.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path4.join(this.baseDir, "profile.md");
+    return path5.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path4.join(this.stateDir, "memory-actions.jsonl");
+    return path5.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path4.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path5.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path4.join(this.stateDir, "compression-guidelines.md");
+    return path5.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path4.join(this.stateDir, "compression-guidelines.draft.md");
+    return path5.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path4.join(this.stateDir, "compression-guideline-state.json");
+    return path5.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path4.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path5.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path4.join(this.stateDir, "behavior-signals.jsonl");
+    return path5.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * Load user-defined entity aliases from config/aliases.json in the memory store.
@@ -1887,9 +3179,9 @@ var StorageManager = class _StorageManager {
    * Call this once at startup (e.g. from orchestrator.initialize()).
    */
   async loadAliases() {
-    const aliasPath = path4.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path5.join(this.baseDir, "config", "aliases.json");
     try {
-      const raw = await readFile2(aliasPath, "utf-8");
+      const raw = await readFile3(aliasPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null) {
         userAliases = parsed;
@@ -1901,17 +3193,17 @@ var StorageManager = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir2(path4.join(this.factsDir, today), { recursive: true });
-    await mkdir2(this.correctionsDir, { recursive: true });
-    await mkdir2(this.entitiesDir, { recursive: true });
-    await mkdir2(this.stateDir, { recursive: true });
-    await mkdir2(this.questionsDir, { recursive: true });
-    await mkdir2(this.artifactsDir, { recursive: true });
-    await mkdir2(this.identityDir, { recursive: true });
-    await mkdir2(this.identityIncidentsDir, { recursive: true });
-    await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
-    await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path4.join(this.baseDir, "config"), { recursive: true });
+    await mkdir3(path5.join(this.factsDir, today), { recursive: true });
+    await mkdir3(this.correctionsDir, { recursive: true });
+    await mkdir3(this.entitiesDir, { recursive: true });
+    await mkdir3(this.stateDir, { recursive: true });
+    await mkdir3(this.questionsDir, { recursive: true });
+    await mkdir3(this.artifactsDir, { recursive: true });
+    await mkdir3(this.identityDir, { recursive: true });
+    await mkdir3(this.identityIncidentsDir, { recursive: true });
+    await mkdir3(this.identityAuditsWeeklyDir, { recursive: true });
+    await mkdir3(this.identityAuditsMonthlyDir, { recursive: true });
+    await mkdir3(path5.join(this.baseDir, "config"), { recursive: true });
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -1953,25 +3245,29 @@ var StorageManager = class _StorageManager {
     };
     let enrichedContent = content;
     if (options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
-      const attrLines = Object.entries(options.structuredAttributes).map(([k, v]) => `${k}: ${v}`).join("; ");
       enrichedContent = `${content}
-[Attributes: ${attrLines}]`;
+[Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]`;
     }
     const sanitized = sanitizeMemoryContent(enrichedContent);
     if (!sanitized.clean) {
       log.warn(`memory content sanitized for ${id}; violations=${sanitized.violations.join(", ")}`);
     }
+    if (category === "fact") {
+      const hashSource = options.contentHashSource !== void 0 && options.contentHashSource.length > 0 ? sanitizeMemoryContent(options.contentHashSource).text : sanitized.text;
+      fm.contentHash = ContentHashIndex.computeHash(hashSource);
+    }
     const fileContent = `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
 `;
     let filePath;
     if (category === "correction") {
-      filePath = path4.join(this.correctionsDir, `${id}.md`);
+      filePath = path5.join(this.correctionsDir, `${id}.md`);
     } else {
-      filePath = path4.join(this.factsDir, today, `${id}.md`);
+      filePath = path5.join(this.factsDir, today, `${id}.md`);
     }
-    await writeFile2(filePath, fileContent, "utf-8");
+    await this.snapshotBeforeWrite(filePath, "write");
+    await writeFile3(filePath, fileContent, "utf-8");
     this.invalidateAllMemoriesCache();
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.writeMemory", {
       memoryId: id,
@@ -1987,7 +3283,12 @@ ${sanitized.text}
     if (category === "fact") {
       try {
         const factHashIndex = await this.getFactHashIndex();
-        factHashIndex.add(sanitized.text);
+        if (options.contentHashSource !== void 0 && options.contentHashSource.length > 0) {
+          const hashSourceSanitized = sanitizeMemoryContent(options.contentHashSource);
+          factHashIndex.add(hashSourceSanitized.text);
+        } else {
+          factHashIndex.add(sanitized.text);
+        }
         await factHashIndex.save();
       } catch (err) {
         log.warn(`storage.writeMemory completed but failed to update fact hash index: ${err}`);
@@ -2010,8 +3311,8 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path4.join(this.artifactsDir, day);
-    await mkdir2(dir, { recursive: true });
+    const dir = path5.join(this.artifactsDir, day);
+    await mkdir3(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
       id,
@@ -2034,8 +3335,8 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path4.join(dir, `${id}.md`);
-    await writeFile2(filePath, `${serializeFrontmatter(fm)}
+    const filePath = path5.join(dir, `${id}.md`);
+    await writeFile3(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
 `, "utf-8");
@@ -2062,7 +3363,7 @@ ${sanitized.text}
         try {
           const entries = await readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path4.join(dir, entry.name);
+            const fullPath = path5.join(dir, entry.name);
             if (entry.isDirectory()) {
               await readDir(fullPath);
               continue;
@@ -2110,7 +3411,7 @@ ${sanitized.text}
     hits.sort((a, b) => b.score - a.score);
     return hits.slice(0, maxResults).map((h) => h.memory);
   }
-  async writeEntity(name, type, facts) {
+  async writeEntity(name, type, facts, options = {}) {
     await this.ensureDirectories();
     if (typeof name !== "string" || !name.trim() || typeof type !== "string" || !type.trim()) {
       log.warn("writeEntity: invalid entity payload, skipping", {
@@ -2119,34 +3420,93 @@ ${sanitized.text}
       });
       return "";
     }
-    const safeFacts = Array.isArray(facts) ? facts.filter((f) => typeof f === "string") : [];
+    const safeFacts = Array.isArray(facts) ? [...new Set(
+      facts.filter((fact) => typeof fact === "string").map((fact) => fact.trim()).filter((fact) => fact.length > 0)
+    )] : [];
     let normalized = normalizeEntityName(name, type);
     const match = await this.findMatchingEntity(name, type);
     if (match && match !== normalized) {
       log.debug(`fuzzy match: "${normalized}" \u2192 existing "${match}"`);
       normalized = match;
     }
-    const filePath = path4.join(this.entitiesDir, `${normalized}.md`);
+    const filePath = path5.join(this.entitiesDir, `${normalized}.md`);
     let entity = {
       name,
       type,
+      created: "",
       updated: (/* @__PURE__ */ new Date()).toISOString(),
       facts: [],
       summary: void 0,
+      synthesis: void 0,
+      synthesisUpdatedAt: void 0,
+      synthesisVersion: void 0,
+      synthesisStructuredFactCount: void 0,
+      synthesisStructuredFactDigest: void 0,
+      timeline: [],
       relationships: [],
       activity: [],
       aliases: []
     };
     try {
-      const existing = await readFile2(filePath, "utf-8");
-      entity = parseEntityFile(existing);
+      const existing = await readFile3(filePath, "utf-8");
+      entity = parseEntityFile(existing, this.entitySchemas);
     } catch {
     }
-    entity.facts = [.../* @__PURE__ */ new Set([...entity.facts, ...safeFacts])];
+    const timestamp = options.timestamp?.trim() || (/* @__PURE__ */ new Date()).toISOString();
+    const source = options.source?.trim() || void 0;
+    const sessionKey = options.sessionKey?.trim() || void 0;
+    const principal = options.principal?.trim() || void 0;
+    const structuredSectionMap = new Map(
+      (entity.structuredSections ?? []).map((section) => [section.key, {
+        ...section,
+        facts: [...section.facts]
+      }])
+    );
+    for (const section of options.structuredSections ?? []) {
+      const normalizedSection = normalizeEntityStructuredSection(type, section, this.entitySchemas);
+      const normalizedFacts = normalizeStructuredSectionFacts(section.facts);
+      if (normalizedFacts.length === 0) continue;
+      const existingSection = structuredSectionMap.get(normalizedSection.key);
+      if (!existingSection) {
+        structuredSectionMap.set(normalizedSection.key, {
+          key: normalizedSection.key,
+          title: normalizedSection.title,
+          facts: normalizedFacts
+        });
+        continue;
+      }
+      existingSection.facts = normalizeStructuredSectionFacts([...existingSection.facts, ...normalizedFacts]);
+      if (!existingSection.title.trim() && normalizedSection.title.trim()) {
+        existingSection.title = normalizedSection.title;
+      }
+    }
+    for (const fact of safeFacts) {
+      const nextEntry = {
+        timestamp,
+        text: fact,
+        ...source ? { source } : {},
+        ...sessionKey ? { sessionKey } : {},
+        ...principal ? { principal } : {}
+      };
+      const alreadyPresent = entity.timeline.some(
+        (entry) => entry.timestamp === nextEntry.timestamp && entry.text === nextEntry.text && entry.source === nextEntry.source && entry.sessionKey === nextEntry.sessionKey && entry.principal === nextEntry.principal
+      );
+      if (alreadyPresent) continue;
+      entity.timeline.push(nextEntry);
+    }
+    entity.structuredSections = sortStructuredSectionsBySchema(
+      type,
+      Array.from(structuredSectionMap.values()).filter((section) => section.facts.length > 0),
+      this.entitySchemas
+    );
+    entity.facts = compileEntityFacts(entity.timeline, entity.structuredSections);
+    entity.summary = entity.synthesis || entity.summary;
     entity.name = name;
     entity.type = type;
+    entity.created = entity.created || timestamp;
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
+    await this.snapshotBeforeWrite(filePath, "write");
+    await writeFile3(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
     this.bumpMemoryStatusVersion();
     log.debug(`wrote entity ${normalized}`);
@@ -2154,14 +3514,15 @@ ${sanitized.text}
   }
   async readProfile() {
     try {
-      return await readFile2(this.profilePath, "utf-8");
+      return await readFile3(this.profilePath, "utf-8");
     } catch {
       return "";
     }
   }
   async writeProfile(content) {
     await this.ensureDirectories();
-    await writeFile2(this.profilePath, content, "utf-8");
+    await this.snapshotBeforeWrite(this.profilePath, "consolidation");
+    await writeFile3(this.profilePath, content, "utf-8");
     log.debug("updated profile.md");
   }
   /**
@@ -2249,12 +3610,51 @@ ${sanitized.text}
   static clearAllStaticCaches() {
     _StorageManager.allMemoriesInFlight.clear();
     _StorageManager.questionsCache.clear();
+    _StorageManager.coldMemoriesCache.clear();
   }
   /** Cancel any in-flight concurrent read so the next readAllMemories()
-   *  starts a fresh disk scan and sees the just-written data. */
+   *  starts a fresh disk scan and sees the just-written data.
+   *
+   *  Finding UvBq (PR #402 round-11): this method intentionally does NOT
+   *  invalidate the cold-scan cache.  Ordinary hot-tier writes (writeMemory)
+   *  do not change cold-tier content, so evicting the cold cache on every hot
+   *  write was defeating the burst-dedup optimisation — the cold cache was
+   *  cleared before applyTemporalSupersession ran, causing a full cold-tree
+   *  disk scan on every write in a burst.  Cold cache invalidation is handled
+   *  exclusively by invalidateColdMemoriesCache(), which is called only when
+   *  cold content actually changes (hot→cold demotions, writeMemoryFileAtomic
+   *  inside cold/, archiveMemory, etc.). */
   invalidateAllMemoriesCache() {
     _StorageManager.allMemoriesInFlight.delete(this.baseDir);
   }
+  /**
+   * Invalidate the cold-scan cache for this storage root and bump the
+   * on-disk cold-version sentinel so that other processes (gateway, CLI) see
+   * the change immediately on their next readAllColdMemories() call.
+   *
+   * Must be called whenever a memory is written INTO the cold tier — hot→cold
+   * demotion, atomic writes inside cold/, archiving a cold memory, etc.
+   * NOT called on ordinary hot-tier writes (those don't change cold contents).
+   *
+   * Finding UvUy (PR #402 round-11): bumping the sentinel here makes the
+   * per-process in-memory cache safe across process boundaries.
+   */
+  invalidateColdMemoriesCache() {
+    const coldRoot = path5.join(this.baseDir, "cold");
+    _StorageManager.coldMemoriesCache.delete(coldRoot);
+    this.bumpColdWriteVersion();
+  }
+  /** Return the current cold-write version counter for this storage root.
+   *  Reads the on-disk sentinel (state/cold-write.log) so it reflects writes
+   *  made by other processes. */
+  readColdWriteVersion() {
+    return this.readSharedVersion("cold-write", _StorageManager.coldWriteVersionByDir);
+  }
+  /** Bump the on-disk cold-write version sentinel and update the in-process
+   *  fallback map.  Called by invalidateColdMemoriesCache(). */
+  bumpColdWriteVersion() {
+    this.bumpSharedVersion("cold-write", _StorageManager.coldWriteVersionByDir);
+  }
   normalizeMemoryReadBatchSize(batchSize) {
     if (typeof batchSize !== "number" || !Number.isFinite(batchSize)) {
       return 50;
@@ -2268,7 +3668,7 @@ ${sanitized.text}
         const entries = await readdir(dir, { withFileTypes: true });
         const subdirs = [];
         for (const entry of entries) {
-          const fullPath = path4.join(dir, entry.name);
+          const fullPath = path5.join(dir, entry.name);
           if (entry.isDirectory()) {
             subdirs.push(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -2294,14 +3694,15 @@ ${sanitized.text}
       const results = await Promise.all(
         batch.map(async (fullPath) => {
           try {
-            const raw = await readFile2(fullPath, "utf-8");
+            const raw = await readFile3(fullPath, "utf-8");
             const parsed = parseFrontmatter2(raw);
             if (!parsed) return null;
             return {
               path: fullPath,
               frontmatter: normalizeFrontmatterForPath(
                 parsed.frontmatter,
-                toMemoryPathRel(this.baseDir, fullPath)
+                toMemoryPathRel(this.baseDir, fullPath),
+                parsed.content
               ),
               content: parsed.content
             };
@@ -2318,7 +3719,7 @@ ${sanitized.text}
   }
   async readWindowUpdatedMs(filePath) {
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile3(filePath, "utf-8");
       const match = raw.match(/^---\n([\s\S]*?)\n---\n?/);
       if (!match) return null;
       const frontmatterBlock = match[1];
@@ -2348,7 +3749,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path4.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path5.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -2430,6 +3831,62 @@ ${sanitized.text}
     const filePaths = await this.collectActiveMemoryPaths();
     return this.readParsedMemoriesFromPaths(filePaths, 50);
   }
+  /**
+   * Read all memories from the cold tier by scanning the entire cold/ root
+   * tree.  Previously this only scanned cold/facts/ and cold/corrections/, but
+   * structuredAttributes can appear on any MemoryCategory (preference, decision,
+   * entity, etc.).  Although buildTierMemoryPath currently routes all
+   * non-correction, non-artifact memories to cold/facts/, scanning the full
+   * coldRoot ensures correctness if that routing ever changes and guards against
+   * files placed in unexpected subdirectories during manual operations or future
+   * refactors.
+   *
+   * Broadened in PR #402 round-6 (Finding UTsP): scanning only facts/ and
+   * corrections/ was a narrower-than-necessary subset of the cold directory
+   * tree.  Correctness trumps the minor performance difference — cold scans
+   * already happen at most once per supersession write.
+   *
+   * Used by applyTemporalSupersession so that memories already demoted to
+   * cold/ can still be marked superseded when a newer hot fact arrives.
+   *
+   * Cached with a TTL (Finding UOGi, PR #402 round-6): back-to-back
+   * structured-attribute writes in the same burst reuse the cached result
+   * instead of re-scanning the cold tree on every call.  The cache is
+   * invalidated whenever a write calls invalidateAllMemoriesCache() (which
+   * covers any hot→cold demotion that changes cold-tier contents) and
+   * expires after COLD_SCAN_CACHE_TTL_MS as a safety net.
+   */
+  async readAllColdMemories() {
+    const coldRoot = this.resolveTierRootDir("cold");
+    const currentColdVersion = this.readColdWriteVersion();
+    const cached = _StorageManager.coldMemoriesCache.get(coldRoot);
+    if (cached && Date.now() - cached.loadedAt < _StorageManager.COLD_SCAN_CACHE_TTL_MS && cached.coldVersion === currentColdVersion) {
+      return cached.memories;
+    }
+    const filePaths = [];
+    const collectPaths = async (dir) => {
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        const subdirs = [];
+        for (const entry of entries) {
+          const fullPath = path5.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            subdirs.push(fullPath);
+          } else if (entry.name.endsWith(".md")) {
+            filePaths.push(fullPath);
+          }
+        }
+        for (const subdir of subdirs) {
+          await collectPaths(subdir);
+        }
+      } catch {
+      }
+    };
+    await collectPaths(coldRoot);
+    const memories = await this.readParsedMemoriesFromPaths(filePaths, 50);
+    _StorageManager.coldMemoriesCache.set(coldRoot, { memories, loadedAt: Date.now(), coldVersion: currentColdVersion });
+    return memories;
+  }
   /**
    * Read archived memory markdown files under archive/.
    * Used by long-term recall fallback when hot recall has no hits.
@@ -2441,19 +3898,20 @@ ${sanitized.text}
       try {
         const entries = await readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path4.join(dir, entry.name);
+          const fullPath = path5.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
             try {
-              const raw = await readFile2(fullPath, "utf-8");
+              const raw = await readFile3(fullPath, "utf-8");
               const parsed = parseFrontmatter2(raw);
               if (parsed) {
                 memories.push({
                   path: fullPath,
                   frontmatter: normalizeFrontmatterForPath(
                     parsed.frontmatter,
-                    toMemoryPathRel(this.baseDir, fullPath)
+                    toMemoryPathRel(this.baseDir, fullPath),
+                    parsed.content
                   ),
                   content: parsed.content
                 });
@@ -2471,23 +3929,24 @@ ${sanitized.text}
   /** Read a single memory file by its absolute path. Returns null if unreadable. */
   async readMemoryByPath(filePath) {
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile3(filePath, "utf-8");
       const parsed = parseFrontmatter2(raw);
       if (parsed) {
         return {
           path: filePath,
           frontmatter: normalizeFrontmatterForPath(
             parsed.frontmatter,
-            toMemoryPathRel(this.baseDir, filePath)
+            toMemoryPathRel(this.baseDir, filePath),
+            parsed.content
           ),
           content: parsed.content
         };
       }
-      const normalizedPath = filePath.split(path4.sep).join("/");
+      const normalizedPath = filePath.split(path5.sep).join("/");
       if (normalizedPath.includes("/entities/") && filePath.endsWith(".md")) {
-        const entity = parseEntityFile(raw);
+        const entity = parseEntityFile(raw, this.entitySchemas);
         if (!entity.name) return null;
-        const nameWithoutExt = path4.basename(filePath, ".md");
+        const nameWithoutExt = path5.basename(filePath, ".md");
         const fileMtime = entity.updated || await stat2(filePath).then((s) => s.mtime.toISOString()).catch(() => (/* @__PURE__ */ new Date(0)).toISOString());
         return {
           path: filePath,
@@ -2510,7 +3969,7 @@ ${sanitized.text}
     }
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path4.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path5.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -2525,27 +3984,27 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path4.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path5.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path4.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path5.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
-    return path4.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path5.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
 
 ${memory.content}
 `;
-    await mkdir2(path4.dirname(targetPath), { recursive: true });
+    await mkdir3(path5.dirname(targetPath), { recursive: true });
     const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
     try {
-      await writeFile2(tempPath, fileContent, "utf-8");
+      await writeFile3(tempPath, fileContent, "utf-8");
       await rename(tempPath, targetPath);
       this.invalidateAllMemoriesCache();
     } catch (err) {
       try {
-        await unlink(tempPath);
+        await unlink2(tempPath);
       } catch {
       }
       throw err;
@@ -2553,11 +4012,11 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path4.resolve(memory.path);
-    const destPath = path4.resolve(targetPath);
+    const sourcePath = path5.resolve(memory.path);
+    const destPath = path5.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
-        await unlink(memory.path);
+        await unlink2(memory.path);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         if (!message.includes("ENOENT")) {
@@ -2569,15 +4028,15 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path4.resolve(memory.path);
-    const destPath = path4.resolve(targetPath);
+    const sourcePath = path5.resolve(memory.path);
+    const destPath = path5.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
     const existing = await this.readMemoryByPath(targetPath);
     if (existing?.frontmatter.id === memory.frontmatter.id) {
       try {
-        await unlink(memory.path);
+        await unlink2(memory.path);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         if (!message.includes("ENOENT")) {
@@ -2589,11 +4048,14 @@ ${memory.content}
     }
     await this.moveMemoryToPath(memory, targetPath);
     this.invalidateAllMemoriesCache();
+    if (targetTier === "cold") {
+      this.invalidateColdMemoriesCache();
+    }
     this.bumpMemoryStatusVersion();
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path4.join(this.baseDir, "archive");
+    return path5.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -2604,8 +4066,8 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path4.join(this.archiveDir, today);
-      await mkdir2(destDir, { recursive: true });
+      const destDir = path5.join(this.archiveDir, today);
+      await mkdir3(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
         status: "archived",
@@ -2616,9 +4078,9 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path4.join(destDir, path4.basename(memory.path));
-      await writeFile2(destPath, fileContent, "utf-8");
-      await unlink(memory.path);
+      const destPath = path5.join(destDir, path5.basename(memory.path));
+      await writeFile3(destPath, fileContent, "utf-8");
+      await unlink2(memory.path);
       this.invalidateAllMemoriesCache();
       await this.appendGeneratedMemoryLifecycleEventFailOpen(
         "storage.archiveMemory",
@@ -2653,7 +4115,7 @@ ${memory.content}
   }
   async readEntity(name) {
     try {
-      return await readFile2(path4.join(this.entitiesDir, `${name}.md`), "utf-8");
+      return await readFile3(path5.join(this.entitiesDir, `${name}.md`), "utf-8");
     } catch {
       return "";
     }
@@ -2707,7 +4169,7 @@ ${memory.content}
     const memory = memories.find((m) => m.frontmatter.id === id);
     if (!memory) return false;
     try {
-      await unlink(memory.path);
+      await unlink2(memory.path);
       this.invalidateAllMemoriesCache();
       this.bumpMemoryStatusVersion();
       log.debug(`invalidated memory ${id}`);
@@ -2738,7 +4200,7 @@ ${memory.content}
 
 ${sanitized.text}
 `;
-    await writeFile2(memory.path, fileContent, "utf-8");
+    await writeFile3(memory.path, fileContent, "utf-8");
     this.invalidateAllMemoriesCache();
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.updateMemory", {
       memoryId: id,
@@ -2770,8 +4232,11 @@ ${sanitized.text}
 
 ${memory.content}
 `;
-    await writeFile2(memory.path, fileContent, "utf-8");
+    await writeFile3(memory.path, fileContent, "utf-8");
     this.invalidateAllMemoriesCache();
+    if (memory.path.includes(`${path5.sep}cold${path5.sep}`)) {
+      this.invalidateColdMemoriesCache();
+    }
     await this.appendGeneratedMemoryLifecycleEventFailOpen(
       "storage.writeMemoryFrontmatter",
       {
@@ -2816,7 +4281,7 @@ ${memory.content}
       const expiresAt = new Date(m.frontmatter.expiresAt).getTime();
       if (expiresAt < now) {
         try {
-          await unlink(m.path);
+          await unlink2(m.path);
           deleted.push(m);
           log.debug(`cleaned expired memory ${m.frontmatter.id} (TTL expired)`);
         } catch {
@@ -2830,9 +4295,9 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path4.join(this.stateDir, "buffer.json");
+    const bufferPath = path5.join(this.stateDir, "buffer.json");
     try {
-      const raw = await readFile2(bufferPath, "utf-8");
+      const raw = await readFile3(bufferPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return { turns: [], lastExtractionAt: null, extractionCount: 0 };
@@ -2840,28 +4305,44 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path4.join(this.stateDir, "buffer.json");
-    await writeFile2(bufferPath, JSON.stringify(state, null, 2), "utf-8");
+    const bufferPath = path5.join(this.stateDir, "buffer.json");
+    await writeFile3(bufferPath, JSON.stringify(state, null, 2), "utf-8");
   }
   async loadMeta() {
-    const metaPath = path4.join(this.stateDir, "meta.json");
+    const metaPath = path5.join(this.stateDir, "meta.json");
     try {
-      const raw = await readFile2(metaPath, "utf-8");
-      return JSON.parse(raw);
+      const raw = await readFile3(metaPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return {
+        extractionCount: typeof parsed.extractionCount === "number" ? parsed.extractionCount : 0,
+        lastExtractionAt: parsed.lastExtractionAt ?? null,
+        lastConsolidationAt: parsed.lastConsolidationAt ?? null,
+        totalMemories: typeof parsed.totalMemories === "number" ? parsed.totalMemories : 0,
+        totalEntities: typeof parsed.totalEntities === "number" ? parsed.totalEntities : 0,
+        processedExtractionFingerprints: Array.isArray(
+          parsed.processedExtractionFingerprints
+        ) ? parsed.processedExtractionFingerprints.filter(
+          (entry) => entry && typeof entry === "object" && typeof entry.fingerprint === "string" && typeof entry.observedAt === "string"
+        ).map((entry) => ({
+          fingerprint: entry.fingerprint,
+          observedAt: entry.observedAt
+        })) : []
+      };
     } catch {
       return {
         extractionCount: 0,
         lastExtractionAt: null,
         lastConsolidationAt: null,
         totalMemories: 0,
-        totalEntities: 0
+        totalEntities: 0,
+        processedExtractionFingerprints: []
       };
     }
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path4.join(this.stateDir, "meta.json");
-    await writeFile2(metaPath, JSON.stringify(state, null, 2), "utf-8");
+    const metaPath = path5.join(this.stateDir, "meta.json");
+    await writeFile3(metaPath, JSON.stringify(state, null, 2), "utf-8");
   }
   async appendMemoryActionEvents(events) {
     if (events.length === 0) return 0;
@@ -2898,7 +4379,7 @@ ${memory.content}
     await this.ensureDirectories();
     let existingKeys = /* @__PURE__ */ new Set();
     try {
-      const raw = await readFile2(this.behaviorSignalsPath, "utf-8");
+      const raw = await readFile3(this.behaviorSignalsPath, "utf-8");
       const lines = raw.split("\n");
       for (const line of lines) {
         const row = line.trim();
@@ -2934,7 +4415,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path5.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await appendFile(filePath, lines, "utf-8");
@@ -2945,9 +4426,9 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path5.join(this.stateDir, "reextract-jobs.jsonl");
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile3(filePath, "utf-8");
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
       const parsed = [];
       for (const line of lines) {
@@ -2975,7 +4456,7 @@ ${memory.content}
     const cappedLimit = Math.max(0, Math.floor(limit));
     if (cappedLimit === 0) return [];
     try {
-      const raw = await readFile2(this.behaviorSignalsPath, "utf-8");
+      const raw = await readFile3(this.behaviorSignalsPath, "utf-8");
       const out = [];
       const lines = raw.split("\n");
       for (let i = lines.length - 1; i >= 0 && out.length < cappedLimit; i -= 1) {
@@ -2998,7 +4479,7 @@ ${memory.content}
     const cappedLimit = Math.max(0, Math.floor(limit));
     if (cappedLimit === 0) return [];
     try {
-      const raw = await readFile2(this.memoryActionsPath, "utf-8");
+      const raw = await readFile3(this.memoryActionsPath, "utf-8");
       const out = [];
       const lines = raw.split("\n");
       for (let i = lines.length - 1; i >= 0 && out.length < cappedLimit; i -= 1) {
@@ -3019,7 +4500,7 @@ ${memory.content}
   }
   async readAllMemoryLifecycleEvents() {
     try {
-      const raw = await readFile2(this.memoryLifecycleLedgerPath, "utf-8");
+      const raw = await readFile3(this.memoryLifecycleLedgerPath, "utf-8");
       const out = [];
       const lines = raw.split("\n");
       for (const line of lines) {
@@ -3046,34 +4527,34 @@ ${memory.content}
   }
   async writeCompressionGuidelines(content) {
     await this.ensureDirectories();
-    await writeFile2(this.compressionGuidelinesPath, content, "utf-8");
+    await writeFile3(this.compressionGuidelinesPath, content, "utf-8");
   }
   async readCompressionGuidelines() {
     try {
-      return await readFile2(this.compressionGuidelinesPath, "utf-8");
+      return await readFile3(this.compressionGuidelinesPath, "utf-8");
     } catch {
       return null;
     }
   }
   async writeCompressionGuidelineDraft(content) {
     await this.ensureDirectories();
-    await writeFile2(this.compressionGuidelineDraftPath, content, "utf-8");
+    await writeFile3(this.compressionGuidelineDraftPath, content, "utf-8");
   }
   async readCompressionGuidelineDraft() {
     try {
-      return await readFile2(this.compressionGuidelineDraftPath, "utf-8");
+      return await readFile3(this.compressionGuidelineDraftPath, "utf-8");
     } catch {
       return null;
     }
   }
   async writeCompressionGuidelineOptimizerState(state) {
     await this.ensureDirectories();
-    await writeFile2(this.compressionGuidelineStatePath, `${JSON.stringify(state, null, 2)}
+    await writeFile3(this.compressionGuidelineStatePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
   }
   async writeCompressionGuidelineDraftState(state) {
     await this.ensureDirectories();
-    await writeFile2(this.compressionGuidelineDraftStatePath, `${JSON.stringify(state, null, 2)}
+    await writeFile3(this.compressionGuidelineDraftStatePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
   }
   async readCompressionGuidelineOptimizerState() {
@@ -3095,8 +4576,8 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash("sha256").update(draftContent).digest("hex");
-      if (contentHash !== draftState.contentHash) return false;
+      const contentHash2 = createHash2("sha256").update(draftContent).digest("hex");
+      if (contentHash2 !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
     await this.writeCompressionGuidelineOptimizerState({
@@ -3104,8 +4585,8 @@ ${memory.content}
       activationState: "active"
     });
     await Promise.all([
-      unlink(this.compressionGuidelineDraftPath).catch(() => void 0),
-      unlink(this.compressionGuidelineDraftStatePath).catch(() => void 0)
+      unlink2(this.compressionGuidelineDraftPath).catch(() => void 0),
+      unlink2(this.compressionGuidelineDraftStatePath).catch(() => void 0)
     ]);
     return true;
   }
@@ -3122,12 +4603,12 @@ ${memory.content}
       return typeof rule.action === "string" && typeof rule.delta === "number" && Number.isFinite(rule.delta) && (rule.direction === "increase" || rule.direction === "decrease" || rule.direction === "hold") && (rule.confidence === "low" || rule.confidence === "medium" || rule.confidence === "high") && Array.isArray(rule.notes) && rule.notes.every((note) => typeof note === "string");
     };
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile3(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       const sourceWindow = parsed?.sourceWindow;
       const eventCounts = parsed?.eventCounts;
       const activationState = parsed?.activationState === "draft" || parsed?.activationState === "active" ? parsed.activationState : void 0;
-      const contentHash = typeof parsed?.contentHash === "string" && parsed.contentHash.length > 0 ? parsed.contentHash : void 0;
+      const contentHash2 = typeof parsed?.contentHash === "string" && parsed.contentHash.length > 0 ? parsed.contentHash : void 0;
       const actionSummaries = Array.isArray(parsed?.actionSummaries) ? parsed.actionSummaries.filter(isValidActionSummary) : void 0;
       const ruleUpdates = Array.isArray(parsed?.ruleUpdates) ? parsed.ruleUpdates.filter(isValidRuleUpdate) : void 0;
       if (!isFiniteNonNegativeInteger(parsed?.version) || typeof parsed?.updatedAt !== "string" || parsed.updatedAt.length === 0 || !sourceWindow || typeof sourceWindow.from !== "string" || sourceWindow.from.length === 0 || typeof sourceWindow.to !== "string" || sourceWindow.to.length === 0 || !eventCounts || !isFiniteNonNegativeInteger(eventCounts.total) || !isFiniteNonNegativeInteger(eventCounts.applied) || !isFiniteNonNegativeInteger(eventCounts.skipped) || !isFiniteNonNegativeInteger(eventCounts.failed) || !isFiniteNonNegativeInteger(parsed?.guidelineVersion)) {
@@ -3147,7 +4628,7 @@ ${memory.content}
           failed: eventCounts.failed
         },
         guidelineVersion: parsed.guidelineVersion,
-        ...contentHash ? { contentHash } : {},
+        ...contentHash2 ? { contentHash: contentHash2 } : {},
         ...activationState ? { activationState } : {},
         ...actionSummaries ? { actionSummaries } : {},
         ...ruleUpdates ? { ruleUpdates } : {}
@@ -3158,11 +4639,11 @@ ${memory.content}
   }
   async writeIdentityAnchor(content) {
     await this.ensureDirectories();
-    await writeFile2(this.identityAnchorPath, content, "utf-8");
+    await writeFile3(this.identityAnchorPath, content, "utf-8");
   }
   async readIdentityAnchor() {
     try {
-      return await readFile2(this.identityAnchorPath, "utf-8");
+      return await readFile3(this.identityAnchorPath, "utf-8");
     } catch {
       return null;
     }
@@ -3174,8 +4655,8 @@ ${memory.content}
     const date = nowIso.slice(0, 10);
     const id = this.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path4.join(this.identityIncidentsDir, `${date}-${id}.md`);
-    await writeFile2(filePath, serializeContinuityIncident(incident), "utf-8");
+    const filePath = path5.join(this.identityIncidentsDir, `${date}-${id}.md`);
+    await writeFile3(filePath, serializeContinuityIncident(incident), "utf-8");
     return { ...incident, filePath };
   }
   async readContinuityIncidents(limit = 200, state = "all") {
@@ -3187,9 +4668,9 @@ ${memory.content}
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path4.join(this.identityIncidentsDir, file);
+        const filePath = path5.join(this.identityIncidentsDir, file);
         try {
-          const raw = await readFile2(filePath, "utf-8");
+          const raw = await readFile3(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
           if (!parsed) continue;
           if (state !== "all" && parsed.state !== state) continue;
@@ -3208,33 +4689,33 @@ ${memory.content}
     if (!target || !directFilePath) return null;
     if (target.state === "closed") return target;
     const closed = closeContinuityIncidentRecord(target, closure, (/* @__PURE__ */ new Date()).toISOString());
-    await writeFile2(directFilePath, serializeContinuityIncident(closed), "utf-8");
+    await writeFile3(directFilePath, serializeContinuityIncident(closed), "utf-8");
     return { ...closed, filePath: directFilePath };
   }
   async writeIdentityAudit(period, key, content) {
     await this.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-    const filePath = path4.join(dir, `${safeKey}.md`);
-    await writeFile2(filePath, content, "utf-8");
+    const filePath = path5.join(dir, `${safeKey}.md`);
+    await writeFile3(filePath, content, "utf-8");
     return filePath;
   }
   async readIdentityAudit(period, key) {
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-      return await readFile2(path4.join(dir, `${safeKey}.md`), "utf-8");
+      return await readFile3(path5.join(dir, `${safeKey}.md`), "utf-8");
     } catch {
       return null;
     }
   }
   async writeIdentityImprovementLoops(content) {
     await this.ensureDirectories();
-    await writeFile2(this.identityImprovementLoopsPath, content, "utf-8");
+    await writeFile3(this.identityImprovementLoopsPath, content, "utf-8");
   }
   async readIdentityImprovementLoops() {
     try {
-      return await readFile2(this.identityImprovementLoopsPath, "utf-8");
+      return await readFile3(this.identityImprovementLoopsPath, "utf-8");
     } catch {
       return null;
     }
@@ -3272,7 +4753,7 @@ ${memory.content}
   }
   async readContinuityIncidentFile(filePath) {
     try {
-      const raw = await readFile2(filePath, "utf-8");
+      const raw = await readFile3(filePath, "utf-8");
       const parsed = parseContinuityIncident(raw);
       return parsed ? { ...parsed, filePath } : null;
     } catch {
@@ -3283,12 +4764,12 @@ ${memory.content}
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path4.join(this.identityIncidentsDir, directMatch);
+      const directPath = path5.join(this.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path4.join(this.identityIncidentsDir, fileName);
+      const filePath = path5.join(this.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -3302,7 +4783,7 @@ ${memory.content}
     return trimmed;
   }
   async writeQuestion(question, context, priority) {
-    await mkdir2(this.questionsDir, { recursive: true });
+    await mkdir3(this.questionsDir, { recursive: true });
     const id = this.generateId("q");
     const frontmatter = {
       id,
@@ -3318,8 +4799,8 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path4.join(this.questionsDir, `${id}.md`);
-    await writeFile2(filePath, content, "utf-8");
+    const filePath = path5.join(this.questionsDir, `${id}.md`);
+    await writeFile3(filePath, content, "utf-8");
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
     return id;
@@ -3342,8 +4823,8 @@ ${question}
       const questions = [];
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path4.join(this.questionsDir, file);
-        const raw = await readFile2(filePath, "utf-8");
+        const filePath = path5.join(this.questionsDir, file);
+        const raw = await readFile3(filePath, "utf-8");
         const parsed = this.parseQuestionFile(raw, filePath);
         if (parsed) {
           questions.push(parsed);
@@ -3365,7 +4846,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path4.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path5.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(
       this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5"
@@ -3386,7 +4867,7 @@ ${question}
     const questions = await this.readQuestions();
     const q = questions.find((q2) => q2.id === id);
     if (!q) return false;
-    let raw = await readFile2(q.filePath, "utf-8");
+    let raw = await readFile3(q.filePath, "utf-8");
     raw = raw.replace(/resolved: false/, "resolved: true");
     raw = raw.replace(
       /---\n\n/,
@@ -3395,7 +4876,7 @@ ${question}
 
 `
     );
-    await writeFile2(q.filePath, raw, "utf-8");
+    await writeFile3(q.filePath, raw, "utf-8");
     log.debug(`resolved question ${id}`);
     return true;
   }
@@ -3405,14 +4886,14 @@ ${question}
   async readIdentity(workspaceDir, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
     try {
-      return await readFile2(identityPath, "utf-8");
+      return await readFile3(identityPath, "utf-8");
     } catch {
       return "";
     }
   }
   async writeIdentity(workspaceDir, content, namespace) {
     const identityPath = this.identityFilePath(workspaceDir, namespace);
-    await writeFile2(identityPath, content, "utf-8");
+    await writeFile3(identityPath, content, "utf-8");
     log.debug(`wrote consolidated IDENTITY.md (${content.length} chars)`);
   }
   /** Max size for IDENTITY.md before we stop appending reflections (15KB leaves room under 20KB gateway limit) */
@@ -3423,22 +4904,22 @@ ${question}
     const identityPath = this.identityFilePath(workspaceDir, opts?.namespace);
     let existing = "";
     try {
-      existing = await readFile2(identityPath, "utf-8");
+      existing = await readFile3(identityPath, "utf-8");
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path4.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path5.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path4.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path5.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
           archivePrefix: "IDENTITY",
           keepTailChars: hygiene.rotateKeepTailChars
         });
-        await writeFile2(identityPath, newContent, "utf-8");
+        await writeFile3(identityPath, newContent, "utf-8");
         existing = newContent;
         log.info(
           `rotated IDENTITY.md to archive (size=${existing.length} chars, maxBytes=${maxBytes})`
@@ -3469,24 +4950,24 @@ ${question}
 
 ${reflection}
 `;
-    await writeFile2(identityPath, existing + section, "utf-8");
+    await writeFile3(identityPath, existing + section, "utf-8");
     log.debug(`appended reflection to ${identityPath}`);
   }
   async readIdentityReflections() {
     try {
-      return await readFile2(this.identityReflectionsPath, "utf-8");
+      return await readFile3(this.identityReflectionsPath, "utf-8");
     } catch {
       return null;
     }
   }
   async writeIdentityReflections(content) {
-    await mkdir2(this.identityDir, { recursive: true });
-    await writeFile2(this.identityReflectionsPath, content, "utf-8");
+    await mkdir3(this.identityDir, { recursive: true });
+    await writeFile3(this.identityReflectionsPath, content, "utf-8");
   }
   async appendIdentityReflection(reflection) {
     let existing = "";
     try {
-      existing = await readFile2(this.identityReflectionsPath, "utf-8");
+      existing = await readFile3(this.identityReflectionsPath, "utf-8");
     } catch {
     }
     if (existing.length > _StorageManager.IDENTITY_MAX_BYTES) {
@@ -3511,8 +4992,8 @@ ${reflection}
 
 ${reflection}
 `;
-    await mkdir2(this.identityDir, { recursive: true });
-    await writeFile2(this.identityReflectionsPath, `${existing.trimEnd()}${section}`, "utf-8");
+    await mkdir3(this.identityDir, { recursive: true });
+    await writeFile3(this.identityReflectionsPath, `${existing.trimEnd()}${section}`, "utf-8");
     log.debug(`appended namespace-local reflection to ${this.identityReflectionsPath}`);
   }
   // ---------------------------------------------------------------------------
@@ -3523,11 +5004,11 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
-      const content = await readFile2(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      const content = await readFile3(filePath, "utf-8");
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityRelationship: entity file ${name}.md not found`);
       return;
@@ -3538,7 +5019,7 @@ ${reflection}
     if (exists) return;
     entity.relationships.push(rel);
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile3(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
   }
   /**
@@ -3546,11 +5027,11 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
-      const content = await readFile2(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      const content = await readFile3(filePath, "utf-8");
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityActivity: entity file ${name}.md not found`);
       return;
@@ -3560,18 +5041,18 @@ ${reflection}
       entity.activity = entity.activity.slice(0, maxEntries);
     }
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile3(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
   }
   /**
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
-      const content = await readFile2(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      const content = await readFile3(filePath, "utf-8");
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityAlias: entity file ${name}.md not found`);
       return;
@@ -3579,28 +5060,142 @@ ${reflection}
     if (entity.aliases.includes(alias)) return;
     entity.aliases.push(alias);
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile3(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
   }
   /**
-   * Set or update the summary of an entity file.
+   * Set or rewrite the synthesis layer of an entity file.
    */
-  async updateEntitySummary(name, summary) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+  async updateEntitySynthesis(name, synthesis, options = {}) {
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
-      const content = await readFile2(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      const content = await readFile3(filePath, "utf-8");
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
-      log.debug(`updateEntitySummary: entity file ${name}.md not found`);
+      log.debug(`updateEntitySynthesis: entity file ${name}.md not found`);
       return;
     }
-    entity.summary = summary;
-    entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
+    const updatedAt = options.updatedAt?.trim() || entity.synthesisUpdatedAt?.trim() || void 0;
+    const entityUpdatedAt = options.entityUpdatedAt?.trim() || updatedAt || entity.updated || (/* @__PURE__ */ new Date()).toISOString();
+    const synthesisTimelineCount = Number.isInteger(options.synthesisTimelineCount) && (options.synthesisTimelineCount ?? 0) >= 0 ? options.synthesisTimelineCount : void 0;
+    const synthesisStructuredFactCount = Number.isInteger(options.synthesisStructuredFactCount) && (options.synthesisStructuredFactCount ?? 0) >= 0 ? options.synthesisStructuredFactCount : countEntityStructuredFacts(entity);
+    const synthesisStructuredFactDigest = options.synthesisStructuredFactDigest?.trim() || fingerprintEntityStructuredFacts(entity);
+    entity.synthesis = synthesis.trim();
+    entity.summary = entity.synthesis;
+    entity.synthesisUpdatedAt = updatedAt;
+    entity.synthesisTimelineCount = synthesisTimelineCount;
+    entity.synthesisStructuredFactCount = synthesisStructuredFactCount;
+    entity.synthesisStructuredFactDigest = synthesisStructuredFactDigest;
+    entity.synthesisVersion = Math.max(0, entity.synthesisVersion ?? 0) + (options.incrementVersion === false ? 0 : 1);
+    entity.updated = entityUpdatedAt;
+    await writeFile3(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
+    await this.removeEntitySynthesisQueueEntries([
+      .../* @__PURE__ */ new Set([name, normalizeEntityName(entity.name, entity.type)])
+    ]);
     this.invalidateKnowledgeIndexCache();
     this.bumpMemoryStatusVersion();
   }
+  /**
+   * Backward-compatible alias for legacy callers/tests.
+   */
+  async updateEntitySummary(name, summary) {
+    const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    let synthesisTimelineCount;
+    try {
+      const filePath = path5.join(this.entitiesDir, `${name}.md`);
+      const content = await readFile3(filePath, "utf-8");
+      synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
+    } catch {
+      synthesisTimelineCount = void 0;
+    }
+    await this.updateEntitySynthesis(name, summary, {
+      entityUpdatedAt: updatedAt,
+      synthesisTimelineCount,
+      updatedAt
+    });
+  }
+  async readEntitySynthesisQueue() {
+    try {
+      const raw = await readFile3(this.entitySynthesisQueuePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed.entityNames) ? parsed.entityNames.filter((value) => typeof value === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  async refreshEntitySynthesisQueue() {
+    const entityNames = await this.listEntityNames();
+    const entityQueueEntries = await Promise.all(
+      entityNames.map(async (entityName) => {
+        const raw = await this.readEntity(entityName);
+        if (!raw) return null;
+        return {
+          entityName,
+          entity: parseEntityFile(raw, this.entitySchemas)
+        };
+      })
+    );
+    const staleEntityNames = entityQueueEntries.filter((entry) => entry !== null).filter(({ entity }) => isEntitySynthesisStale(entity)).sort((left, right) => {
+      const leftTs = latestEntityTimelineTimestamp(left.entity) ?? "";
+      const rightTs = latestEntityTimelineTimestamp(right.entity) ?? "";
+      return compareEntityTimestamps(rightTs, leftTs);
+    }).map(({ entityName }) => entityName);
+    await mkdir3(this.stateDir, { recursive: true });
+    await writeFile3(
+      this.entitySynthesisQueuePath,
+      JSON.stringify(
+        {
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          entityNames: staleEntityNames
+        },
+        null,
+        2
+      ) + "\n",
+      "utf-8"
+    );
+    return staleEntityNames;
+  }
+  async removeEntitySynthesisQueueEntries(entityNames) {
+    if (entityNames.length === 0) return;
+    const queue = await this.readEntitySynthesisQueue();
+    if (queue.length === 0) return;
+    const removals = new Set(entityNames);
+    const nextQueue = queue.filter((name) => !removals.has(name));
+    await mkdir3(this.stateDir, { recursive: true });
+    await writeFile3(
+      this.entitySynthesisQueuePath,
+      JSON.stringify(
+        {
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          entityNames: nextQueue
+        },
+        null,
+        2
+      ) + "\n",
+      "utf-8"
+    );
+  }
+  async migrateEntityFilesToCompiledTruthTimeline() {
+    const entityNames = await this.listEntityNames();
+    let migrated = 0;
+    for (const entityName of entityNames) {
+      const raw = await this.readEntity(entityName);
+      if (!raw) continue;
+      const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
+      if (raw.trimEnd() === serialized.trimEnd()) continue;
+      await writeFile3(path5.join(this.entitiesDir, `${entityName}.md`), serialized, "utf-8");
+      migrated += 1;
+    }
+    if (migrated > 0) {
+      this.invalidateKnowledgeIndexCache();
+      this.bumpMemoryStatusVersion();
+    }
+    return {
+      total: entityNames.length,
+      migrated
+    };
+  }
   // ---------------------------------------------------------------------------
   // Scoring + Knowledge Index (Knowledge Graph v7.0)
   // ---------------------------------------------------------------------------
@@ -3610,7 +5205,8 @@ ${reflection}
    */
   async readAllEntityFiles() {
     const currentVersion = this.getMemoryStatusVersion();
-    const cached = getCachedEntities(this.baseDir, currentVersion);
+    const schemaCacheKey = buildEntitySchemaCacheKey(this.entitySchemas);
+    const cached = getCachedEntities(this.baseDir, currentVersion, schemaCacheKey);
     if (cached) return cached;
     try {
       const entries = await readdir(this.entitiesDir);
@@ -3622,14 +5218,14 @@ ${reflection}
         const batch = mdFiles.slice(i, i + BATCH_SIZE);
         const results = await Promise.all(
           batch.map(
-            (entry) => readFile2(path4.join(this.entitiesDir, entry), "utf-8").catch(() => null)
+            (entry) => readFile3(path5.join(this.entitiesDir, entry), "utf-8").catch(() => null)
           )
         );
         for (const content of results) {
-          if (content !== null) entities.push(parseEntityFile(content));
+          if (content !== null) entities.push(parseEntityFile(content, this.entitySchemas));
         }
       }
-      setCachedEntities(this.baseDir, entities, currentVersion);
+      setCachedEntities(this.baseDir, entities, currentVersion, schemaCacheKey);
       return entities;
     } catch {
       return [];
@@ -3679,7 +5275,7 @@ ${reflection}
       type: e.type,
       score: _StorageManager.scoreEntity(e, now),
       factCount: e.facts.length,
-      summary: e.summary,
+      summary: e.synthesis ?? e.summary,
       topRelationships: e.relationships.slice(0, 3).map((r) => r.target)
     }));
     scored.sort((a, b) => b.score - a.score);
@@ -3742,38 +5338,121 @@ ${rows.join("\n")}
         const mergedEntity = {
           name: "",
           type: "other",
+          created: "",
           updated: "",
+          extraFrontmatterLines: [],
+          preSectionLines: [],
           facts: [],
           summary: void 0,
+          synthesis: void 0,
+          synthesisUpdatedAt: void 0,
+          synthesisTimelineCount: void 0,
+          synthesisStructuredFactCount: void 0,
+          synthesisStructuredFactDigest: void 0,
+          synthesisVersion: void 0,
+          timeline: [],
           relationships: [],
           activity: [],
-          aliases: []
+          aliases: [],
+          structuredSections: [],
+          extraSections: []
         };
         for (const file of files) {
-          const filePath = path4.join(this.entitiesDir, file);
+          const filePath = path5.join(this.entitiesDir, file);
           try {
-            const content = await readFile2(filePath, "utf-8");
-            const parsed = parseEntityFile(content);
+            const content = await readFile3(filePath, "utf-8");
+            const parsed = parseEntityFile(content, this.entitySchemas);
             if (!mergedEntity.type || mergedEntity.type === "other") {
               mergedEntity.type = parsed.type;
             }
-            if (!mergedEntity.updated || parsed.updated > mergedEntity.updated) {
+            if (!mergedEntity.updated || compareEntityTimestamps(parsed.updated, mergedEntity.updated) > 0) {
               mergedEntity.updated = parsed.updated;
             }
+            const parsedCreated = parsed.created || parsed.updated;
+            const mergedCreated = mergedEntity.created?.trim() || "";
+            const parsedCreatedMs = parsedCreated ? Date.parse(parsedCreated) : Number.NaN;
+            const mergedCreatedMs = mergedCreated ? Date.parse(mergedCreated) : Number.NaN;
+            const parsedCreatedIsValid = Number.isFinite(parsedCreatedMs);
+            const mergedCreatedIsValid = Number.isFinite(mergedCreatedMs);
+            if (parsedCreated && (!mergedCreated || parsedCreatedIsValid && !mergedCreatedIsValid || parsedCreatedIsValid && mergedCreatedIsValid && parsedCreatedMs < mergedCreatedMs || !parsedCreatedIsValid && !mergedCreatedIsValid && compareEntityTimestamps(parsedCreated, mergedCreated) < 0)) {
+              mergedEntity.created = parsedCreated;
+            }
             if (parsed.name.length > mergedEntity.name.length) {
               mergedEntity.name = parsed.name;
             }
-            if (!mergedEntity.summary && parsed.summary) {
+            const parsedSynthesisUpdatedAt = parsed.synthesisUpdatedAt?.trim() || void 0;
+            const mergedSynthesisUpdatedAt = mergedEntity.synthesisUpdatedAt?.trim() || void 0;
+            if (parsed.synthesis && (!mergedEntity.synthesis || !mergedSynthesisUpdatedAt && Boolean(parsedSynthesisUpdatedAt) || Boolean(mergedSynthesisUpdatedAt) && Boolean(parsedSynthesisUpdatedAt) && compareEntityTimestamps(parsedSynthesisUpdatedAt, mergedSynthesisUpdatedAt) > 0)) {
+              mergedEntity.synthesis = parsed.synthesis;
+              mergedEntity.summary = parsed.synthesis;
+              mergedEntity.synthesisUpdatedAt = parsedSynthesisUpdatedAt;
+              mergedEntity.synthesisTimelineCount = parsed.synthesisTimelineCount;
+              mergedEntity.synthesisStructuredFactCount = parsed.synthesisStructuredFactCount;
+              mergedEntity.synthesisStructuredFactDigest = parsed.synthesisStructuredFactDigest;
+              mergedEntity.synthesisVersion = parsed.synthesisVersion;
+            } else if (!mergedEntity.summary && parsed.summary) {
               mergedEntity.summary = parsed.summary;
+              mergedEntity.synthesis = parsed.summary;
+              mergedEntity.synthesisUpdatedAt = parsedSynthesisUpdatedAt;
+              mergedEntity.synthesisTimelineCount = parsed.synthesisTimelineCount;
+              mergedEntity.synthesisStructuredFactCount = parsed.synthesisStructuredFactCount;
+              mergedEntity.synthesisStructuredFactDigest = parsed.synthesisStructuredFactDigest;
+              mergedEntity.synthesisVersion = parsed.synthesisVersion;
             }
-            mergedEntity.facts.push(...parsed.facts);
+            mergedEntity.timeline.push(...parsed.timeline);
             mergedEntity.relationships.push(...parsed.relationships);
             mergedEntity.activity.push(...parsed.activity);
             mergedEntity.aliases.push(...parsed.aliases);
+            const mergedStructuredSectionMap = new Map(
+              (mergedEntity.structuredSections ?? []).map((section) => [section.key, {
+                ...section,
+                facts: [...section.facts]
+              }])
+            );
+            for (const section of parsed.structuredSections ?? []) {
+              const existingSection = mergedStructuredSectionMap.get(section.key);
+              if (!existingSection) {
+                mergedStructuredSectionMap.set(section.key, {
+                  key: section.key,
+                  title: section.title,
+                  facts: [...new Set(section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0))]
+                });
+                continue;
+              }
+              const mergedFacts = new Set(existingSection.facts.map((fact) => fact.trim()));
+              for (const fact of section.facts) {
+                const trimmed = fact.trim();
+                if (!trimmed) continue;
+                mergedFacts.add(trimmed);
+              }
+              existingSection.facts = Array.from(mergedFacts);
+              if (!existingSection.title.trim() && section.title.trim()) {
+                existingSection.title = section.title;
+              }
+            }
+            mergedEntity.structuredSections = Array.from(mergedStructuredSectionMap.values());
+            mergedEntity.extraFrontmatterLines.push(...parsed.extraFrontmatterLines ?? []);
+            mergedEntity.preSectionLines.push(...parsed.preSectionLines ?? []);
+            mergedEntity.extraSections.push(...(parsed.extraSections ?? []).map((section) => ({
+              title: section.title,
+              lines: [...section.lines]
+            })));
           } catch {
           }
         }
-        mergedEntity.facts = [...new Set(mergedEntity.facts)];
+        const timelineKeys = /* @__PURE__ */ new Set();
+        mergedEntity.timeline = mergedEntity.timeline.filter((entry) => {
+          const key = JSON.stringify([
+            entry.timestamp,
+            entry.source ?? "",
+            entry.sessionKey ?? "",
+            entry.principal ?? "",
+            entry.text
+          ]);
+          if (timelineKeys.has(key)) return false;
+          timelineKeys.add(key);
+          return true;
+        });
         const relKeys = /* @__PURE__ */ new Set();
         mergedEntity.relationships = mergedEntity.relationships.filter((r) => {
           const key = `${r.target}::${r.label}`;
@@ -3789,18 +5468,32 @@ ${rows.join("\n")}
           return true;
         }).sort((a, b) => b.date.localeCompare(a.date));
         mergedEntity.aliases = [...new Set(mergedEntity.aliases)];
+        mergedEntity.structuredSections = sortStructuredSectionsBySchema(
+          mergedEntity.type,
+          mergedEntity.structuredSections ?? [],
+          this.entitySchemas
+        );
+        mergedEntity.facts = compileEntityFacts(mergedEntity.timeline, mergedEntity.structuredSections);
+        const extraSectionKeys = /* @__PURE__ */ new Set();
+        mergedEntity.extraSections = (mergedEntity.extraSections ?? []).filter((section) => {
+          const key = `${section.title}::${section.lines.join("\n")}`;
+          if (extraSectionKeys.has(key)) return false;
+          extraSectionKeys.add(key);
+          return true;
+        });
         if (!mergedEntity.name) {
           const dashIdx = canonical.indexOf("-");
           mergedEntity.name = dashIdx !== -1 ? canonical.slice(dashIdx + 1) : canonical;
         }
+        mergedEntity.created = mergedEntity.created || mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
         mergedEntity.updated = mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
-        const canonicalPath = path4.join(this.entitiesDir, `${canonical}.md`);
-        await writeFile2(canonicalPath, serializeEntityFile(mergedEntity), "utf-8");
+        const canonicalPath = path5.join(this.entitiesDir, `${canonical}.md`);
+        await writeFile3(canonicalPath, serializeEntityFile(mergedEntity, this.entitySchemas), "utf-8");
         for (const file of files) {
-          const filePath = path4.join(this.entitiesDir, file);
+          const filePath = path5.join(this.entitiesDir, file);
           if (filePath !== canonicalPath) {
             try {
-              await unlink(filePath);
+              await unlink2(filePath);
               merged++;
               log.debug(`merged entity ${file} \u2192 ${canonical}.md`);
             } catch {
@@ -3825,7 +5518,7 @@ ${rows.join("\n")}
       const updatedAt = new Date(m.frontmatter.updated).getTime();
       if (updatedAt < cutoff) {
         try {
-          await unlink(m.path);
+          await unlink2(m.path);
           deleted.push(m);
           log.debug(`cleaned expired commitment ${m.frontmatter.id}`);
         } catch {
@@ -3862,7 +5555,7 @@ ${rows.join("\n")}
 ${memory.content}
 `;
       try {
-        await writeFile2(memory.path, fileContent, "utf-8");
+        await writeFile3(memory.path, fileContent, "utf-8");
         updated++;
       } catch (err) {
         log.debug(`failed to update access tracking for ${entry.memoryId}: ${err}`);
@@ -3880,6 +5573,29 @@ ${memory.content}
     const memories = await this.readAllMemories();
     return memories.find((m) => m.frontmatter.id === id) ?? null;
   }
+  /**
+   * Check which of the given memory IDs actually exist on disk.
+   *
+   * Uses a lightweight directory scan (collectActiveMemoryPaths) that reads
+   * file names without parsing frontmatter — much cheaper than readAllMemories()
+   * for simple existence checks like citation usage tracking.
+   *
+   * Returns the subset of `ids` that correspond to real memory files.
+   */
+  async filterExistingMemoryIds(ids) {
+    if (ids.length === 0) return /* @__PURE__ */ new Set();
+    const wantedIds = new Set(ids);
+    const filePaths = await this.collectActiveMemoryPaths();
+    const foundIds = /* @__PURE__ */ new Set();
+    for (const filePath of filePaths) {
+      const basename = path5.basename(filePath, ".md");
+      if (wantedIds.has(basename)) {
+        foundIds.add(basename);
+        if (foundIds.size === wantedIds.size) break;
+      }
+    }
+    return foundIds;
+  }
   async getProjectedMemoryState(id) {
     const projected = readProjectedMemoryState(this.baseDir, id);
     if (projected) return projected;
@@ -3970,11 +5686,11 @@ ${sanitized.text}
 `;
     let filePath;
     if (category === "correction") {
-      filePath = path4.join(this.correctionsDir, `${id}.md`);
+      filePath = path5.join(this.correctionsDir, `${id}.md`);
     } else {
-      filePath = path4.join(this.factsDir, today, `${id}.md`);
+      filePath = path5.join(this.factsDir, today, `${id}.md`);
     }
-    await writeFile2(filePath, fileContent, "utf-8");
+    await writeFile3(filePath, fileContent, "utf-8");
     log.debug(`wrote chunk ${id} (${chunkIndex + 1}/${chunkTotal}) to ${filePath}`);
     return id;
   }
@@ -4010,7 +5726,7 @@ ${sanitized.text}
 ${oldMemory.content}
 `;
     try {
-      await writeFile2(oldMemory.path, fileContent, "utf-8");
+      await writeFile3(oldMemory.path, fileContent, "utf-8");
       await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.supersedeMemory", {
         memoryId: oldMemoryId,
         eventType: "superseded",
@@ -4041,15 +5757,15 @@ Reason: ${reason}`, {
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path4.join(this.baseDir, "summaries");
+    return path5.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
-    await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path4.join(this.summariesDir, `${summary.id}.json`);
-    await writeFile2(filePath, JSON.stringify(summary, null, 2), "utf-8");
+    await mkdir3(this.summariesDir, { recursive: true });
+    const filePath = path5.join(this.summariesDir, `${summary.id}.json`);
+    await writeFile3(filePath, JSON.stringify(summary, null, 2), "utf-8");
     log.debug(`wrote summary ${summary.id}`);
   }
   /**
@@ -4061,8 +5777,8 @@ Reason: ${reason}`, {
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path4.join(this.summariesDir, file);
-        const raw = await readFile2(filePath, "utf-8");
+        const filePath = path5.join(this.summariesDir, file);
+        const raw = await readFile3(filePath, "utf-8");
         summaries.push(JSON.parse(raw));
       }
       return summaries;
@@ -4092,7 +5808,7 @@ Reason: ${reason}`, {
 ${memory.content}
 `;
       try {
-        await writeFile2(memory.path, fileContent, "utf-8");
+        await writeFile3(memory.path, fileContent, "utf-8");
         await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.archiveMemories", {
           memoryId: id,
           eventType: "archived",
@@ -4120,18 +5836,18 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path4.join(this.stateDir, "topics.json");
-    await mkdir2(this.stateDir, { recursive: true });
-    await writeFile2(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
+    const metaPath = path5.join(this.stateDir, "topics.json");
+    await mkdir3(this.stateDir, { recursive: true });
+    await writeFile3(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2), "utf-8");
     log.debug(`saved ${topics.length} topic scores`);
   }
   /**
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path4.join(this.stateDir, "topics.json");
+    const metaPath = path5.join(this.stateDir, "topics.json");
     try {
-      const raw = await readFile2(metaPath, "utf-8");
+      const raw = await readFile3(metaPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return { topics: [], updatedAt: null };
@@ -4205,7 +5921,13 @@ ${memory.content}
 };
 
 export {
+  normalizeEntityText,
+  normalizeEntitySchemas,
+  resolveRequestedEntitySectionKeys,
   sanitizeMemoryContent,
+  hasCitationForTemplate,
+  attachCitation,
+  stripCitationForTemplate,
   getCachedEpisodeMap,
   setCachedEpisodeMap,
   getCachedRuleMemories,
@@ -4236,6 +5958,10 @@ export {
   parseContinuityImprovementLoops,
   normalizeEntityName,
   ContentHashIndex,
+  normalizeAttributePairs,
+  compareEntityTimestamps,
+  fingerprintEntityStructuredFacts,
+  isEntitySynthesisStale,
   parseEntityFile,
   serializeEntityFile,
   StorageManager