@remnic/core 1.0.1 → 1.0.3

package/dist/{chunk-QWUUMMIK.js → chunk-POMSFKTB.js}

@@ -1,11 +1,19 @@
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-U4PV25RD.js";
+} from "./chunk-U2IQTSBY.js";
+import {
+  DEFAULT_CITATION_FORMAT,
+  hasCitation,
+  stripCitationForTemplate
+} from "./chunk-4KAN3GZ3.js";
+import {
+  createVersion
+} from "./chunk-6ZH4TU6I.js";
 import {
   getCachedEntities,
   setCachedEntities
-} from "./chunk-ESSMF2FR.js";
+} from "./chunk-6PFRXT4K.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -22,9 +30,6 @@ import {
   readProjectedMemoryState,
   readProjectedMemoryTimeline
 } from "./chunk-BOUYNNYD.js";
-import {
-  rotateMarkdownFileToArchive
-} from "./chunk-DM2T26WE.js";
 import {
   closeContinuityIncidentRecord,
   createContinuityIncidentRecord,
@@ -34,12 +39,20 @@ import {
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
 } from "./chunk-QSVPYQPG.js";
+import {
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-M62O4P4T.js";
+import {
+  matchEntitySchemaSection,
+  normalizeEntityStructuredSection,
+  sortStructuredSectionsBySchema
+} from "./chunk-4DJQYKMN.js";
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/storage.ts
 import { access, readdir, readFile, stat, writeFile, mkdir, unlink, rename, appendFile } from "fs/promises";
@@ -146,6 +159,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");
 }
@@ -280,7 +294,9 @@ function parseFrontmatter(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
   };
@@ -303,14 +319,47 @@ function parseFrontmatter(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 = path.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(path.sep).join("/");
+  let normalizedFrontmatter = frontmatter;
+  if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
+    const basename = path.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);
@@ -406,6 +455,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();
@@ -416,36 +492,598 @@ var ContentHashIndex = class _ContentHashIndex {
     return createHash("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 createHash("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*(.+)$/);
@@ -466,34 +1104,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);
+  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);
     }
-    if (summaryLines.length > 0) summary = summaryLines.join(" ");
   }
