@remnic/core 9.4.2 → 9.6.0

package/dist/{chunk-M7GGMGMZ.js → chunk-SVOHGUMI.js}

@@ -1,7 +1,12 @@
 import {
   WEARABLES_DIR_NAME,
-  isValidTranscriptDate
-} from "./chunk-M7XQSUBB.js";
+  hasSelfMarker,
+  isValidTranscriptDate,
+  parseTranscriptSegmentLine,
+  resolveSpeaker,
+  unescapeSegmentText,
+  unescapeSpeakerLabel
+} from "./chunk-B3ABVQ36.js";
 import {
   TombstoneStore,
   buildRetiredFactTombstoneInputs,
@@ -11,14 +16,12 @@ import {
   isErrnoCode
 } from "./chunk-5UZXUTVO.js";
 import {
-  assertPathInsideRoot
-} from "./chunk-5GPPACXK.js";
+  assertPathInsideRoot,
+  pathIsInside
+} from "./chunk-VSMRDBFT.js";
 import {
   supersessionKeysForFact
 } from "./chunk-EHK6KZHK.js";
-import {
-  stripAttributesSuffix
-} from "./chunk-SVOZFLIQ.js";
 import {
   DEFAULT_CITATION_FORMAT,
   hasCitation,
@@ -28,10 +31,21 @@ import {
   assertMemoryFrontmatterId,
   warnProjectionFallback
 } from "./chunk-4KJLYTLS.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-SVOZFLIQ.js";
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
 } from "./chunk-JS2HKKOK.js";
+import {
+  markProjectedMemoryPathInvalid,
+  readProjectedGovernanceRecord,
+  readProjectedMemoryBrowse,
+  readProjectedMemoryState,
+  readProjectedMemoryTimeline,
+  updateProjectedMemoryPath
+} from "./chunk-RHOZ5LLO.js";
 import {
   getCachedEntities,
   invalidateAllForDir,
@@ -47,14 +61,6 @@ import {
   normalizeProjectionPreview,
   normalizeProjectionTags
 } from "./chunk-SCU65EZI.js";
-import {
-  markProjectedMemoryPathInvalid,
-  readProjectedGovernanceRecord,
-  readProjectedMemoryBrowse,
-  readProjectedMemoryState,
-  readProjectedMemoryTimeline,
-  updateProjectedMemoryPath
-} from "./chunk-RHOZ5LLO.js";
 import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
@@ -88,14 +94,14 @@ import {
   reconcileProvenanceRead,
   serializeProvenanceFields
 } from "./chunk-OEHCMALU.js";
-import {
-  sanitizeMemoryContent
-} from "./chunk-5GKPFL3S.js";
 import {
   matchEntitySchemaSection,
   normalizeEntityStructuredSection,
   sortStructuredSectionsBySchema
 } from "./chunk-4DJQYKMN.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
 import {
   log
 } from "./chunk-37CTGERM.js";
@@ -118,10 +124,10 @@ import {
 } from "./chunk-VS2IYZRU.js";
 
 // src/storage.ts
-import { access, readdir as readdir4, readFile, stat as stat2, writeFile, mkdir, unlink as unlink2, appendFile, open as open2 } from "fs/promises";
+import { access, lstat as lstat2, readdir as readdir4, readFile, realpath as realpath2, stat as stat2, writeFile, mkdir, unlink as unlink2, appendFile, open as open2 } from "fs/promises";
 import { appendFileSync, createReadStream as createReadStream2, mkdirSync, readFileSync, statSync } from "fs";
-import { createHash } from "crypto";
-import path4 from "path";
+import { createHash as createHash3 } from "crypto";
+import path5 from "path";
 
 // src/storage/memory-read-store.ts
 import { lstat, readdir, realpath, stat } from "fs/promises";
@@ -1259,6 +1265,1050 @@ var IdentityContinuityStore = class {
   }
 };
 
