@remnic/core 9.22.0 → 9.22.2

package/dist/{chunk-QMGIQUBG.js → chunk-XWPFZX6S.js}

@@ -1,5 +1,12 @@
+import {
+  TombstoneStore,
+  buildRetiredFactTombstoneInputs,
+  collectRetiredMemoriesForRebuild
+} from "./chunk-2QMKMVHH.js";
 import {
   WEARABLES_DIR_NAME,
+  escapeSegmentText,
+  escapeSpeakerLabel,
   hasSelfMarker,
   isValidTranscriptDate,
   parseTranscriptSegmentLine,
@@ -7,11 +14,6 @@ import {
   unescapeSegmentText,
   unescapeSpeakerLabel
 } from "./chunk-UHVXE24Y.js";
-import {
-  TombstoneStore,
-  buildRetiredFactTombstoneInputs,
-  collectRetiredMemoriesForRebuild
-} from "./chunk-2QMKMVHH.js";
 import {
   supersessionKeysForFact
 } from "./chunk-DNHVPZOD.js";
@@ -27,7 +29,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-6NZ7U4R4.js";
+} from "./chunk-SCOT5DTA.js";
 import {
   appendLifecycleEventsSerialized,
   drainPendingLifecycleLedgerForSync,
@@ -67,9 +69,6 @@ import {
   readProjectedMemoryTimeline,
   updateProjectedMemoryPath
 } from "./chunk-3CSX3ETE.js";
-import {
-  rotateMarkdownFileToArchive
-} from "./chunk-DM2T26WE.js";
 import {
   closeContinuityIncidentRecord,
   createContinuityIncidentRecord,
@@ -79,6 +78,9 @@ import {
   serializeContinuityIncident,
   upsertContinuityLoopInMarkdown
 } from "./chunk-LDXUBPMO.js";
+import {
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
 import {
   parseFaithfulnessField,
   serializeFaithfulnessFields
@@ -205,8 +207,8 @@ import {
   open
 } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, readFileSync, statSync } from "fs";
-import { createHash as createHash4 } from "crypto";
-import path8 from "path";
+import { createHash as createHash5 } from "crypto";
+import path9 from "path";
 
 // src/storage/memory-read-store.ts
 import { lstat, readdir, realpath, stat } from "fs/promises";
@@ -1334,9 +1336,9 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   };
   if (path5.isAbsolute(resultPath)) {
     addCandidate(resultPath);
-    const relative = path5.relative(storageRoot, path5.resolve(resultPath));
-    if (relative && !relative.startsWith("..") && !path5.isAbsolute(relative)) {
-      const normalized = relative.split(path5.sep).join("/");
+    const relative2 = path5.relative(storageRoot, path5.resolve(resultPath));
+    if (relative2 && !relative2.startsWith("..") && !path5.isAbsolute(relative2)) {
+      const normalized = relative2.split(path5.sep).join("/");
       if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
         addCandidate(path5.join(storageRoot, "facts", normalized));
       }
@@ -2624,8 +2626,344 @@ function reconstructFusionInputs(date, dayTranscripts) {
   return inputs;
 }
 
-// src/storage/entity-timeline.ts
+// src/meetings/store.ts
 import { createHash as createHash3 } from "crypto";
+import * as path7 from "path";
+var MEETINGS_DIR_NAME = "meetings";
+var MEETING_KIND = "meeting";
+var MEETING_FORMAT_VERSION = 1;
+var MEETING_ID_PATTERN = /^mtg-(\d{4}-\d{2}-\d{2})-[0-9a-f]{8}$/;
+function meetingIdDate(id) {
+  const match = MEETING_ID_PATTERN.exec(id);
+  return match === null ? null : match[1];
+}
+function canonicalContent(base, fused) {
+  return JSON.stringify({
+    formatVersion: MEETING_FORMAT_VERSION,
+    id: base.id,
+    date: base.date,
+    startUtc: base.startUtc,
+    endUtc: base.endUtc,
+    app: base.app ?? null,
+    detectionSource: base.detectionSource,
+    title: base.title ?? null,
+    attendees: fused.attendees,
+    sources: fused.sources,
+    corroboratedBy: fused.corroboratedBy,
+    screenContext: fused.screenContext,
+    contextExcerpts: fused.contextExcerpts,
+    transcript: fused.transcript,
+    speakers: fused.speakers,
+    snapshotCount: fused.snapshotCount
+  });
+}
+function composeMeetingRecord(base, fused) {
+  const contentHash = createHash3("sha256").update(canonicalContent(base, fused), "utf-8").digest("hex");
+  return {
+    ...base,
+    ...fused,
+    contentHash,
+    formatVersion: MEETING_FORMAT_VERSION
+  };
+}
+function formatClockUtc(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms)) return "--:--";
+  return new Date(ms).toISOString().slice(11, 16);
+}
+function renderTranscriptLine(segment) {
+  const clock = formatClockUtc(segment.startIso ?? "");
+  return `**${escapeSpeakerLabel(segment.speaker)}** [${clock}]: ${escapeSegmentText(segment.text)}`;
+}
+function frontmatterList(key, values) {
+  if (values.length === 0) return [`${key}: []`];
+  const lines = [`${key}:`];
+  for (const value of values) lines.push(`  - ${JSON.stringify(value)}`);
+  return lines;
+}
+function serializeMeetingRecord(record) {
+  const lines = ["---"];
+  lines.push(`kind: ${MEETING_KIND}`);
+  lines.push(`formatVersion: ${record.formatVersion}`);
+  lines.push(`id: ${JSON.stringify(record.id)}`);
+  lines.push(`date: ${JSON.stringify(record.date)}`);
+  lines.push(`startUtc: ${JSON.stringify(record.startUtc)}`);
+  lines.push(`endUtc: ${JSON.stringify(record.endUtc)}`);
+  if (record.app !== void 0) lines.push(`app: ${JSON.stringify(record.app)}`);
+  lines.push(`detectionSource: ${JSON.stringify(record.detectionSource)}`);
+  if (record.title !== void 0) lines.push(`title: ${JSON.stringify(record.title)}`);
+  lines.push(...frontmatterList("attendees", record.attendees));
+  lines.push(...frontmatterList("sources", record.sources));
+  lines.push(...frontmatterList("corroboratedBy", record.corroboratedBy));
+  lines.push(`snapshotCount: ${record.snapshotCount}`);
+  lines.push(`contentHash: ${JSON.stringify(record.contentHash)}`);
+  lines.push("---");
+  lines.push("");
+  const heading = record.title !== void 0 && record.title.length > 0 ? ` \xB7 ${record.title}` : "";
+  lines.push(`# Meeting ${record.id}${heading}`);
+  lines.push("");
+  lines.push("## Attendees");
+  lines.push("");
+  if (record.attendees.length === 0) {
+    lines.push("_None resolved._");
+  } else {
+    for (const attendee of record.attendees) lines.push(`- ${attendee}`);
+  }
+  lines.push("");
+  if (record.screenContext.length > 0 || record.contextExcerpts.length > 0) {
+    lines.push("## Screen context");
+    lines.push("");
+    for (const event of record.screenContext) {
+      lines.push(`- [${event.clock}] ${event.label}`);
+    }
+    if (record.contextExcerpts.length > 0) {
+      if (record.screenContext.length > 0) lines.push("");
+      lines.push("Notable excerpts:");
+      lines.push("");
+      for (const excerpt of record.contextExcerpts) lines.push(`> ${excerpt.replace(/\n/g, " ")}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Transcript");
+  lines.push("");
+  if (record.transcript.length === 0) {
+    lines.push("_No transcript segments in this window._");
+  } else {
+    for (const segment of record.transcript) lines.push(renderTranscriptLine(segment));
+  }
+  lines.push("");
+  return `${lines.join("\n")}`;
+}
+function parseScalar2(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return trimmed;
+    }
+  }
+  return trimmed;
+}
+function parseMeetingRecordSummary(raw) {
+  if (!raw.startsWith("---\n")) return null;
+  const closeIndex = raw.indexOf("\n---\n", 4);
+  if (closeIndex === -1) return null;
+  const frontmatter = raw.slice(4, closeIndex).split("\n");
+  const scalars = {};
+  const lists = {};
+  let currentList = null;
+  for (const line of frontmatter) {
+    const listItem = /^ {2}- (.*)$/.exec(line);
+    if (listItem !== null && currentList !== null) {
+      lists[currentList].push(parseScalar2(listItem[1]));
+      continue;
+    }
+    const kv = /^([A-Za-z][A-Za-z0-9]*):\s*(.*)$/.exec(line);
+    if (kv === null) continue;
+    const key = kv[1];
+    const value = kv[2];
+    if (value === "") {
+      currentList = key;
+      lists[key] = [];
+    } else if (value === "[]") {
+      currentList = null;
+      lists[key] = [];
+    } else {
+      currentList = null;
+      scalars[key] = value;
+    }
+  }
+  if (scalars.kind !== void 0 && parseScalar2(scalars.kind) !== MEETING_KIND) return null;
+  const id = scalars.id !== void 0 ? parseScalar2(scalars.id) : void 0;
+  const contentHash = scalars.contentHash !== void 0 ? parseScalar2(scalars.contentHash) : void 0;
+  if (id === void 0 || contentHash === void 0) return null;
+  return {
+    id,
+    date: scalars.date !== void 0 ? parseScalar2(scalars.date) : "",
+    startUtc: scalars.startUtc !== void 0 ? parseScalar2(scalars.startUtc) : "",
+    endUtc: scalars.endUtc !== void 0 ? parseScalar2(scalars.endUtc) : "",
+    ...scalars.app !== void 0 ? { app: parseScalar2(scalars.app) } : {},
+    detectionSource: scalars.detectionSource !== void 0 ? parseScalar2(scalars.detectionSource) : "",
+    ...scalars.title !== void 0 ? { title: parseScalar2(scalars.title) } : {},
+    attendees: lists.attendees ?? [],
+    sources: lists.sources ?? [],
+    corroboratedBy: lists.corroboratedBy ?? [],
+    snapshotCount: scalars.snapshotCount !== void 0 ? Number(scalars.snapshotCount) || 0 : 0,
+    contentHash
+  };
+}
+var MeetingRecordStore = class {
+  constructor(memoryDir, io) {
+    this.memoryDir = memoryDir;
+    this.io = io;
+    this.meetingsDir = path7.join(memoryDir, MEETINGS_DIR_NAME);
+  }
+  memoryDir;
+  io;
+  meetingsDir;
+  recordPath(date, id) {
+    if (!isValidTranscriptDate(date)) {
+      throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
+    }
+    const idDate = meetingIdDate(id);
+    if (idDate === null) {
+      throw new Error(`invalid meeting id '${String(id)}' \u2014 expected mtg-YYYY-MM-DD-<hash>`);
+    }
+    if (idDate !== date) {
+      throw new Error(`meeting id '${id}' does not belong to date '${date}'`);
+    }
+    return path7.join(this.meetingsDir, date, `${id}.md`);
+  }
+  /** Idempotently persist a record: skip the write when contentHash is unchanged. */
+  async saveMeetingRecord(record) {
+    const filePath = this.recordPath(record.date, record.id);
+    await this.assertPathContained(filePath);
+    const existing = await this.readRaw(filePath);
+    if (existing !== null) {
+      const summary = parseMeetingRecordSummary(existing);
+      if (summary !== null && summary.contentHash === record.contentHash) {
+        return { path: filePath, written: false, contentHash: record.contentHash };
+      }
+    }
+    await this.io.writeFile(filePath, serializeMeetingRecord(record));
+    return { path: filePath, written: true, contentHash: record.contentHash };
+  }
+  /** Read a stored record's raw markdown; null when absent. */
+  async readMeetingRecord(date, id) {
+    const filePath = this.recordPath(date, id);
+    await this.assertPathContained(filePath);
+    return this.readRaw(filePath);
+  }
+  /**
+   * Read + parse every stored record for a day exactly ONCE, sorted by start
+   * time (ascending, id tiebreak). The single day-read path both `listMeetingIds`
+   * and `listMeetingSummaries` derive from — no record is read twice.
+   */
+  async readDaySummaries(date) {
+    if (!isValidTranscriptDate(date)) {
+      throw new Error(`invalid meeting date '${String(date)}' \u2014 expected YYYY-MM-DD`);
+    }
+    const dayDir = path7.join(this.meetingsDir, date);
+    await this.assertPathContained(dayDir);
+    let entries;
+    try {
+      entries = await this.io.readDir(dayDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const summaries = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const id = entry.slice(0, -3);
+      if (meetingIdDate(id) !== date) continue;
+      const raw = await this.readMeetingRecord(date, id);
+      if (raw === null) continue;
+      const summary = parseMeetingRecordSummary(raw);
+      if (summary !== null) summaries.push(summary);
+    }
+    summaries.sort((a, b) => a.startUtc < b.startUtc ? -1 : a.startUtc > b.startUtc ? 1 : SORT_STR(a.id, b.id));
+    return summaries;
+  }
+  /** List meeting ids stored for a day, sorted by start time (ascending). */
+  async listMeetingIds(date) {
+    return (await this.readDaySummaries(date)).map((summary) => summary.id);
+  }
+  /** Read parsed summaries for a day, sorted by start time. */
+  async listMeetingSummaries(date) {
+    return this.readDaySummaries(date);
+  }
+  /** List dates that have at least one stored meeting record, newest first. */
+  async listMeetingDates() {
+    await this.assertPathContained(this.meetingsDir);
+    let entries;
+    try {
+      entries = await this.io.readDir(this.meetingsDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const dates = entries.filter((entry) => isValidTranscriptDate(entry));
+    dates.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+    return dates;
+  }
+  /** Remove a stored record. Idempotent: a no-op when already absent. */
+  async deleteMeetingRecord(date, id) {
+    const filePath = this.recordPath(date, id);
+    await this.assertPathContained(filePath);
+    try {
+      await this.io.deleteFile(filePath);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+  }
+  async readRaw(filePath) {
+    try {
+      return await this.io.readFile(filePath);
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  async assertPathContained(targetPath) {
+    let rootReal;
+    try {
+      rootReal = await this.io.realpath(this.memoryDir);
+    } catch {
+      rootReal = path7.resolve(this.memoryDir);
+    }
+    await this.assertNoEscape(rootReal, this.meetingsDir);
+    await this.assertNoEscape(rootReal, path7.dirname(targetPath));
+    await this.assertNoEscape(rootReal, targetPath);
+    await this.assertNotSymlink(this.meetingsDir, "directory");
+    const dayDir = this.dayDirWithin(targetPath);
+    if (dayDir !== null) await this.assertNotSymlink(dayDir, "directory");
+    if (targetPath.endsWith(".md")) await this.assertNotSymlink(targetPath, "record file");
+  }
+  /** The `<meetings>/<date>` directory on the path to `targetPath`, or null when
+   *  `targetPath` is the meetings root itself. */
+  dayDirWithin(targetPath) {
+    const rel = path7.relative(this.meetingsDir, targetPath);
+    if (rel === "" || rel.startsWith("..") || path7.isAbsolute(rel)) return null;
+    const first = rel.split(path7.sep)[0];
+    if (first === void 0 || first.length === 0) return null;
+    return path7.join(this.meetingsDir, first);
+  }
+  async assertNotSymlink(target, kind) {
+    let stat4;
+    try {
+      stat4 = await this.io.lstat(target);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    if (stat4.isSymbolicLink) {
+      const label = path7.relative(this.memoryDir, target) || MEETINGS_DIR_NAME;
+      throw new Error(
+        `meetings ${kind} '${label}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
+      );
+    }
+  }
+  async assertNoEscape(rootReal, candidate) {
+    let candidateReal;
+    try {
+      candidateReal = await this.io.realpath(candidate);
+    } catch {
+      return;
+    }
+    if (!pathIsInside(rootReal, candidateReal)) {
+      throw new Error(
+        "meeting record path resolves outside the memory dir \u2014 refusing to follow a symlink/traversal (AGENTS.md pattern #3)"
+      );
+    }
+  }
+};
+var SORT_STR = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+
+// src/storage/entity-timeline.ts
+import { createHash as createHash4 } from "crypto";
 function parseEntityTimelineBullet(bullet, fallbackTimestamp) {
   const trimmed = bullet.trim();
   if (!trimmed) return null;
@@ -2997,7 +3335,7 @@ function fingerprintEntityStructuredFacts(entity) {
     (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 createHash3("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -3020,7 +3358,7 @@ function isEntitySynthesisStale(entity) {
 
 // src/storage/content-hash-index.ts
 import { mkdir, stat as stat2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 var CONTENT_HASH_INDEX_LOCK_STALE_MS = 3e4;
 var CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS = 5;
 var CONTENT_HASH_INDEX_RETRY_BASE_MS = 500;
@@ -3080,8 +3418,8 @@ var ContentHashIndex = class _ContentHashIndex {
    * re-read on the hot path.
    */
   lastSyncedFingerprint = null;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path7.dirname(stateDir), lockOptions = {}) {
-    this.filePath = path7.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path8.dirname(stateDir), lockOptions = {}) {
+    this.filePath = path8.join(stateDir, "fact-hashes.txt");
     this.secureStoreKeyProvider = secureStoreKeyProvider;
     this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
     this.memoryDir = memoryDir;
@@ -3173,7 +3511,7 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed (plain whole-file overwrite). */
   async save() {
     if (!this.dirty) return;
-    await mkdir(path7.dirname(this.filePath), { recursive: true });
+    await mkdir(path8.dirname(this.filePath), { recursive: true });
     const publishedAdded = new Set(this.added);
     const publishedRemoved = new Set(this.removed);
     const serialized = [...this.hashes].join("\n") + "\n";
@@ -3220,7 +3558,7 @@ var ContentHashIndex = class _ContentHashIndex {
    */
   async saveMergingWithDisk() {
     if (!this.dirty) return;
-    await mkdir(path7.dirname(this.filePath), { recursive: true });
+    await mkdir(path8.dirname(this.filePath), { recursive: true });
     const publish = async () => {
       const publishedAdded = new Set(this.added);
       const publishedRemoved = new Set(this.removed);
@@ -3239,7 +3577,7 @@ var ContentHashIndex = class _ContentHashIndex {
         if (err instanceof SecureStoreLockedError) throw err;
         if (!isErrnoCode(err, "ENOENT")) throw err;
       }
-      await mkdir(path7.dirname(this.filePath), { recursive: true });
+      await mkdir(path8.dirname(this.filePath), { recursive: true });
       await writeMaybeEncryptedFile(
         this.filePath,
         [...merged].join("\n") + "\n",
@@ -3306,7 +3644,7 @@ var ContentHashIndex = class _ContentHashIndex {
    * fired retry) simply yields `acquired=false` after the bounded wait.
    */
   async rebuildUnderLock(populate) {
-    await mkdir(path7.dirname(this.filePath), { recursive: true });
+    await mkdir(path8.dirname(this.filePath), { recursive: true });
     let published = false;
     await withHeldFileLock(
       `${this.filePath}.lock`,
@@ -3373,7 +3711,7 @@ var ContentHashIndex = class _ContentHashIndex {
       if (!this.dirty) break;
       if (attempt < maxAttempts - 1) {
         const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
-        await new Promise((resolve2) => setTimeout(resolve2, wait));
+        await new Promise((resolve3) => setTimeout(resolve3, wait));
       }
     }
     if (this.reconcileRetryTimer) {
@@ -3403,8 +3741,8 @@ var ContentHashIndex = class _ContentHashIndex {
       return;
     }
     if (!this.reconcileRetryBarrier) {
-      this.reconcileRetryBarrier = new Promise((resolve2) => {
-        this.reconcileRetryResolve = resolve2;
+      this.reconcileRetryBarrier = new Promise((resolve3) => {
+        this.reconcileRetryResolve = resolve3;
       });
     }
     const attempt = this.reconcileRetryAttempts + 1;
@@ -3432,10 +3770,10 @@ var ContentHashIndex = class _ContentHashIndex {
   }
   /** Resolve and clear the retry barrier if one is outstanding. */
   settleReconcileRetry() {
-    const resolve2 = this.reconcileRetryResolve;
+    const resolve3 = this.reconcileRetryResolve;
     this.reconcileRetryBarrier = null;
     this.reconcileRetryResolve = null;
-    resolve2?.();
+    resolve3?.();
   }
   /** Remove a hash from the index (used when archiving/deleting). */
   remove(content) {
@@ -4107,17 +4445,17 @@ function inferEntityTypeFromContent(content) {
 }
 var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set(["company", "other", "person", "place", "project", "tool", "topic"]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path8.basename(pathRel, ".md").toLowerCase();
+  const basename = path9.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(path8.sep).join("/");
+  const normalizedPath = pathRel.split(path9.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path8.basename(pathRel, ".md");
+    const basename = path9.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -4783,8 +5121,8 @@ var StorageManager3 = class _StorageManager {
   }
   /** Whether `filePath` resolves to `stateDir` itself or a path contained in it. */
   isStateFilePath(filePath) {
-    const rel = path8.relative(this.stateDir, path8.resolve(filePath));
-    return rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel);
+    const rel = path9.relative(this.stateDir, path9.resolve(filePath));
+    return rel === "" || !rel.startsWith("..") && !path9.isAbsolute(rel);
   }
   // ── Tombstone store (issue #1579) ───────────────────────────────────────
   // Instance-scoped (rule 11) + namespace-scoped (rule 42) tombstone index.
@@ -4884,8 +5222,8 @@ var StorageManager3 = class _StorageManager {
    * /srv/cold/remnic), skipping the patch and stranding a stale hot entry.
    */
   isColdOrArchiveTierPath(p) {
-    const rel = path8.relative(this.baseDir, p);
-    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path8.sep}`) || rel.startsWith(`archive${path8.sep}`);
+    const rel = path9.relative(this.baseDir, p);
+    return rel === "cold" || rel === "archive" || rel.startsWith(`cold${path9.sep}`) || rel.startsWith(`archive${path9.sep}`);
   }
   /**
    * Mark the secure-store as required for this storage instance.
@@ -4972,7 +5310,7 @@ var StorageManager3 = class _StorageManager {
         void 0,
         this.baseDir
       );
-      const rel = path8.relative(this.baseDir, filePath).split(path8.sep).join("/");
+      const rel = path9.relative(this.baseDir, filePath).split(path9.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -5052,13 +5390,13 @@ var StorageManager3 = class _StorageManager {
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path8.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path9.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path8.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path9.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
     const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : kind === "cold-write" ? ".cold-write-version.log" : ".memory-corpus-version.log";
-    return path8.join(this.stateDir, fileName);
+    return path9.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -5150,7 +5488,7 @@ var StorageManager3 = class _StorageManager {
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path8.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path9.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -5166,7 +5504,7 @@ var StorageManager3 = class _StorageManager {
     if (!isValidTranscriptDate(date)) {
       throw new Error(`invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`);
     }
-    return path8.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path9.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -5198,6 +5536,24 @@ var StorageManager3 = class _StorageManager {
       lstat: (p) => lstat2(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
     });
   }
+  _meetingRecordStore;
+  /**
+   * Meeting record IO (issue #1900). Records live under `<baseDir>/meetings/`
+   * — inside the QMD collection root (full-text searchable) but outside the
+   * memory scan roots — and inherit the same encrypted-at-rest + atomic-write +
+   * symlink-containment semantics as memories via the shared secure IO port.
+   */
+  meetingRecordStore() {
+    if (this._meetingRecordStore) return this._meetingRecordStore;
+    return this._meetingRecordStore = new MeetingRecordStore(this.baseDir, {
+      writeFile: (p, c) => this.writeStorageSecureFile(p, c),
+      readFile: (p) => readMaybeEncryptedFile(p, this._secureStoreKey, this.baseDir),
+      readDir: (d) => readdir4(d),
+      deleteFile: (p) => unlink2(p),
+      realpath: (p) => realpath2(p),
+      lstat: (p) => lstat2(p).then((st) => ({ isSymbolicLink: st.isSymbolicLink() }))
+    });
+  }
   /**
    * Locate a wearable-sourced memory by exact (trimmed) content,
    * ignoring the "[Attributes: ...]" suffix writeMemory appends for
@@ -5264,25 +5620,25 @@ var StorageManager3 = class _StorageManager {
     });
   }
   get factsDir() {
-    return path8.join(this.baseDir, "facts");
+    return path9.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path8.join(this.baseDir, "corrections");
+    return path9.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path8.join(this.baseDir, "procedures");
+    return path9.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path8.join(this.baseDir, "reasoning-traces");
+    return path9.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path8.join(this.baseDir, "entities");
+    return path9.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path8.resolve(this.entitiesDir, `${name}.md`);
-    const relative = path8.relative(this.entitiesDir, filePath);
-    if (relative === "" || relative.startsWith("..") || path8.isAbsolute(relative)) {
+    const filePath = path9.resolve(this.entitiesDir, `${name}.md`);
+    const relative2 = path9.relative(this.entitiesDir, filePath);
+    if (relative2 === "" || relative2.startsWith("..") || path9.isAbsolute(relative2)) {
       return null;
     }
     return filePath;
@@ -5303,10 +5659,10 @@ var StorageManager3 = class _StorageManager {
     });
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path8.resolve(filePath);
-    const base = path8.resolve(this.baseDir);
-    const rel = path8.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path8.sep}`) || path8.isAbsolute(rel)) {
+    const resolved = path9.resolve(filePath);
+    const base = path9.resolve(this.baseDir);
+    const rel = path9.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path9.sep}`) || path9.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -5318,7 +5674,7 @@ var StorageManager3 = class _StorageManager {
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat3(target);
-    const relPath = path8.relative(this.baseDir, target).split(path8.sep).join("/");
+    const relPath = path9.relative(this.baseDir, target).split(path9.sep).join("/");
     const cache = await this.loadOfflineSyncDigestCache();
     const cached = cache.get(relPath);
     if (cached && cached.statBytes === st.size && cached.mtimeMs === st.mtimeMs && cached.ctimeMs === st.ctimeMs && !cached.encrypted) {
@@ -5332,11 +5688,11 @@ var StorageManager3 = class _StorageManager {
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash4("sha256").update(content).digest("hex"),
+        sha256: createHash5("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash4("sha256");
+      const hash = createHash5("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -5379,7 +5735,7 @@ var StorageManager3 = class _StorageManager {
         const bytes = typeof record.bytes === "number" ? record.bytes : NaN;
         const sha256 = typeof record.sha256 === "string" ? record.sha256 : "";
         const encrypted = record.encrypted === true;
-        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path8.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
+        if (cachePath.length === 0 || cachePath === ".." || cachePath.startsWith("../") || path9.isAbsolute(cachePath) || !Number.isFinite(statBytes) || !Number.isFinite(mtimeMs) || !Number.isFinite(ctimeMs) || !Number.isFinite(bytes) || !/^[a-f0-9]{64}$/i.test(sha256)) {
           continue;
         }
         cache.set(cachePath, { statBytes, mtimeMs, ctimeMs, encrypted, sha256, bytes });
@@ -5421,7 +5777,7 @@ var StorageManager3 = class _StorageManager {
       const cache = this.offlineSyncDigestCache;
       if (!cache) return;
       const entries = [...cache.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([entryPath, entry]) => ({ path: entryPath, ...entry }));
-      await mkdir2(path8.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir2(path9.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(this.offlineSyncDigestCachePath, `${JSON.stringify({ version: 1, entries })}
 `, "utf-8");
     }).catch((err) => {
@@ -5466,10 +5822,10 @@ var StorageManager3 = class _StorageManager {
     this.invalidateAllMemoriesCache();
     this.invalidateKnowledgeIndexCache();
     this.factHashIndexAuthoritative = false;
-    if (filePath.includes(`${path8.sep}cold${path8.sep}`)) {
+    if (filePath.includes(`${path9.sep}cold${path9.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    if (filePath.includes(`${path8.sep}artifacts${path8.sep}`)) {
+    if (filePath.includes(`${path9.sep}artifacts${path9.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -5540,7 +5896,7 @@ var StorageManager3 = class _StorageManager {
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir2(path8.dirname(filePath), { recursive: true });
+    await mkdir2(path9.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (await this.isEncryptedFileHeader(filePath)) {
@@ -5566,13 +5922,13 @@ var StorageManager3 = class _StorageManager {
     this.notifyCatalogWriteForPath(filePath);
   }
   get stateDir() {
-    return path8.join(this.baseDir, "state");
+    return path9.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path8.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path9.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path8.join(this.stateDir, "entity-synthesis-queue.json");
+    return path9.join(this.stateDir, "entity-synthesis-queue.json");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -5582,7 +5938,7 @@ var StorageManager3 = class _StorageManager {
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path8.join(this.stateDir, "tombstones.jsonl");
+    return path9.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -5777,7 +6133,7 @@ var StorageManager3 = class _StorageManager {
         );
         if (published || attempt === maxAttempts - 1) break;
         const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
-        await new Promise((resolve2) => setTimeout(resolve2, wait));
+        await new Promise((resolve3) => setTimeout(resolve3, wait));
       }
       this.factHashIndexAuthoritative = published;
       if (!published) {
@@ -5855,55 +6211,55 @@ var StorageManager3 = class _StorageManager {
     return null;
   }
   get questionsDir() {
-    return path8.join(this.baseDir, "questions");
+    return path9.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path8.join(this.baseDir, "artifacts");
+    return path9.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path8.join(this.baseDir, "identity");
+    return path9.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path8.join(this.identityDir, "identity-anchor.md");
+    return path9.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path8.join(this.identityDir, "incidents");
+    return path9.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path8.join(this.identityDir, "audits", "weekly");
+    return path9.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path8.join(this.identityDir, "audits", "monthly");
+    return path9.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path8.join(this.identityDir, "improvement-loops.md");
+    return path9.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path8.join(this.identityDir, "reflections.md");
+    return path9.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path8.join(this.baseDir, "profile.md");
+    return path9.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path8.join(this.stateDir, "memory-actions.jsonl");
+    return path9.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path8.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path9.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path8.join(this.stateDir, "compression-guidelines.md");
+    return path9.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path8.join(this.stateDir, "compression-guidelines.draft.md");
+    return path9.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path8.join(this.stateDir, "compression-guideline-state.json");
+    return path9.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path8.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path9.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path8.join(this.stateDir, "behavior-signals.jsonl");
+    return path9.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * In-memory dedup key set for behavior-signals appends (issue #1909),
@@ -5935,7 +6291,7 @@ var StorageManager3 = class _StorageManager {
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path8.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path9.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -5966,7 +6322,7 @@ var StorageManager3 = class _StorageManager {
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path8.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path9.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     try {
       const raw = readFileSync(aliasPath, "utf-8");
@@ -5989,9 +6345,9 @@ var StorageManager3 = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir2(path8.join(this.factsDir, today), { recursive: true });
-    await mkdir2(path8.join(this.proceduresDir, today), { recursive: true });
-    await mkdir2(path8.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir2(path9.join(this.factsDir, today), { recursive: true });
+    await mkdir2(path9.join(this.proceduresDir, today), { recursive: true });
+    await mkdir2(path9.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir2(this.correctionsDir, { recursive: true });
     await mkdir2(this.entitiesDir, { recursive: true });
     await mkdir2(this.stateDir, { recursive: true });
@@ -6001,7 +6357,7 @@ var StorageManager3 = class _StorageManager {
     await mkdir2(this.identityIncidentsDir, { recursive: true });
     await mkdir2(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir2(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir2(path8.join(this.baseDir, "config"), { recursive: true });
+    await mkdir2(path9.join(this.baseDir, "config"), { recursive: true });
     if (this.hotMemoriesCacheEnabled && this.getMemoryCorpusVersion() === 0) {
       this.bumpMemoryCorpusVersion();
     }
@@ -6021,11 +6377,11 @@ var StorageManager3 = class _StorageManager {
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir2(this.correctionsDir, { recursive: true });
-      return path8.join(this.correctionsDir, `${id}.md`);
+      return path9.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path8.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path9.join(getCategoryDir(this.baseDir, category), today);
     await mkdir2(datedDir, { recursive: true });
-    return path8.join(datedDir, `${id}.md`);
+    return path9.join(datedDir, `${id}.md`);
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -6330,7 +6686,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path8.join(this.artifactsDir, day);
+    const dir = path9.join(this.artifactsDir, day);
     await mkdir2(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -6355,7 +6711,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path8.join(dir, `${id}.md`);
+    const filePath = path9.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -6631,7 +6987,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path8.join(this.baseDir, "cold");
+    const coldRoot = path9.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -6723,7 +7079,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path8.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path9.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -6786,7 +7142,7 @@ ${sanitized.text}
       try {
         const entries = await readdir4(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path8.join(dir, entry.name);
+          const fullPath = path9.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -6819,7 +7175,7 @@ ${sanitized.text}
     return this.memoryReadStore.readMemoryByPath(filePath);
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path8.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path9.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -6834,13 +7190,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path8.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path9.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path8.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path9.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path8.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path9.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
@@ -6853,8 +7209,8 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path8.resolve(memory.path);
-    const destPath = path8.resolve(targetPath);
+    const sourcePath = path9.resolve(memory.path);
+    const destPath = path9.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
         await unlink2(memory.path);
@@ -6870,8 +7226,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path8.resolve(memory.path);
-    const destPath = path8.resolve(targetPath);
+    const sourcePath = path9.resolve(memory.path);
+    const destPath = path9.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -6898,7 +7254,7 @@ ${memory.content}
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path8.join(this.baseDir, "archive");
+    return path9.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -6909,7 +7265,7 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path8.join(this.archiveDir, today);
+      const destDir = path9.join(this.archiveDir, today);
       await mkdir2(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
@@ -6921,7 +7277,7 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path8.join(destDir, path8.basename(memory.path));
+      const destPath = path9.join(destDir, path9.basename(memory.path));
       await this.writeStorageSecureFile(destPath, fileContent);
       await unlink2(memory.path);
       markProjectedMemoryPathInvalid(this.baseDir, memory.frontmatter.id);
@@ -7069,7 +7425,7 @@ ${memory.content}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
     await this.patchHotMemoriesCache({ addedPath: memory.path });
-    if (memory.path.includes(`${path8.sep}cold${path8.sep}`)) {
+    if (memory.path.includes(`${path9.sep}cold${path9.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -7140,7 +7496,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path8.join(this.stateDir, "buffer.json");
+    const bufferPath = path9.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -7152,11 +7508,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path8.join(this.stateDir, "buffer.json");
+    const bufferPath = path9.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path8.join(this.stateDir, "meta.json");
+    const metaPath = path9.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -7189,7 +7545,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path8.join(this.stateDir, "meta.json");
+    const metaPath = path9.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -7256,7 +7612,7 @@ ${memory.content}
       },
       (payload) => this.appendStorageSecureFile(target, payload),
       async () => {
-        await mkdir2(path8.dirname(target), { recursive: true });
+        await mkdir2(path9.dirname(target), { recursive: true });
       }
     );
   }
@@ -7354,7 +7710,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path8.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path9.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -7367,7 +7723,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path8.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path9.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -7519,7 +7875,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash4("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash5("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -7597,7 +7953,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path8.join(this.questionsDir, `${id}.md`);
+    const filePath = path9.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -7615,7 +7971,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path8.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path9.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5");
     const resolved = this.extractFrontmatterValue(frontmatterStr, "resolved") === "true";
@@ -7671,11 +8027,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path8.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path9.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path8.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path9.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -7771,7 +8127,7 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path8.join(this.entitiesDir, `${name}.md`);
+    const filePath = path9.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7794,7 +8150,7 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path8.join(this.entitiesDir, `${name}.md`);
+    const filePath = path9.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7817,7 +8173,7 @@ ${reflection}
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path8.join(this.entitiesDir, `${name}.md`);
+    const filePath = path9.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -7844,7 +8200,7 @@ ${reflection}
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     let synthesisTimelineCount;
     try {
-      const filePath = path8.join(this.entitiesDir, `${name}.md`);
+      const filePath = path9.join(this.entitiesDir, `${name}.md`);
       const content = await this.readStorageSecureFile(filePath);
       synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
     } catch (err) {
@@ -7927,7 +8283,7 @@ ${reflection}
       if (!raw) continue;
       const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
       if (raw.trimEnd() === serialized.trimEnd()) continue;
-      await this.writeStorageSecureFile(path8.join(this.entitiesDir, `${entityName}.md`), serialized);
+      await this.writeStorageSecureFile(path9.join(this.entitiesDir, `${entityName}.md`), serialized);
       migrated += 1;
     }
     if (migrated > 0) {
@@ -8020,14 +8376,14 @@ ${reflection}
     if (entries.length === 0) return 0;
     const memories = await this.readAllMemories();
     const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    const memoryPathMap = new Map(memories.map((m) => [path8.resolve(m.path), m]));
+    const memoryPathMap = new Map(memories.map((m) => [path9.resolve(m.path), m]));
     let updated = 0;
     const prevVersion = this.getMemoryCorpusVersion();
     const keyId = this.hotCacheKeyId();
     const warm = this.hotMemoriesCacheEnabled && getCachedMemories(this.baseDir, prevVersion, keyId, this.hotCacheTtlMs()) !== null;
     const appliedPatches = /* @__PURE__ */ new Map();
     for (const entry of entries) {
-      const memory = entry.memoryPath ? memoryPathMap.get(path8.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
+      const memory = entry.memoryPath ? memoryPathMap.get(path9.resolve(entry.memoryPath)) : memoryMap.get(entry.memoryId);
       if (!memory) continue;
       const newFm = {
         ...memory.frontmatter,
@@ -8043,7 +8399,7 @@ ${memory.content}
         if (warm) {
           updateCacheOnWrite(this.baseDir, { ...memory, frontmatter: newFm }, keyId);
         }
-        appliedPatches.set(path8.resolve(memory.path), {
+        appliedPatches.set(path9.resolve(memory.path), {
           accessCount: entry.newCount,
           lastAccessed: entry.lastAccessed
         });
@@ -8059,7 +8415,7 @@ ${memory.content}
         const cur = getCachedMemories(this.baseDir, prevVersion, keyId);
         if (cur) {
           const reapplied = cur.map((m) => {
-            const patch = appliedPatches.get(path8.resolve(m.path));
+            const patch = appliedPatches.get(path9.resolve(m.path));
             return patch ? { ...m, frontmatter: { ...m.frontmatter, accessCount: patch.accessCount, lastAccessed: patch.lastAccessed } } : m;
           });
           setCachedMemories(this.baseDir, reapplied, produced, keyId, this.hotCacheTtlMs());
@@ -8091,7 +8447,7 @@ ${memory.content}
     const pathsById = /* @__PURE__ */ new Map();
     const filePathsById = /* @__PURE__ */ new Map();
     for (const filePath of filePaths) {
-      const memoryId = path8.basename(filePath, ".md");
+      const memoryId = path9.basename(filePath, ".md");
       if (!wantedIds.has(memoryId)) continue;
       const paths = filePathsById.get(memoryId) ?? [];
       paths.push(filePath);
@@ -8106,7 +8462,7 @@ ${memory.content}
           qmdResultPathCandidates(this.baseDir, preferredPath)
         );
         const directMatch = existingPaths.find(
-          (filePath) => directCandidates.has(path8.resolve(filePath))
+          (filePath) => directCandidates.has(path9.resolve(filePath))
         );
         if (directMatch) {
           preferredMatches.push(directMatch);
@@ -8119,7 +8475,7 @@ ${memory.content}
             candidates.add(candidate);
           }
         }
-        const match = existingPaths.find((filePath) => candidates.has(path8.resolve(filePath)));
+        const match = existingPaths.find((filePath) => candidates.has(path9.resolve(filePath)));
         if (match) preferredMatches.push(match);
       }
       if (preferredMatches.length > 0) {
@@ -8338,14 +8694,14 @@ Reason: ${reason}`;
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path8.join(this.baseDir, "summaries");
+    return path9.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
     await mkdir2(this.summariesDir, { recursive: true });
-    const filePath = path8.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path9.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -8358,7 +8714,7 @@ Reason: ${reason}`;
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path8.join(this.summariesDir, file);
+        const filePath = path9.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -8420,7 +8776,7 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path8.join(this.stateDir, "topics.json");
+    const metaPath = path9.join(this.stateDir, "topics.json");
     await mkdir2(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(
       metaPath,
@@ -8432,7 +8788,7 @@ ${memory.content}
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path8.join(this.stateDir, "topics.json");
+    const metaPath = path9.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -8529,6 +8885,14 @@ export {
   serializeFusionDay,
   parseFusionDay,
   reconstructFusionInputs,
+  MEETINGS_DIR_NAME,
+  MEETING_KIND,
+  MEETING_FORMAT_VERSION,
+  meetingIdDate,
+  composeMeetingRecord,
+  serializeMeetingRecord,
+  parseMeetingRecordSummary,
+  MeetingRecordStore,
   normalizeStructuredSectionFacts,
   compileEntityFacts,
   compareEntityTimestamps,
@@ -8547,4 +8911,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-QMGIQUBG.js.map
+//# sourceMappingURL=chunk-XWPFZX6S.js.map