-  return { name, type, updated, facts, summary, relationships, activity, aliases };
+  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) {
@@ -515,13 +1247,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)
@@ -530,6 +1286,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
@@ -541,6 +1300,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.
@@ -551,6 +1333,26 @@ 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 readFile(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;
@@ -562,7 +1364,7 @@ var StorageManager = class _StorageManager {
     return path.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
-    const fileName = kind === "memory-status" ? ".memory-status-version.log" : ".artifact-write-version.log";
+    const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : ".cold-write-version.log";
     return path.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
@@ -605,12 +1407,18 @@ var StorageManager = class _StorageManager {
   get correctionsDir() {
     return path.join(this.baseDir, "corrections");
   }
+  get proceduresDir() {
+    return path.join(this.baseDir, "procedures");
+  }
   get entitiesDir() {
     return path.join(this.baseDir, "entities");
   }
   get stateDir() {
     return path.join(this.baseDir, "state");
   }
+  get entitySynthesisQueuePath() {
+    return path.join(this.stateDir, "entity-synthesis-queue.json");
+  }
   get factHashIndexReadyPath() {
     return path.join(this.stateDir, "fact-hashes.ready");
   }
@@ -647,10 +1455,35 @@ var StorageManager = class _StorageManager {
       }
       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 mkdir(path.dirname(this.factHashIndexReadyPath), { recursive: true });
@@ -733,6 +1566,7 @@ var StorageManager = class _StorageManager {
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     await mkdir(path.join(this.factsDir, today), { recursive: true });
+    await mkdir(path.join(this.proceduresDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -782,16 +1616,22 @@ var StorageManager = class _StorageManager {
       memoryKind: options.memoryKind,
       structuredAttributes: options.structuredAttributes
     };
+    if (options.status !== void 0) {
+      fm.status = options.status;
+    }
     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}
@@ -799,9 +1639,13 @@ ${sanitized.text}
     let filePath;
     if (category === "correction") {
       filePath = path.join(this.correctionsDir, `${id}.md`);
+    } else if (category === "procedure") {
+      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
+      filePath = path.join(this.proceduresDir, today, `${id}.md`);
     } else {
       filePath = path.join(this.factsDir, today, `${id}.md`);
     }
+    await this.snapshotBeforeWrite(filePath, "write");
     await writeFile(filePath, fileContent, "utf-8");
     this.invalidateAllMemoriesCache();
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.writeMemory", {
@@ -818,7 +1662,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}`);
@@ -941,7 +1790,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", {
@@ -950,7 +1799,9 @@ ${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) {
@@ -961,23 +1812,80 @@ ${sanitized.text}
     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 readFile(filePath, "utf-8");
-      entity = parseEntityFile(existing);
+      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 writeFile(filePath, serializeEntityFile(entity), "utf-8");
+    await this.snapshotBeforeWrite(filePath, "write");
+    await writeFile(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
     this.bumpMemoryStatusVersion();
     log.debug(`wrote entity ${normalized}`);
@@ -992,6 +1900,7 @@ ${sanitized.text}
   }
   async writeProfile(content) {
     await this.ensureDirectories();
+    await this.snapshotBeforeWrite(this.profilePath, "consolidation");
     await writeFile(this.profilePath, content, "utf-8");
     log.debug("updated profile.md");
   }
@@ -1080,12 +1989,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 = path.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;
@@ -1113,6 +2061,7 @@ ${sanitized.text}
       }
     };
     await collectPaths(this.factsDir);
+    await collectPaths(this.proceduresDir);
     await collectPaths(this.correctionsDir);
     return filePaths;
   }
@@ -1132,7 +2081,8 @@ ${sanitized.text}
               path: fullPath,
               frontmatter: normalizeFrontmatterForPath(
                 parsed.frontmatter,
-                toMemoryPathRel(this.baseDir, fullPath)
+                toMemoryPathRel(this.baseDir, fullPath),
+                parsed.content
               ),
               content: parsed.content
             };
@@ -1261,6 +2211,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 = path.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.
@@ -1284,7 +2290,8 @@ ${sanitized.text}
                   path: fullPath,
                   frontmatter: normalizeFrontmatterForPath(
                     parsed.frontmatter,
-                    toMemoryPathRel(this.baseDir, fullPath)
+                    toMemoryPathRel(this.baseDir, fullPath),
+                    parsed.content
                   ),
                   content: parsed.content
                 });
@@ -1309,14 +2316,15 @@ ${sanitized.text}
           path: filePath,
           frontmatter: normalizeFrontmatterForPath(
             parsed.frontmatter,
-            toMemoryPathRel(this.baseDir, filePath)
+            toMemoryPathRel(this.baseDir, filePath),
+            parsed.content
           ),
           content: parsed.content
         };
       }
       const normalizedPath = filePath.split(path.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 = path.basename(filePath, ".md");
         const fileMtime = entity.updated || await stat(filePath).then((s) => s.mtime.toISOString()).catch(() => (/* @__PURE__ */ new Date(0)).toISOString());
@@ -1361,6 +2369,9 @@ ${sanitized.text}
     if (memory.frontmatter.category === "correction") {
       return path.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
+    if (memory.frontmatter.category === "procedure") {
+      return path.join(root, "procedures", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    }
     return path.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
@@ -1420,6 +2431,9 @@ ${memory.content}
     }
     await this.moveMemoryToPath(memory, targetPath);
     this.invalidateAllMemoriesCache();
+    if (targetTier === "cold") {
+      this.invalidateColdMemoriesCache();
+    }
     this.bumpMemoryStatusVersion();
     return { changed: true, targetPath };
   }
@@ -1603,6 +2617,9 @@ ${memory.content}
 `;
     await writeFile(memory.path, fileContent, "utf-8");
     this.invalidateAllMemoriesCache();
+    if (memory.path.includes(`${path.sep}cold${path.sep}`)) {
+      this.invalidateColdMemoriesCache();
+    }
     await this.appendGeneratedMemoryLifecycleEventFailOpen(
       "storage.writeMemoryFrontmatter",
       {
@@ -1678,14 +2695,30 @@ ${memory.content}
     const metaPath = path.join(this.stateDir, "meta.json");
     try {
       const raw = await readFile(metaPath, "utf-8");
-      return JSON.parse(raw);
+      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: []
       };
     }
   }
@@ -2358,7 +3391,7 @@ ${reflection}
     let entity;
     try {
       const content = await readFile(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityRelationship: entity file ${name}.md not found`);
       return;
@@ -2369,7 +3402,7 @@ ${reflection}
     if (exists) return;
     entity.relationships.push(rel);
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
   }
   /**
@@ -2381,7 +3414,7 @@ ${reflection}
     let entity;
     try {
       const content = await readFile(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityActivity: entity file ${name}.md not found`);
       return;
@@ -2391,7 +3424,7 @@ ${reflection}
       entity.activity = entity.activity.slice(0, maxEntries);
     }
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile(filePath, serializeEntityFile(entity, this.entitySchemas), "utf-8");
     this.invalidateKnowledgeIndexCache();
   }
   /**
@@ -2402,7 +3435,7 @@ ${reflection}
     let entity;
     try {
       const content = await readFile(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      entity = parseEntityFile(content, this.entitySchemas);
     } catch {
       log.debug(`addEntityAlias: entity file ${name}.md not found`);
       return;
@@ -2410,28 +3443,142 @@ ${reflection}
     if (entity.aliases.includes(alias)) return;
     entity.aliases.push(alias);
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile(filePath, serializeEntityFile(entity), "utf-8");
+    await writeFile(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) {
+  async updateEntitySynthesis(name, synthesis, options = {}) {
     const filePath = path.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await readFile(filePath, "utf-8");
-      entity = parseEntityFile(content);
+      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 writeFile(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 writeFile(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 = path.join(this.entitiesDir, `${name}.md`);
+      const content = await readFile(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 readFile(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 mkdir(this.stateDir, { recursive: true });
+    await writeFile(
+      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 mkdir(this.stateDir, { recursive: true });
+    await writeFile(
+      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 writeFile(path.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)
   // ---------------------------------------------------------------------------
@@ -2441,7 +3588,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);
@@ -2457,10 +3605,10 @@ ${reflection}
           )
         );
         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 [];
@@ -2510,7 +3658,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);
@@ -2573,38 +3721,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 = path.join(this.entitiesDir, file);
           try {
             const content = await readFile(filePath, "utf-8");
-            const parsed = parseEntityFile(content);
+            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}`;
@@ -2620,13 +3851,27 @@ ${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 = path.join(this.entitiesDir, `${canonical}.md`);
-        await writeFile(canonicalPath, serializeEntityFile(mergedEntity), "utf-8");
+        await writeFile(canonicalPath, serializeEntityFile(mergedEntity, this.entitySchemas), "utf-8");
         for (const file of files) {
           const filePath = path.join(this.entitiesDir, file);
           if (filePath !== canonicalPath) {
@@ -2711,6 +3956,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 = path.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;
@@ -2802,6 +4070,9 @@ ${sanitized.text}
     let filePath;
     if (category === "correction") {
       filePath = path.join(this.correctionsDir, `${id}.md`);
+    } else if (category === "procedure") {
+      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
+      filePath = path.join(this.proceduresDir, today, `${id}.md`);
     } else {
       filePath = path.join(this.factsDir, today, `${id}.md`);
     }
@@ -3038,8 +4309,12 @@ ${memory.content}
 export {
   normalizeEntityName,
   ContentHashIndex,
+  normalizeAttributePairs,
+  compareEntityTimestamps,
+  fingerprintEntityStructuredFacts,
+  isEntitySynthesisStale,
   parseEntityFile,
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-QWUUMMIK.js.map
+//# sourceMappingURL=chunk-POMSFKTB.js.map