+// src/wearables/fusion/cluster.ts
+var DEFAULT_PROXIMITY_GAP_MS = 5 * 6e4;
+function maxSegmentExtent(segments) {
+  let best;
+  for (const seg of segments) {
+    const iso = seg.endIso ?? seg.startIso;
+    if (iso === void 0) continue;
+    const ms = Date.parse(iso);
+    if (!Number.isFinite(ms)) continue;
+    if (best === void 0 || ms > best.ms) {
+      best = { ms, iso };
+    }
+  }
+  return best;
+}
+function effectiveInterval(conversation) {
+  const start = Date.parse(conversation.startIso);
+  const endRaw = conversation.endIso !== void 0 ? Date.parse(conversation.endIso) : NaN;
+  const end = Number.isFinite(endRaw) ? endRaw : maxSegmentExtent(conversation.segments)?.ms ?? start;
+  return { start, end: Math.max(end, start) };
+}
+function compareConversation(a, b) {
+  if (a.source !== b.source) return a.source < b.source ? -1 : 1;
+  if (a.conversationId !== b.conversationId) {
+    return a.conversationId < b.conversationId ? -1 : 1;
+  }
+  return 0;
+}
+function clusterConversations(inputs, proximityGapMs = DEFAULT_PROXIMITY_GAP_MS) {
+  const finite = [];
+  const noStart = [];
+  for (const conv of inputs) {
+    const interval = effectiveInterval(conv);
+    if (Number.isFinite(interval.start)) {
+      finite.push({ conv, interval });
+    } else {
+      noStart.push(conv);
+    }
+  }
+  finite.sort((a, b) => {
+    if (a.interval.start !== b.interval.start) {
+      return a.interval.start - b.interval.start;
+    }
+    return compareConversation(a.conv, b.conv);
+  });
+  const n = finite.length;
+  const parent = new Array(n);
+  for (let i = 0; i < n; i++) parent[i] = i;
+  const find = (x) => {
+    let root = x;
+    while (parent[root] !== root) root = parent[root];
+    let cur = x;
+    while (parent[cur] !== root) {
+      const next = parent[cur];
+      parent[cur] = root;
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+  for (let i = 0; i < n; i++) {
+    const endGap = finite[i].interval.end + proximityGapMs;
+    for (let j = i + 1; j < n; j++) {
+      if (finite[j].interval.start > endGap) break;
+      if (finite[i].conv.source === finite[j].conv.source) continue;
+      union(i, j);
+    }
+  }
+  const clusters = [];
+  const rootToCluster = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const root = find(i);
+    let idx = rootToCluster.get(root);
+    if (idx === void 0) {
+      idx = clusters.length;
+      rootToCluster.set(root, idx);
+      clusters.push([]);
+    }
+    clusters[idx].push(finite[i].conv);
+  }
+  noStart.sort(compareConversation);
+  for (const conv of noStart) {
+    clusters.push([conv]);
+  }
+  return clusters;
+}
+
+// src/wearables/fusion/reconcile.ts
+var DEFAULT_WINDOW_TOLERANCE_MS = 3e4;
+var DEFAULT_SOURCE_TRUST = 0.8;
+var TRUST_DECISION_EPSILON = 1e-9;
+var GENERIC_LABEL_PATTERN = /^(Speaker \d+|Unknown speaker|SPEAKER_\d+)$/i;
+function speakerKey(label, isSelf) {
+  return isSelf ? "self" : label;
+}
+function resolveTrust(source, trustMap) {
+  const value = trustMap?.[source];
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.min(1, Math.max(0, value));
+  }
+  return DEFAULT_SOURCE_TRUST;
+}
+function normalizeWords(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((word) => word.length > 0);
+}
+function wordsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function isWordPrefix(short, long) {
+  if (short.length === 0 || short.length > long.length) return false;
+  for (let i = 0; i < short.length; i++) {
+    if (short[i] !== long[i]) return false;
+  }
+  return true;
+}
+function wordsCorroborate(a, b, allowPrefix) {
+  if (wordsEqual(a, b)) return true;
+  if (!allowPrefix) return false;
+  return isWordPrefix(a, b) || isWordPrefix(b, a);
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(1, Math.max(0, value));
+}
+function fusionInputsFromConversations(sourceId, conversations, registry) {
+  return conversations.map((conversation) => {
+    const segments = conversation.segments.map((raw) => {
+      const resolved = resolveSpeaker(sourceId, raw, registry);
+      return {
+        speaker: resolved.label,
+        isSelf: resolved.isSelf,
+        text: raw.text,
+        ...raw.startIso !== void 0 ? { startIso: raw.startIso } : {},
+        ...raw.endIso !== void 0 ? { endIso: raw.endIso } : {}
+      };
+    });
+    return {
+      source: sourceId,
+      conversationId: conversation.id,
+      startIso: conversation.startIso,
+      ...conversation.endIso !== void 0 ? { endIso: conversation.endIso } : {},
+      ...conversation.title !== void 0 ? { title: conversation.title } : {},
+      ...conversation.summary !== void 0 ? { summary: conversation.summary } : {},
+      segments
+    };
+  });
+}
+function fuseCluster(cluster, options = {}) {
+  const trustMap = options.sourceTrust;
+  const toleranceMs = options.windowToleranceMs ?? DEFAULT_WINDOW_TOLERANCE_MS;
+  const sources = [];
+  const sourcesSeen = /* @__PURE__ */ new Set();
+  for (const conv of cluster) {
+    if (!sourcesSeen.has(conv.source)) {
+      sourcesSeen.add(conv.source);
+      sources.push(conv.source);
+    }
+  }
+  let startMs = Number.POSITIVE_INFINITY;
+  let endMs = Number.NEGATIVE_INFINITY;
+  let startIso;
+  let endIso;
+  for (const conv of cluster) {
+    const ms = Date.parse(conv.startIso);
+    if (Number.isFinite(ms) && ms < startMs) {
+      startMs = ms;
+      startIso = conv.startIso;
+    }
+    if (conv.endIso !== void 0) {
+      const endM = Date.parse(conv.endIso);
+      if (Number.isFinite(endM) && endM > endMs) {
+        endMs = endM;
+        endIso = conv.endIso;
+      }
+    }
+  }
+  const segmentExtent = maxSegmentExtent(
+    cluster.flatMap((conv) => conv.segments)
+  );
+  if (segmentExtent !== void 0 && segmentExtent.ms > endMs) {
+    endMs = segmentExtent.ms;
+    endIso = segmentExtent.iso;
+  }
+  if (endIso !== void 0 && Number.isFinite(startMs) && endMs < startMs) {
+    endIso = startIso;
+    endMs = startMs;
+  }
+  if (startIso === void 0) {
+    startIso = cluster[0]?.startIso ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  let title;
+  let summary;
+  for (const conv of cluster) {
+    if (title === void 0 && conv.title !== void 0 && conv.title.trim().length > 0) {
+      title = conv.title.trim();
+    }
+    if (summary === void 0 && conv.summary !== void 0 && conv.summary.trim().length > 0) {
+      summary = conv.summary.trim();
+    }
+    if (title !== void 0 && summary !== void 0) break;
+  }
+  const tagged = [];
+  for (const conv of cluster) {
+    const sourceTrust = resolveTrust(conv.source, trustMap);
+    for (const segment of conv.segments) {
+      const startMsValue = segment.startIso !== void 0 ? Date.parse(segment.startIso) : NaN;
+      tagged.push({
+        source: conv.source,
+        conversationId: conv.conversationId,
+        speakerLabel: segment.speaker,
+        isSelf: segment.isSelf,
+        text: segment.text,
+        startMs: Number.isFinite(startMsValue) ? startMsValue : Number.POSITIVE_INFINITY,
+        ...segment.startIso !== void 0 ? { startIso: segment.startIso } : {},
+        ...segment.endIso !== void 0 ? { endIso: segment.endIso } : {},
+        sourceTrust,
+        originalIndex: tagged.length
+      });
+    }
+  }
+  tagged.sort((a, b) => {
+    const aFinite = Number.isFinite(a.startMs);
+    const bFinite = Number.isFinite(b.startMs);
+    if (aFinite && bFinite && a.startMs !== b.startMs) return a.startMs - b.startMs;
+    if (aFinite !== bFinite) return aFinite ? -1 : 1;
+    return a.originalIndex - b.originalIndex;
+  });
+  const groups = [];
+  for (const seg of tagged) {
+    const key = speakerKey(seg.speakerLabel, seg.isSelf);
+    const segMissing = !Number.isFinite(seg.startMs);
+    const segWords = normalizeWords(seg.text);
+    const corroborates = (group) => {
+      if (group.members.some((member) => member.source === seg.source)) {
+        return false;
+      }
+      const groupMissing = !Number.isFinite(group.anchorMs);
+      if (groupMissing !== segMissing) return false;
+      if (!groupMissing && Math.abs(seg.startMs - group.anchorMs) > toleranceMs) {
+        return false;
+      }
+      return group.members.some(
+        (member) => wordsCorroborate(normalizeWords(member.text), segWords, !groupMissing)
+      );
+    };
+    const closestCorroborating = (wantSameSpeaker) => {
+      let best;
+      let bestDelta = Infinity;
+      for (const group of groups) {
+        if (group.key === key !== wantSameSpeaker || !corroborates(group)) {
+          continue;
+        }
+        const delta = !segMissing && Number.isFinite(group.anchorMs) ? Math.abs(seg.startMs - group.anchorMs) : 0;
+        if (best === void 0 || delta < bestDelta || delta === bestDelta && group.anchorMs < best.anchorMs) {
+          best = group;
+          bestDelta = delta;
+        }
+      }
+      return best;
+    };
+    let chosen = closestCorroborating(true);
+    if (chosen === void 0) {
+      chosen = closestCorroborating(false);
+    }
+    if (chosen !== void 0) {
+      chosen.members.push(seg);
+      if (seg.originalIndex < chosen.originalIndex) {
+        chosen.originalIndex = seg.originalIndex;
+      }
+    } else {
+      groups.push({
+        key,
+        speakerLabel: seg.speakerLabel,
+        isSelf: seg.isSelf,
+        members: [seg],
+        anchorMs: seg.startMs,
+        // The creating segment is the EARLIEST member (tagged is
+        // time-sorted), so its clock IS the group anchor that groups are
+        // sorted by and that the fused segment must be emitted at.
+        anchorStartIso: seg.startIso,
+        anchorEndIso: seg.endIso,
+        originalIndex: seg.originalIndex
+      });
+    }
+  }
+  groups.sort((a, b) => {
+    const aMissing = !Number.isFinite(a.anchorMs);
+    const bMissing = !Number.isFinite(b.anchorMs);
+    if (aMissing !== bMissing) return aMissing ? 1 : -1;
+    if (!aMissing && a.anchorMs !== b.anchorMs) return a.anchorMs - b.anchorMs;
+    return a.originalIndex - b.originalIndex;
+  });
+  const segments = [];
+  const disagreements = [];
+  for (const group of groups) {
+    const reconciled = reconcileGroup(group);
+    segments.push(reconciled.segment);
+    disagreements.push(...reconciled.disagreements);
+  }
+  const preSortOrder = new Map(segments.map((seg, i) => [seg, i]));
+  segments.sort((a, b) => {
+    const aMs = a.startIso !== void 0 ? Date.parse(a.startIso) : Number.NaN;
+    const bMs = b.startIso !== void 0 ? Date.parse(b.startIso) : Number.NaN;
+    const aFinite = Number.isFinite(aMs);
+    const bFinite = Number.isFinite(bMs);
+    if (aFinite && bFinite) {
+      if (aMs !== bMs) return aMs - bMs;
+    } else if (aFinite !== bFinite) {
+      return aFinite ? -1 : 1;
+    }
+    return (preSortOrder.get(a) ?? 0) - (preSortOrder.get(b) ?? 0);
+  });
+  detectCrossSegmentDisagreements(segments, toleranceMs, disagreements);
+  const result = {
+    sources,
+    speakers: collectSpeakers(tagged),
+    startIso,
+    segments,
+    disagreements
+  };
+  if (endIso !== void 0) result.endIso = endIso;
+  if (title !== void 0) result.title = title;
+  if (summary !== void 0) result.summary = summary;
+  return result;
+}
+function reconcileGroup(group) {
+  const members = group.members;
+  const ranked = [...members].sort((a, b) => {
+    if (Math.abs(b.sourceTrust - a.sourceTrust) > TRUST_DECISION_EPSILON) {
+      return b.sourceTrust - a.sourceTrust;
+    }
+    if (b.text.length !== a.text.length) return b.text.length - a.text.length;
+    if (a.source !== b.source) return a.source < b.source ? -1 : 1;
+    if (a.conversationId !== b.conversationId) {
+      return a.conversationId < b.conversationId ? -1 : 1;
+    }
+    return a.originalIndex - b.originalIndex;
+  });
+  const top = ranked[0];
+  const topWords = normalizeWords(top.text);
+  let chosen = top;
+  if (topWords.length > 0) {
+    let bestLen = -1;
+    for (const candidate of ranked) {
+      if (candidate === top) continue;
+      const candidateWords = normalizeWords(candidate.text);
+      if (isWordPrefix(topWords, candidateWords) && candidateWords.length > topWords.length && candidateWords.length > bestLen) {
+        chosen = candidate;
+        bestLen = candidateWords.length;
+      }
+    }
+  }
+  const truncatedOverride = chosen !== top;
+  const others = ranked.filter((member) => member !== chosen);
+  const chosenWords = normalizeWords(chosen.text);
+  const reason = members.length === 1 ? "only-source" : truncatedOverride ? "more-complete" : others.some(
+    (r) => chosen.sourceTrust - r.sourceTrust > TRUST_DECISION_EPSILON
+  ) ? "higher-trust" : others.some((r) => chosen.text.length - r.text.length > 0) ? "more-complete" : "tie-break";
+  const disagree = [];
+  let conflict = false;
+  for (const candidate of others) {
+    const candidateWords = normalizeWords(candidate.text);
+    if (chosenWords.length === 0 && candidateWords.length === 0) continue;
+    if (wordsEqual(chosenWords, candidateWords)) continue;
+    if (isWordPrefix(candidateWords, chosenWords) || isWordPrefix(chosenWords, candidateWords)) {
+      continue;
+    }
+    conflict = true;
+    disagree.push({ source: candidate.source, value: candidate.text });
+  }
+  const distinctSpeakerKeys = new Set(
+    members.map((m) => speakerKey(m.speakerLabel, m.isSelf))
+  );
+  const speakerConflict = distinctSpeakerKeys.size > 1;
+  const alternatives = others.map((candidate) => ({
+    source: candidate.source,
+    text: candidate.text
+  }));
+  const confidence = conflict || speakerConflict ? clamp01(chosen.sourceTrust * 0.7) : members.length > 1 ? clamp01(chosen.sourceTrust + 0.1 * (members.length - 1)) : clamp01(chosen.sourceTrust);
+  const segment = {
+    speaker: chosen.speakerLabel,
+    isSelf: chosen.isSelf,
+    text: chosen.text,
+    confidence,
+    provenance: {
+      source: chosen.source,
+      conversationId: chosen.conversationId,
+      sourceTrust: chosen.sourceTrust,
+      reason,
+      alternatives,
+      ...chosen.startIso !== void 0 ? { sourceStartIso: chosen.startIso } : {},
+      ...chosen.endIso !== void 0 ? { sourceEndIso: chosen.endIso } : {}
+    },
+    ...group.anchorStartIso !== void 0 ? { startIso: group.anchorStartIso } : {},
+    ...group.anchorEndIso !== void 0 ? { endIso: group.anchorEndIso } : {}
+  };
+  const disagreements = [];
+  const anchorIso = group.anchorStartIso ?? (Number.isFinite(group.anchorMs) ? new Date(group.anchorMs).toISOString() : void 0);
+  if (conflict) {
+    disagreements.push({
+      kind: "asr-text",
+      subject: anchorIso ?? "(no timestamp)",
+      candidates: [{ source: chosen.source, value: chosen.text }, ...disagree],
+      provisional: { source: chosen.source, value: chosen.text }
+    });
+  }
+  if (speakerConflict) {
+    const speakerCandidates = members.map((m) => ({ source: m.source, value: m.speakerLabel })).sort(
+      (a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0
+    );
+    disagreements.push({
+      kind: "speaker",
+      subject: anchorIso ?? "(no timestamp)",
+      candidates: speakerCandidates,
+      provisional: { source: chosen.source, value: chosen.speakerLabel }
+    });
+  }
+  return { segment, disagreements };
+}
+function detectCrossSegmentDisagreements(segments, toleranceMs, out) {
+  const n = segments.length;
+  if (n < 2) return;
+  const claimed = new Array(n).fill(false);
+  for (let i = 0; i < n; i++) {
+    if (claimed[i]) continue;
+    const seed = segments[i];
+    const seedMs = seed.startIso !== void 0 ? Date.parse(seed.startIso) : NaN;
+    if (!Number.isFinite(seedMs)) continue;
+    const seedWords = normalizeWords(seed.text);
+    const clusterIdx = [];
+    for (let j = i + 1; j < n; j++) {
+      if (claimed[j]) continue;
+      const cand = segments[j];
+      if (speakerKey(cand.speaker, cand.isSelf) !== speakerKey(seed.speaker, seed.isSelf)) {
+        continue;
+      }
+      if (cand.provenance.source === seed.provenance.source) continue;
+      const candMs = cand.startIso !== void 0 ? Date.parse(cand.startIso) : NaN;
+      if (!Number.isFinite(candMs)) continue;
+      if (Math.abs(candMs - seedMs) > toleranceMs) continue;
+      if (wordsCorroborate(seedWords, normalizeWords(cand.text), true)) {
+        continue;
+      }
+      clusterIdx.push(j);
+    }
+    if (clusterIdx.length === 0) continue;
+    clusterIdx.unshift(i);
+    for (const idx of clusterIdx) claimed[idx] = true;
+    const involved = clusterIdx.map((idx) => segments[idx]);
+    const involvedOrder = new Map(involved.map((seg, i2) => [seg, i2]));
+    involved.sort((a, b) => {
+      if (Math.abs(b.provenance.sourceTrust - a.provenance.sourceTrust) > TRUST_DECISION_EPSILON) {
+        return b.provenance.sourceTrust - a.provenance.sourceTrust;
+      }
+      if (b.text.length !== a.text.length) return b.text.length - a.text.length;
+      if (a.provenance.source !== b.provenance.source) {
+        return a.provenance.source < b.provenance.source ? -1 : 1;
+      }
+      return involvedOrder.get(a) - involvedOrder.get(b);
+    });
+    const provisional = involved[0];
+    const anchorIso = involved.map((s) => s.startIso).filter((v) => v !== void 0).sort()[0];
+    for (const seg of involved) {
+      seg.confidence = clamp01(seg.provenance.sourceTrust * 0.7);
+    }
+    out.push({
+      kind: "asr-text",
+      subject: anchorIso ?? "(no timestamp)",
+      candidates: involved.map((s) => ({
+        source: s.provenance.source,
+        value: s.text
+      })),
+      provisional: {
+        source: provisional.provenance.source,
+        value: provisional.text
+      }
+    });
+  }
+}
+function collectSpeakers(tagged) {
+  const order = [];
+  const acc = /* @__PURE__ */ new Map();
+  for (const seg of tagged) {
+    const key = speakerKey(seg.speakerLabel, seg.isSelf);
+    let entry = acc.get(key);
+    if (entry === void 0) {
+      entry = {
+        label: seg.speakerLabel,
+        isSelf: seg.isSelf,
+        sources: /* @__PURE__ */ new Set(),
+        generic: GENERIC_LABEL_PATTERN.test(seg.speakerLabel)
+      };
+      acc.set(key, entry);
+      order.push(key);
+    }
+    entry.sources.add(seg.source);
+  }
+  return order.map((key) => {
+    const entry = acc.get(key);
+    if (entry === void 0) throw new Error("fusion speaker accumulator miss");
+    const sourceCount = entry.sources.size;
+    const confidence = entry.isSelf ? sourceCount > 1 ? 0.95 : 0.85 : entry.generic ? sourceCount > 1 ? 0.7 : 0.5 : sourceCount > 1 ? 0.9 : 0.7;
+    return {
+      label: entry.label,
+      isSelf: entry.isSelf,
+      confidence,
+      sources: [...entry.sources].sort()
+    };
+  });
+}
+
+// src/wearables/fusion/fuse.ts
+import { createHash } from "crypto";
+var FUSION_ID_PREFIX = "fusion";
+var FUSION_ALGO_VERSION = "2026-07-12-1";
+function canonicalInputsKey(date, inputs) {
+  const sorted = [...inputs].sort((a, b) => {
+    if (a.source !== b.source) return a.source < b.source ? -1 : 1;
+    if (a.conversationId !== b.conversationId) {
+      return a.conversationId < b.conversationId ? -1 : 1;
+    }
+    return 0;
+  });
+  const record = [
+    date,
+    sorted.map((conv) => [
+      conv.source,
+      conv.conversationId,
+      conv.startIso,
+      conv.endIso ?? "",
+      conv.title ?? "",
+      conv.summary ?? "",
+      conv.segments.map((segment) => [
+        segment.speaker,
+        segment.isSelf ? "self" : "other",
+        segment.startIso ?? "",
+        segment.endIso ?? "",
+        segment.text
+      ])
+    ])
+  ];
+  return createHash("sha256").update(JSON.stringify(record), "utf-8").digest("hex");
+}
+function configFingerprint(options, sources) {
+  const proximityGapMs = options.proximityGapMs ?? DEFAULT_PROXIMITY_GAP_MS;
+  const windowToleranceMs = options.windowToleranceMs ?? DEFAULT_WINDOW_TOLERANCE_MS;
+  const trustMap = options.sourceTrust ?? {};
+  const trustEntries = [...new Set(sources)].sort().map((source) => [source, trustMap[source] ?? DEFAULT_SOURCE_TRUST]);
+  return JSON.stringify([proximityGapMs, windowToleranceMs, trustEntries]);
+}
+function canonicalDayKey(date, inputs, options, algoVersion = FUSION_ALGO_VERSION) {
+  const inputsKey = canonicalInputsKey(date, inputs);
+  const fingerprint = configFingerprint(
+    options,
+    inputs.map((conv) => conv.source)
+  );
+  return createHash("sha256").update(inputsKey).update("\n").update(fingerprint).update("\n").update(algoVersion).digest("hex");
+}
+function buildProvenance(cluster, proximityGapMs, windowToleranceMs) {
+  return {
+    contributions: cluster.map((conv) => ({
+      source: conv.source,
+      conversationId: conv.conversationId,
+      startIso: conv.startIso,
+      ...conv.endIso !== void 0 ? { endIso: conv.endIso } : {},
+      segmentCount: conv.segments.length
+    })),
+    proximityGapMs,
+    windowToleranceMs,
+    method: "time-proximity"
+  };
+}
+function fuseDay(date, inputs, options = {}) {
+  const proximityGapMs = options.proximityGapMs ?? DEFAULT_PROXIMITY_GAP_MS;
+  const windowToleranceMs = options.windowToleranceMs ?? DEFAULT_WINDOW_TOLERANCE_MS;
+  const clusters = clusterConversations(inputs, proximityGapMs);
+  const conversations = clusters.map((cluster) => {
+    const fused = fuseCluster(cluster, {
+      ...options,
+      windowToleranceMs
+    });
+    const id = `${FUSION_ID_PREFIX}-${canonicalInputsKey(date, cluster).slice(0, 24)}`;
+    const result = {
+      id,
+      date,
+      startIso: fused.startIso,
+      sources: fused.sources,
+      speakers: fused.speakers,
+      segments: fused.segments,
+      disagreements: fused.disagreements,
+      provenance: buildProvenance(cluster, proximityGapMs, windowToleranceMs)
+    };
+    if (fused.endIso !== void 0) result.endIso = fused.endIso;
+    if (fused.title !== void 0) result.title = fused.title;
+    if (fused.summary !== void 0) result.summary = fused.summary;
+    return result;
+  });
+  const sourcesSeen = /* @__PURE__ */ new Set();
+  const sources = [];
+  for (const conv of conversations) {
+    for (const source of conv.sources) {
+      if (!sourcesSeen.has(source)) {
+        sourcesSeen.add(source);
+        sources.push(source);
+      }
+    }
+  }
+  return {
+    date,
+    conversations,
+    sources,
+    contentHash: canonicalDayKey(date, inputs, options)
+  };
+}
+
+// src/wearables/fusion/store.ts
+import { createHash as createHash2 } from "crypto";
+import * as path4 from "path";
+var FUSION_KIND = "wearable-fusion";
+function hashFusionBody(conversations) {
+  return createHash2("sha256").update(JSON.stringify(conversations), "utf-8").digest("hex");
+}
+function composeFusionDayMeta(date, conversations, sources, contentHash, fusedAt) {
+  return {
+    kind: FUSION_KIND,
+    date,
+    sourceCount: sources.length,
+    conversationCount: conversations.length,
+    contentHash,
+    bodyHash: hashFusionBody(conversations),
+    fusedAt
+  };
+}
+function serializeFusionDay(meta, conversations) {
+  const lines = ["---"];
+  lines.push(`kind: ${meta.kind}`);
+  lines.push(`date: ${JSON.stringify(meta.date)}`);
+  lines.push(`sourceCount: ${meta.sourceCount}`);
+  lines.push(`conversationCount: ${meta.conversationCount}`);
+  lines.push(`contentHash: ${JSON.stringify(meta.contentHash)}`);
+  lines.push(`bodyHash: ${JSON.stringify(meta.bodyHash)}`);
+  lines.push(`fusedAt: ${JSON.stringify(meta.fusedAt)}`);
+  lines.push("---");
+  lines.push("");
+  return `${lines.join("\n")}
+${JSON.stringify(conversations, null, 2)}
+`;
+}
+function parseScalar(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed === "string") return parsed;
+    } catch {
+    }
+  }
+  return trimmed;
+}
+function parseNonNegativeInt(value) {
+  if (value === void 0) return 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return 0;
+  return Math.floor(parsed);
+}
+var FUSED_SEGMENT_PICK_REASONS = {
+  "only-source": true,
+  "higher-trust": true,
+  "more-complete": true,
+  "tie-break": true
+};
+var FUSED_DISAGREEMENT_KINDS = {
+  "asr-text": true,
+  speaker: true,
+  timestamp: true
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isFusedSegmentProvenance(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.source !== "string") return false;
+  if (typeof value.conversationId !== "string") return false;
+  if (typeof value.sourceTrust !== "number") return false;
+  if (typeof value.reason !== "string") return false;
+  if (!(value.reason in FUSED_SEGMENT_PICK_REASONS)) return false;
+  return Array.isArray(value.alternatives) && value.alternatives.every(
+    (alt) => isPlainObject(alt) && typeof alt.source === "string" && typeof alt.text === "string"
+  );
+}
+function isFusedSegment(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.speaker !== "string") return false;
+  if (typeof value.isSelf !== "boolean") return false;
+  if (typeof value.text !== "string") return false;
+  if (typeof value.confidence !== "number") return false;
+  return isFusedSegmentProvenance(value.provenance);
+}
+function isFusedSpeaker(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.label !== "string") return false;
+  if (typeof value.isSelf !== "boolean") return false;
+  if (typeof value.confidence !== "number") return false;
+  return isStringArray(value.sources);
+}
+function isFusedDisagreement(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.kind !== "string") return false;
+  if (!(value.kind in FUSED_DISAGREEMENT_KINDS)) return false;
+  if (typeof value.subject !== "string") return false;
+  return Array.isArray(value.candidates) && value.candidates.every(
+    (cand) => isPlainObject(cand) && typeof cand.source === "string" && typeof cand.value === "string"
+  );
+}
+function isFusedContribution(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.source !== "string") return false;
+  if (typeof value.conversationId !== "string") return false;
+  if (typeof value.startIso !== "string") return false;
+  return typeof value.segmentCount === "number";
+}
+function isFusedConversationProvenance(value) {
+  if (!isPlainObject(value)) return false;
+  if (!Array.isArray(value.contributions) || !value.contributions.every(isFusedContribution)) {
+    return false;
+  }
+  if (typeof value.proximityGapMs !== "number") return false;
+  if (typeof value.windowToleranceMs !== "number") return false;
+  return value.method === "time-proximity";
+}
+function isFusedWearableConversation(value) {
+  if (!isPlainObject(value)) return false;
+  if (typeof value.id !== "string") return false;
+  if (typeof value.date !== "string") return false;
+  if (typeof value.startIso !== "string") return false;
+  if (!isStringArray(value.sources)) return false;
+  if (!Array.isArray(value.speakers) || !value.speakers.every(isFusedSpeaker)) return false;
+  if (!Array.isArray(value.segments) || !value.segments.every(isFusedSegment)) return false;
+  if (!Array.isArray(value.disagreements) || !value.disagreements.every(isFusedDisagreement)) {
+    return false;
+  }
+  return isFusedConversationProvenance(value.provenance);
+}
+function parseFusionDay(raw) {
+  if (!raw.startsWith("---\n")) return null;
+  const closeIndex = raw.indexOf("\n---\n", 4);
+  if (closeIndex === -1) return null;
+  const header = raw.slice(4, closeIndex);
+  const body = raw.slice(closeIndex + 5).replace(/^\n/, "");
+  const scalars = /* @__PURE__ */ new Map();
+  for (const line of header.split("\n")) {
+    const match = line.match(/^([A-Za-z][A-Za-z0-9]*): (.*)$/);
+    if (match) scalars.set(match[1], parseScalar(match[2]));
+  }
+  if (scalars.get("kind") !== FUSION_KIND) return null;
+  const date = scalars.get("date");
+  if (date === void 0) return null;
+  let conversations = [];
+  let parseOk = true;
+  const bodyTrimmed = body.trim();
+  if (bodyTrimmed.length === 0) {
+    parseOk = false;
+  } else {
+    try {
+      const parsed = JSON.parse(bodyTrimmed);
+      if (Array.isArray(parsed) && parsed.every(isFusedWearableConversation)) {
+        conversations = parsed;
+      } else {
+        parseOk = false;
+      }
+    } catch {
+      parseOk = false;
+    }
+  }
+  const meta = {
+    kind: FUSION_KIND,
+    date,
+    sourceCount: parseNonNegativeInt(scalars.get("sourceCount")),
+    conversationCount: parseNonNegativeInt(scalars.get("conversationCount")),
+    contentHash: scalars.get("contentHash") ?? "",
+    bodyHash: scalars.get("bodyHash") ?? "",
+    fusedAt: scalars.get("fusedAt") ?? ""
+  };
+  return { meta, conversations, parseOk };
+}
+var FUSION_DIR_NAME = "_fusion";
+var FusionArtifactStore = class {
+  constructor(wearablesDir, memoryDir, io) {
+    this.wearablesDir = wearablesDir;
+    this.memoryDir = memoryDir;
+    this.io = io;
+  }
+  wearablesDir;
+  memoryDir;
+  io;
+  fusedDayPath(date) {
+    if (!isValidTranscriptDate(date)) {
+      throw new Error(
+        `invalid wearable fusion date '${String(date)}' \u2014 expected YYYY-MM-DD`
+      );
+    }
+    return path4.join(this.wearablesDir, FUSION_DIR_NAME, `${date}.md`);
+  }
+  async writeFusedDay(date, serialized) {
+    const filePath = this.fusedDayPath(date);
+    await this.assertPathContained(filePath);
+    await this.io.writeFile(filePath, serialized);
+  }
+  /** Read a stored fused-day artifact; null when absent. */
+  async readFusedDay(date) {
+    const filePath = this.fusedDayPath(date);
+    await this.assertPathContained(filePath);
+    try {
+      return await this.io.readFile(filePath);
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  /**
+   * Remove a stored fused-day artifact. Idempotent: a no-op when the
+   * artifact is already absent. Used to clear a now-stale derived file
+   * before a fusion run that deliberately refuses to fuse (e.g. a day
+   * whose sources later conflict on timezone) so fusedConversations()
+   * does not keep serving a stale view (issue #1849).
+   */
+  async deleteFusedDay(date) {
+    const filePath = this.fusedDayPath(date);
+    await this.assertPathContained(filePath);
+    try {
+      await this.io.deleteFile(filePath);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+  }
+  /** List dates with stored fused artifacts, newest first. */
+  async listFusedDays() {
+    const fusionDir = path4.join(this.wearablesDir, FUSION_DIR_NAME);
+    await this.assertPathContained(fusionDir);
+    let entries;
+    try {
+      entries = await this.io.readDir(fusionDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    const days = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const date = entry.slice(0, -3);
+      if (!isValidTranscriptDate(date)) continue;
+      days.push(date);
+    }
+    days.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
+    return days;
+  }
+  /**
+   * Reject a symlinked/traversing fusion artifact path before any IO. The
+   * fusion dir (`<wearablesDir>/_fusion`) and its parents are followed
+   * directly by the secure IO; a symlink placed there (attacker-writable
+   * or a malformed memory dir) would otherwise be followed and
+   * read/write/delete outside the allowed root (AGENTS.md pattern #3).
+   *
+   * Containment is anchored to the real MEMORY-DIR root, not the
+   * wearables dir, AND the wearables root is checked explicitly: if
+   * `wearablesDir` itself is a symlink that resolves outside memoryDir, a
+   * leaf candidate like `<wearablesDir>/_fusion/<date>.md` may not yet
+   * exist (so its realpath ENOENT-skips) and the write would silently
+   * create the file inside the symlinked escape target. Checking
+   * `wearablesDir` itself — which resolves through the symlink when it
+   * exists — closes that gap, while the per-leaf checks catch a nested
+   * `_fusion` or per-file symlink. Absent paths are allowed (a fresh
+   * write creates them lexically under the root; only a path that
+   * resolves to an existing target can redirect IO). Mirrors
+   * `assertPathInsideRoot` in the storage walkers.
+   */
+  async assertPathContained(targetPath) {
+    let rootReal;
+    try {
+      rootReal = await this.io.realpath(this.memoryDir);
+    } catch {
+      rootReal = path4.resolve(this.memoryDir);
+    }
+    await this.assertNoEscape(rootReal, this.wearablesDir);
+    await this.assertNoEscape(rootReal, path4.dirname(targetPath));
+    await this.assertNoEscape(rootReal, targetPath);
+    await this.assertFusionDirNotSymlinked();
+  }
+  /**
+   * Refuse a pre-existing symbolic link at the `<wearablesDir>/_fusion`
+   * directory. Unlike `assertNoEscape` (which follows the link and only
+   * rejects when the target lands outside the memory dir), this catches a
+   * fusion root that aliases an in-bounds path — e.g. a `_fusion` link
+   * pointed at a raw source transcript — so fusion IO never writes
+   * through it and overwrites the aliased file. Absent dirs are allowed
+   * (a fresh write creates a real directory lexically under the root).
+   */
+  async assertFusionDirNotSymlinked() {
+    const fusionDir = path4.join(this.wearablesDir, FUSION_DIR_NAME);
+    let stat3;
+    try {
+      stat3 = await this.io.lstat(fusionDir);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+    if (stat3.isSymbolicLink) {
+      throw new Error(
+        "wearable fusion dir '_fusion' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)"
+      );
+    }
+  }
+  /**
+   * Refuse a candidate whose realpath escapes the memory root. Absent
+   * candidates are allowed: a missing path cannot yet redirect IO, and
+   * the secure write creates it lexically under the root.
+   */
+  async assertNoEscape(rootReal, candidate) {
+    let candidateReal;
+    try {
+      candidateReal = await this.io.realpath(candidate);
+    } catch {
+      return;
+    }
+    if (!pathIsInside(rootReal, candidateReal)) {
+      throw new Error(
+        "wearable fusion artifact path resolves outside the memory dir \u2014 refusing to follow a symlink/traversal (AGENTS.md pattern #3)"
+      );
+    }
+  }
+};
+
+// src/wearables/fusion/reconstruct.ts
+var CONVERSATION_HEADING = /^## (.+?)\u2013(.+?)(?:\s\u00b7\s(.*))?\s\(conversation (.+)\)$/;
+var LOCATION_LINE = /^\*Location: (.+)\*$/;
+var CLOCK_PATTERN = /^(\d{2}):(\d{2})$/;
+var MINUTES_PER_DAY = 24 * 60;
+var MAX_PLAUSIBLE_WRAP_MINUTES = 12 * 60;
+function clockToIso(clock, date) {
+  const match = CLOCK_PATTERN.exec(clock.trim());
+  if (match === null) return void 0;
+  const hour = match[1] === "24" ? "00" : match[1];
+  return `${date}T${hour}:${match[2]}:00.000Z`;
+}
+function clockMinutesOfDay(clock) {
+  const match = CLOCK_PATTERN.exec(clock.trim());
+  if (match === null) return void 0;
+  const hour = match[1] === "24" ? 0 : Number.parseInt(match[1], 10);
+  return hour * 60 + Number.parseInt(match[2], 10);
+}
+function nextCalendarDay(date) {
+  const [y, m, d] = date.split("-").map((part) => Number.parseInt(part, 10));
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  dt.setUTCDate(dt.getUTCDate() + 1);
+  const yy = dt.getUTCFullYear();
+  const mm = String(dt.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(dt.getUTCDate()).padStart(2, "0");
+  return `${yy}-${mm}-${dd}`;
+}
+function reconstructFusionInputs(date, dayTranscripts) {
+  if (!isValidTranscriptDate(date)) return [];
+  const inputs = [];
+  for (const { source, body, escaped } of dayTranscripts) {
+    let current = null;
+    const flushCurrent = () => {
+      if (current === null) return;
+      const startIso = current.startIso ?? current.segments.find((segment) => segment.startIso !== void 0)?.startIso ?? `${date}T00:00:00.000Z`;
+      const input = {
+        source,
+        conversationId: current.conversationId,
+        startIso,
+        segments: current.segments
+      };
+      if (current.endIso !== void 0) input.endIso = current.endIso;
+      if (current.title !== void 0) input.title = current.title;
+      inputs.push(input);
+      current = null;
+    };
+    for (const rawLine of body.split("\n")) {
+      const line = rawLine.trimEnd();
+      if (line.length === 0) continue;
+      const heading = CONVERSATION_HEADING.exec(line);
+      if (heading !== null) {
+        flushCurrent();
+        const [, startClock, endClock, title, id] = heading;
+        const startMin = clockMinutesOfDay(startClock);
+        const endMin = clockMinutesOfDay(endClock);
+        const wrapped = startMin !== void 0 && endMin !== void 0 && endMin < startMin;
+        const wrapDuration = startMin !== void 0 && endMin !== void 0 ? MINUTES_PER_DAY - startMin + endMin : void 0;
+        const plausibleWrap = wrapped && wrapDuration !== void 0 && wrapDuration <= MAX_PLAUSIBLE_WRAP_MINUTES;
+        const startIso = clockToIso(startClock, date);
+        const endIso = plausibleWrap ? clockToIso(endClock, nextCalendarDay(date)) : clockToIso(endClock, date);
+        current = {
+          conversationId: id,
+          segments: [],
+          wrapped,
+          ...startMin !== void 0 ? { wrapStartMin: startMin } : {},
+          ...startIso !== void 0 ? { startIso } : {},
+          ...endIso !== void 0 ? { endIso } : {},
+          ...title !== void 0 && title.length > 0 ? { title } : {}
+        };
+        continue;
+      }
+      if (LOCATION_LINE.exec(line) !== null) continue;
+      const segmentMatch = parseTranscriptSegmentLine(line);
+      if (segmentMatch !== null) {
+        if (current === null) continue;
+        const { label, clock, text: rawText } = segmentMatch;
+        const text = escaped ? unescapeSegmentText(rawText) : rawText;
+        const segMin = clockMinutesOfDay(clock);
+        const segWrapDuration = current.wrapStartMin !== void 0 && segMin !== void 0 ? MINUTES_PER_DAY - current.wrapStartMin + segMin : void 0;
+        const plausibleSegWrap = current.wrapStartMin !== void 0 && segMin !== void 0 && segMin < current.wrapStartMin && segWrapDuration !== void 0 && segWrapDuration <= MAX_PLAUSIBLE_WRAP_MINUTES;
+        const segDate = plausibleSegWrap ? nextCalendarDay(date) : date;
+        const startIso = clockToIso(clock, segDate);
+        const speaker = escaped ? unescapeSpeakerLabel(label.trim()) : label.trim();
+        const segment = {
+          speaker,
+          // Self status is read from the RESERVED `(you)` marker, which the
+          // renderer guarantees can only appear on the wearer's label -
+          // never on a non-self display name (issue #1849).
+          isSelf: hasSelfMarker(speaker),
+          text,
+          ...startIso !== void 0 ? { startIso } : {}
+        };
+        current.segments.push(segment);
+      }
+    }
+    flushCurrent();
+  }
+  return inputs;
+}
+
 // src/storage.ts
 var ARTIFACT_SEARCH_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
@@ -1865,17 +2915,17 @@ var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set([
   "topic"
 ]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path4.basename(pathRel, ".md").toLowerCase();
+  const basename = path5.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path4.sep).join("/");
+  const normalizedPath = pathRel.split(path5.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path4.basename(pathRel, ".md");
+    const basename = path5.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -1942,8 +2992,8 @@ var ContentHashIndex = class _ContentHashIndex {
   secureStoreKeyProvider;
   secureStoreWriteKeyProvider;
   memoryDir;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path4.dirname(stateDir)) {
-    this.filePath = path4.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path5.dirname(stateDir)) {
+    this.filePath = path5.join(stateDir, "fact-hashes.txt");
     this.secureStoreKeyProvider = secureStoreKeyProvider;
     this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
     this.memoryDir = memoryDir;
@@ -1990,7 +3040,7 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed. */
   async save() {
     if (!this.dirty) return;
-    await mkdir(path4.dirname(this.filePath), { recursive: true });
+    await mkdir(path5.dirname(this.filePath), { recursive: true });
     await writeMaybeEncryptedFile(
       this.filePath,
       [...this.hashes].join("\n") + "\n",
@@ -2532,7 +3582,7 @@ function fingerprintEntityStructuredFacts(entity) {
     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");
+  return createHash3("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -3056,7 +4106,7 @@ var StorageManager3 = class _StorageManager {
         void 0,
         this.baseDir
       );
-      const rel = path4.relative(this.baseDir, filePath).split(path4.sep).join("/");
+      const rel = path5.relative(this.baseDir, filePath).split(path5.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -3113,13 +4163,13 @@ var StorageManager3 = class _StorageManager {
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path4.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path5.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path4.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path5.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
   }
   versionFilePath(kind) {
     const fileName = kind === "memory-status" ? ".memory-status-version.log" : kind === "artifact-write" ? ".artifact-write-version.log" : ".cold-write-version.log";
-    return path4.join(this.stateDir, fileName);
+    return path5.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -3166,7 +4216,7 @@ var StorageManager3 = class _StorageManager {
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path4.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path5.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -3184,7 +4234,7 @@ var StorageManager3 = class _StorageManager {
         `invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path4.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path5.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -3205,6 +4255,19 @@ var StorageManager3 = class _StorageManager {
       sourceId
     );
   }
+  _fusionStore;
+  /** Derived fusion-day IO; file IO lives in wearables/fusion (#1810). */
+  fusionArtifactStore() {
+    if (this._fusionStore) return this._fusionStore;
+    return this._fusionStore = new FusionArtifactStore(this.wearablesDir, 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
@@ -3271,25 +4334,25 @@ var StorageManager3 = class _StorageManager {
     });
   }
   get factsDir() {
-    return path4.join(this.baseDir, "facts");
+    return path5.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path4.join(this.baseDir, "corrections");
+    return path5.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path4.join(this.baseDir, "procedures");
+    return path5.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path4.join(this.baseDir, "reasoning-traces");
+    return path5.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path4.join(this.baseDir, "entities");
+    return path5.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path4.resolve(this.entitiesDir, `${name}.md`);
-    const relative = path4.relative(this.entitiesDir, filePath);
-    if (relative === "" || relative.startsWith("..") || path4.isAbsolute(relative)) {
+    const filePath = path5.resolve(this.entitiesDir, `${name}.md`);
+    const relative = path5.relative(this.entitiesDir, filePath);
+    if (relative === "" || relative.startsWith("..") || path5.isAbsolute(relative)) {
       return null;
     }
     return filePath;
@@ -3304,10 +4367,10 @@ var StorageManager3 = class _StorageManager {
     return writeMaybeEncryptedFileFromChunks(filePath, chunks, this.resolveWriteKey(), {}, this.baseDir).then(() => this.notifyCatalogWrite());
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path4.resolve(filePath);
-    const base = path4.resolve(this.baseDir);
-    const rel = path4.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path4.sep}`) || path4.isAbsolute(rel)) {
+    const resolved = path5.resolve(filePath);
+    const base = path5.resolve(this.baseDir);
+    const rel = path5.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path5.sep}`) || path5.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -3319,7 +4382,7 @@ var StorageManager3 = class _StorageManager {
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat2(target);
-    const relPath = path4.relative(this.baseDir, target).split(path4.sep).join("/");
+    const relPath = path5.relative(this.baseDir, target).split(path5.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) {
@@ -3333,11 +4396,11 @@ var StorageManager3 = class _StorageManager {
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash("sha256").update(content).digest("hex"),
+        sha256: createHash3("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash("sha256");
+      const hash = createHash3("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream2(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -3380,7 +4443,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("../") || path4.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("../") || path5.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 });
@@ -3422,7 +4485,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 mkdir(path4.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir(path5.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(
         this.offlineSyncDigestCachePath,
         `${JSON.stringify({ version: 1, entries })}
@@ -3475,10 +4538,10 @@ var StorageManager3 = class _StorageManager {
       if (isErrnoCode(error, "ENOENT")) return;
       throw error;
     });
-    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
+    if (filePath.includes(`${path5.sep}cold${path5.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
+    if (filePath.includes(`${path5.sep}artifacts${path5.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -3506,7 +4569,7 @@ var StorageManager3 = class _StorageManager {
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path4.dirname(filePath), { recursive: true });
+    await mkdir(path5.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (isEncryptedFile(await readFile(filePath))) {
@@ -3532,16 +4595,16 @@ var StorageManager3 = class _StorageManager {
     this.notifyCatalogWrite();
   }
   get stateDir() {
-    return path4.join(this.baseDir, "state");
+    return path5.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path4.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path5.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path4.join(this.stateDir, "entity-synthesis-queue.json");
+    return path5.join(this.stateDir, "entity-synthesis-queue.json");
   }
   get factHashIndexReadyPath() {
-    return path4.join(this.stateDir, "fact-hashes.ready");
+    return path5.join(this.stateDir, "fact-hashes.ready");
   }
   // ── Tombstone store access (issue #1579) ─────────────────────────────────
   /**
@@ -3551,7 +4614,7 @@ var StorageManager3 = class _StorageManager {
    * helpers are injected into the store).
    */
   get tombstonesPath() {
-    return path4.join(this.stateDir, "tombstones.jsonl");
+    return path5.join(this.stateDir, "tombstones.jsonl");
   }
   /**
    * Configure the tombstone invariant for this storage instance. Installed
@@ -3750,7 +4813,7 @@ var StorageManager3 = class _StorageManager {
         );
       }
       await factHashIndex.save();
-      await mkdir(path4.dirname(this.factHashIndexReadyPath), { recursive: true });
+      await mkdir(path5.dirname(this.factHashIndexReadyPath), { recursive: true });
       await writeFile(this.factHashIndexReadyPath, "v1\n", "utf-8");
       this.factHashIndexAuthoritative = true;
     })().finally(() => {
@@ -3759,55 +4822,55 @@ var StorageManager3 = class _StorageManager {
     await this.factHashIndexAuthoritativePromise;
   }
   get questionsDir() {
-    return path4.join(this.baseDir, "questions");
+    return path5.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path4.join(this.baseDir, "artifacts");
+    return path5.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path4.join(this.baseDir, "identity");
+    return path5.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path4.join(this.identityDir, "identity-anchor.md");
+    return path5.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path4.join(this.identityDir, "incidents");
+    return path5.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path4.join(this.identityDir, "audits", "weekly");
+    return path5.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path4.join(this.identityDir, "audits", "monthly");
+    return path5.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path4.join(this.identityDir, "improvement-loops.md");
+    return path5.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path4.join(this.identityDir, "reflections.md");
+    return path5.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path4.join(this.baseDir, "profile.md");
+    return path5.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path4.join(this.stateDir, "memory-actions.jsonl");
+    return path5.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path4.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path5.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path4.join(this.stateDir, "compression-guidelines.md");
+    return path5.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path4.join(this.stateDir, "compression-guidelines.draft.md");
+    return path5.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path4.join(this.stateDir, "compression-guideline-state.json");
+    return path5.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path4.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path5.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path4.join(this.stateDir, "behavior-signals.jsonl");
+    return path5.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * Buffer surprise telemetry ledger (issue #563 PR 3).
@@ -3820,7 +4883,7 @@ var StorageManager3 = class _StorageManager {
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path4.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path5.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Entity alias table loaded from THIS store's config/aliases.json.
@@ -3854,7 +4917,7 @@ var StorageManager3 = class _StorageManager {
     this.loadAliasesSync();
   }
   loadAliasesSync() {
-    const aliasPath = path4.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path5.join(this.baseDir, "config", "aliases.json");
     this.userAliases = {};
     try {
       const raw = readFileSync(aliasPath, "utf-8");
@@ -3879,9 +4942,9 @@ var StorageManager3 = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path4.join(this.factsDir, today), { recursive: true });
-    await mkdir(path4.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path4.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(path5.join(this.factsDir, today), { recursive: true });
+    await mkdir(path5.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path5.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -3891,7 +4954,7 @@ var StorageManager3 = class _StorageManager {
     await mkdir(this.identityIncidentsDir, { recursive: true });
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path4.join(this.baseDir, "config"), { recursive: true });
+    await mkdir(path5.join(this.baseDir, "config"), { recursive: true });
   }
   /**
    * Resolve the on-disk write path for a memory of the given category, creating
@@ -3908,11 +4971,11 @@ var StorageManager3 = class _StorageManager {
   async resolveCategoryWritePath(category, id, today) {
     if (category === "correction") {
       await mkdir(this.correctionsDir, { recursive: true });
-      return path4.join(this.correctionsDir, `${id}.md`);
+      return path5.join(this.correctionsDir, `${id}.md`);
     }
-    const datedDir = path4.join(getCategoryDir(this.baseDir, category), today);
+    const datedDir = path5.join(getCategoryDir(this.baseDir, category), today);
     await mkdir(datedDir, { recursive: true });
-    return path4.join(datedDir, `${id}.md`);
+    return path5.join(datedDir, `${id}.md`);
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -4162,7 +5225,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path4.join(this.artifactsDir, day);
+    const dir = path5.join(this.artifactsDir, day);
     await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -4186,7 +5249,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path4.join(dir, `${id}.md`);
+    const filePath = path5.join(dir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -4388,7 +5451,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path4.join(this.baseDir, "cold");
+    const coldRoot = path5.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
     invalidateAllForDir(this.baseDir);
@@ -4478,7 +5541,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path4.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path5.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -4543,7 +5606,7 @@ ${sanitized.text}
       try {
         const entries = await readdir4(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path4.join(dir, entry.name);
+          const fullPath = path5.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -4578,7 +5641,7 @@ ${sanitized.text}
     );
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path4.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path5.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -4593,13 +5656,13 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path4.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path5.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path4.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path5.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     const dir = categoryDirName(memory.frontmatter.category);
-    return path4.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path5.join(root, dir, this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
@@ -4612,8 +5675,8 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path4.resolve(memory.path);
-    const destPath = path4.resolve(targetPath);
+    const sourcePath = path5.resolve(memory.path);
+    const destPath = path5.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
         await unlink2(memory.path);
@@ -4629,8 +5692,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path4.resolve(memory.path);
-    const destPath = path4.resolve(targetPath);
+    const sourcePath = path5.resolve(memory.path);
+    const destPath = path5.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -4657,7 +5720,7 @@ ${memory.content}
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path4.join(this.baseDir, "archive");
+    return path5.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -4668,7 +5731,7 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path4.join(this.archiveDir, today);
+      const destDir = path5.join(this.archiveDir, today);
       await mkdir(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
@@ -4680,7 +5743,7 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path4.join(destDir, path4.basename(memory.path));
+      const destPath = path5.join(destDir, path5.basename(memory.path));
       await this.writeStorageSecureFile(destPath, fileContent);
       await unlink2(memory.path);
       markProjectedMemoryPathInvalid(this.baseDir, memory.frontmatter.id);
@@ -4830,7 +5893,7 @@ ${memory.content}
 `;
     await this.writeStorageSecureFile(memory.path, fileContent);
     this.invalidateAllMemoriesCache();
-    if (memory.path.includes(`${path4.sep}cold${path4.sep}`)) {
+    if (memory.path.includes(`${path5.sep}cold${path5.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -4903,7 +5966,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path4.join(this.stateDir, "buffer.json");
+    const bufferPath = path5.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -4915,11 +5978,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path4.join(this.stateDir, "buffer.json");
+    const bufferPath = path5.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path4.join(this.stateDir, "meta.json");
+    const metaPath = path5.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -4953,7 +6016,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path4.join(this.stateDir, "meta.json");
+    const metaPath = path5.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -5039,7 +6102,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path5.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -5052,7 +6115,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path4.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path5.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -5210,7 +6273,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash3("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -5290,7 +6353,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path4.join(this.questionsDir, `${id}.md`);
+    const filePath = path5.join(this.questionsDir, `${id}.md`);
     await this.writeStorageSecureFile(filePath, content);
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -5308,7 +6371,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path4.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path5.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(
       this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5"
@@ -5371,11 +6434,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path4.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path5.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path4.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path5.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -5469,7 +6532,7 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5494,7 +6557,7 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5517,7 +6580,7 @@ ${reflection}
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path4.join(this.entitiesDir, `${name}.md`);
+    const filePath = path5.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -5548,7 +6611,7 @@ ${reflection}
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     let synthesisTimelineCount;
     try {
-      const filePath = path4.join(this.entitiesDir, `${name}.md`);
+      const filePath = path5.join(this.entitiesDir, `${name}.md`);
       const content = await this.readStorageSecureFile(filePath);
       synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
     } catch (err) {
@@ -5631,7 +6694,7 @@ ${reflection}
       if (!raw) continue;
       const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
       if (raw.trimEnd() === serialized.trimEnd()) continue;
-      await this.writeStorageSecureFile(path4.join(this.entitiesDir, `${entityName}.md`), serialized);
+      await this.writeStorageSecureFile(path5.join(this.entitiesDir, `${entityName}.md`), serialized);
       migrated += 1;
     }
     if (migrated > 0) {
@@ -5775,7 +6838,7 @@ ${memory.content}
     const filePaths = await this.collectActiveMemoryPaths();
     const foundIds = /* @__PURE__ */ new Set();
     for (const filePath of filePaths) {
-      const basename = path4.basename(filePath, ".md");
+      const basename = path5.basename(filePath, ".md");
       if (wantedIds.has(basename)) {
         foundIds.add(basename);
         if (foundIds.size === wantedIds.size) break;
@@ -5967,14 +7030,14 @@ Reason: ${reason}`, {
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path4.join(this.baseDir, "summaries");
+    return path5.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
     await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path4.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path5.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -5987,7 +7050,7 @@ Reason: ${reason}`, {
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path4.join(this.summariesDir, file);
+        const filePath = path5.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -6048,7 +7111,7 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path4.join(this.stateDir, "topics.json");
+    const metaPath = path5.join(this.stateDir, "topics.json");
     await mkdir(this.stateDir, { recursive: true });
     await this.writeStorageSecureFile(metaPath, JSON.stringify({ topics, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
     log.debug(`saved ${topics.length} topic scores`);
@@ -6057,7 +7120,7 @@ ${memory.content}
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path4.join(this.stateDir, "topics.json");
+    const metaPath = path5.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -6136,6 +7199,19 @@ ${memory.content}
 
 export {
   selfDeps,
+  DEFAULT_PROXIMITY_GAP_MS,
+  clusterConversations,
+  DEFAULT_WINDOW_TOLERANCE_MS,
+  DEFAULT_SOURCE_TRUST,
+  fusionInputsFromConversations,
+  fuseCluster,
+  fuseDay,
+  FUSION_KIND,
+  hashFusionBody,
+  composeFusionDayMeta,
+  serializeFusionDay,
+  parseFusionDay,
+  reconstructFusionInputs,
   parseFrontmatterStringValue,
   parseFrontmatter,
   normalizeFrontmatterForPath,
@@ -6154,4 +7230,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-M7GGMGMZ.js.map
+//# sourceMappingURL=chunk-SVOHGUMI.js.map