@remnic/core 9.3.629 → 9.3.631

package/dist/{chunk-UGHUNQ74.js → chunk-QYGIQ5NM.js}

@@ -1,3 +1,7 @@
+import {
+  WEARABLES_DIR_NAME,
+  isValidTranscriptDate
+} from "./chunk-M7XQSUBB.js";
 import {
   isErrnoCode
 } from "./chunk-5UZXUTVO.js";
@@ -77,274 +81,8 @@ import {
 // src/storage.ts
 import { access, readdir, readFile, stat, writeFile, mkdir, unlink, appendFile, open } from "fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, statSync } from "fs";
-import { createHash as createHash2 } from "crypto";
-import path2 from "path";
-
-// src/wearables/day-store.ts
 import { createHash } from "crypto";
-
-// src/wearables/speakers.ts
-import { promises as fsPromises } from "fs";
-import * as path from "path";
-var DEFAULT_SELF_NAME = "Me";
-function emptySpeakerRegistry() {
-  return { version: 1, selfName: DEFAULT_SELF_NAME, speakers: {} };
-}
-function speakersFilePath(memoryDir) {
-  return path.join(memoryDir, "state", "wearables", "speakers.json");
-}
-async function loadSpeakerRegistry(memoryDir) {
-  const filePath = speakersFilePath(memoryDir);
-  let raw;
-  try {
-    raw = await fsPromises.readFile(filePath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return emptySpeakerRegistry();
-    }
-    throw err;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    throw new Error(
-      `wearables speakers file is not valid JSON (state/wearables/speakers.json): ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.speakers !== "object" || parsed.speakers === null) {
-    throw new Error(
-      'wearables speakers file has an unexpected shape (state/wearables/speakers.json); expected {"version":1,"selfName":"...","speakers":{}}'
-    );
-  }
-  const registry = parsed;
-  return {
-    version: 1,
-    selfName: typeof registry.selfName === "string" && registry.selfName.trim().length > 0 ? registry.selfName.trim() : DEFAULT_SELF_NAME,
-    speakers: registry.speakers
-  };
-}
-async function saveSpeakerRegistry(memoryDir, registry) {
-  const filePath = speakersFilePath(memoryDir);
-  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
-  await fsPromises.writeFile(
-    tmpPath,
-    `${JSON.stringify(registry, null, 2)}
-`,
-    "utf-8"
-  );
-  try {
-    await fsPromises.rename(tmpPath, filePath);
-  } catch (err) {
-    await fsPromises.unlink(tmpPath).catch(() => void 0);
-    throw err;
-  }
-}
-function speakerRegistryKey(sourceId, speakerKey) {
-  return `${sourceId}:${speakerKey}`;
-}
-function resolveSpeaker(sourceId, segment, registry) {
-  const override = registry.speakers[speakerRegistryKey(sourceId, segment.speakerKey)];
-  if (override) {
-    const isSelf = override.isSelf === true;
-    return {
-      label: isSelf ? `${override.name} (you)` : override.name,
-      isSelf
-    };
-  }
-  if (segment.isWearer === true) {
-    return { label: `${registry.selfName} (you)`, isSelf: true };
-  }
-  if (typeof segment.speakerName === "string" && segment.speakerName.trim().length > 0) {
-    return { label: segment.speakerName.trim(), isSelf: false };
-  }
-  const key = segment.speakerKey.trim();
-  if (/^\d+$/.test(key)) {
-    return { label: `Speaker ${key}`, isSelf: false };
-  }
-  return { label: key.length > 0 ? key : "Unknown speaker", isSelf: false };
-}
-function distinctSpeakerLabels(sourceId, segments, registry) {
-  const labels = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const segment of segments) {
-    const { label } = resolveSpeaker(sourceId, segment, registry);
-    if (!seen.has(label)) {
-      seen.add(label);
-      labels.push(label);
-    }
-  }
-  return labels;
-}
-
-// src/wearables/day-store.ts
-var WEARABLES_DIR_NAME = "wearables";
-var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-function isValidTranscriptDate(date) {
-  if (!DATE_PATTERN.test(date)) return false;
-  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
-  return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === date;
-}
-function hashTranscriptBody(body) {
-  return createHash("sha256").update(body, "utf-8").digest("hex");
-}
-function formatClockTime(iso, timezone) {
-  if (!iso) return "--:--";
-  const ms = Date.parse(iso);
-  if (Number.isNaN(ms)) return "--:--";
-  try {
-    return new Intl.DateTimeFormat("en-US", {
-      timeZone: timezone,
-      hour12: false,
-      hour: "2-digit",
-      minute: "2-digit"
-    }).format(new Date(ms));
-  } catch {
-    return new Date(ms).toISOString().slice(11, 16);
-  }
-}
-function conversationDurationMinutes(conversation) {
-  const start = Date.parse(conversation.startIso);
-  const end = conversation.endIso ? Date.parse(conversation.endIso) : NaN;
-  if (Number.isNaN(start) || Number.isNaN(end) || end <= start) return 0;
-  return (end - start) / 6e4;
-}
-function composeDayTranscriptBody(sourceId, date, timezone, conversations, registry) {
-  const lines = [];
-  lines.push(`# ${sourceId} transcript \u2014 ${date}`);
-  lines.push("");
-  const ordered = [...conversations].sort((a, b) => {
-    const aMs = Date.parse(a.startIso);
-    const bMs = Date.parse(b.startIso);
-    if (aMs < bMs) return -1;
-    if (aMs > bMs) return 1;
-    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-  });
-  for (const conversation of ordered) {
-    const start = formatClockTime(conversation.startIso, timezone);
-    const end = formatClockTime(conversation.endIso, timezone);
-    const title = conversation.title?.trim();
-    const heading = title && title.length > 0 ? ` \xB7 ${title}` : "";
-    lines.push(`## ${start}\u2013${end}${heading} (conversation ${conversation.id})`);
-    if (conversation.location) {
-      lines.push(`*Location: ${conversation.location}*`);
-    }
-    lines.push("");
-    for (const segment of conversation.segments) {
-      const { label } = resolveSpeaker(sourceId, segment, registry);
-      const at = formatClockTime(segment.startIso, timezone);
-      lines.push(`**${label}** [${at}]: ${segment.text}`);
-    }
-    lines.push("");
-  }
-  return `${lines.join("\n").trimEnd()}
-`;
-}
-function composeDayTranscriptMeta(sourceId, date, timezone, conversations, registry, body, syncedAt) {
-  const allSegments = conversations.flatMap((c) => c.segments);
-  const durationMinutes = Math.round(
-    conversations.reduce((sum, c) => sum + conversationDurationMinutes(c), 0)
-  );
-  return {
-    kind: "wearable-transcript",
-    source: sourceId,
-    date,
-    timezone,
-    conversationCount: conversations.length,
-    segmentCount: allSegments.length,
-    speakers: distinctSpeakerLabels(sourceId, allSegments, registry),
-    durationMinutes,
-    contentHash: hashTranscriptBody(body),
-    syncedAt
-  };
-}
-function serializeDayTranscript(meta, body) {
-  const lines = ["---"];
-  lines.push(`kind: ${meta.kind}`);
-  lines.push(`source: ${JSON.stringify(meta.source)}`);
-  lines.push(`date: ${JSON.stringify(meta.date)}`);
-  lines.push(`timezone: ${JSON.stringify(meta.timezone)}`);
-  lines.push(`conversationCount: ${meta.conversationCount}`);
-  lines.push(`segmentCount: ${meta.segmentCount}`);
-  if (meta.speakers.length === 0) {
-    lines.push("speakers: []");
-  } else {
-    lines.push("speakers:");
-    for (const speaker of meta.speakers) {
-      lines.push(`  - ${JSON.stringify(speaker)}`);
-    }
-  }
-  lines.push(`durationMinutes: ${meta.durationMinutes}`);
-  lines.push(`contentHash: ${JSON.stringify(meta.contentHash)}`);
-  lines.push(`syncedAt: ${JSON.stringify(meta.syncedAt)}`);
-  lines.push("---");
-  lines.push("");
-  return `${lines.join("\n")}${body}`;
-}
-function parseDayTranscript(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();
-  const speakers = [];
-  let inSpeakers = false;
-  for (const line of header.split("\n")) {
-    if (inSpeakers) {
-      const item = line.match(/^ {2}- (.*)$/);
-      if (item) {
-        speakers.push(parseYamlScalar(item[1]));
-        continue;
-      }
-      inSpeakers = false;
-    }
-    if (line === "speakers:") {
-      inSpeakers = true;
-      continue;
-    }
-    if (line === "speakers: []") continue;
-    const match = line.match(/^([A-Za-z][A-Za-z0-9]*): (.*)$/);
-    if (match) scalars.set(match[1], parseYamlScalar(match[2]));
-  }
-  if (scalars.get("kind") !== "wearable-transcript") return null;
-  const source = scalars.get("source");
-  const date = scalars.get("date");
-  if (!source || !date) return null;
-  const meta = {
-    kind: "wearable-transcript",
-    source,
-    date,
-    timezone: scalars.get("timezone") ?? "UTC",
-    conversationCount: parseNonNegativeInt(scalars.get("conversationCount")),
-    segmentCount: parseNonNegativeInt(scalars.get("segmentCount")),
-    speakers,
-    durationMinutes: parseNonNegativeInt(scalars.get("durationMinutes")),
-    contentHash: scalars.get("contentHash") ?? "",
-    syncedAt: scalars.get("syncedAt") ?? ""
-  };
-  return { meta, body };
-}
-function parseYamlScalar(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);
-}
-
-// src/storage.ts
+import path from "path";
 var ARTIFACT_SEARCH_STOPWORDS = /* @__PURE__ */ new Set([
   "a",
   "an",
@@ -928,17 +666,17 @@ var KNOWN_ENTITY_FILENAME_PREFIXES = /* @__PURE__ */ new Set([
   "topic"
 ]);
 function inferEntityTypeFromFilename(pathRel) {
-  const basename = path2.basename(pathRel, ".md").toLowerCase();
+  const basename = path.basename(pathRel, ".md").toLowerCase();
   const separator = basename.indexOf("-");
   if (separator <= 0) return void 0;
   const candidate = basename.slice(0, separator);
   return KNOWN_ENTITY_FILENAME_PREFIXES.has(candidate) ? candidate : void 0;
 }
 function normalizeFrontmatterForPath(frontmatter, pathRel, content = "") {
-  const normalizedPath = pathRel.split(path2.sep).join("/");
+  const normalizedPath = pathRel.split(path.sep).join("/");
   let normalizedFrontmatter = frontmatter;
   if (normalizedPath === "entities" || normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/")) {
-    const basename = path2.basename(pathRel, ".md");
+    const basename = path.basename(pathRel, ".md");
     const inferredType = inferEntityTypeFromContent(content) || inferEntityTypeFromFilename(pathRel) || "entity";
     const existingTags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
     normalizedFrontmatter = {
@@ -1005,8 +743,8 @@ var ContentHashIndex = class _ContentHashIndex {
   secureStoreKeyProvider;
   secureStoreWriteKeyProvider;
   memoryDir;
-  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path2.dirname(stateDir)) {
-    this.filePath = path2.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path.dirname(stateDir)) {
+    this.filePath = path.join(stateDir, "fact-hashes.txt");
     this.secureStoreKeyProvider = secureStoreKeyProvider;
     this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
     this.memoryDir = memoryDir;
@@ -1053,7 +791,7 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Persist index to disk if changed. */
   async save() {
     if (!this.dirty) return;
-    await mkdir(path2.dirname(this.filePath), { recursive: true });
+    await mkdir(path.dirname(this.filePath), { recursive: true });
     await writeMaybeEncryptedFile(
       this.filePath,
       [...this.hashes].join("\n") + "\n",
@@ -1105,9 +843,19 @@ var ContentHashIndex = class _ContentHashIndex {
   /** Normalize content and compute SHA-256 hash. */
   static computeHash(content) {
     const normalized = _ContentHashIndex.normalizeContent(content);
-    return createHash2("sha256").update(normalized).digest("hex");
+    return createHash("sha256").update(normalized).digest("hex");
   }
 };
+function stripAttributesSuffix(content) {
+  const trimmed = content.trimEnd();
+  if (!trimmed.endsWith("]")) return content.trim();
+  const marker = "\n[Attributes: ";
+  const markerIndex = trimmed.lastIndexOf(marker);
+  if (markerIndex === -1) return content.trim();
+  const inner = trimmed.slice(markerIndex + marker.length, -1);
+  if (inner.includes("]") || inner.includes("\n")) return content.trim();
+  return trimmed.slice(0, markerIndex).trim();
+}
 function normalizeAttributePairs(pairs) {
   return Object.entries(pairs).map(([k, v]) => [k.trim().toLowerCase(), v.trim()]).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join("; ");
 }
@@ -1596,7 +1344,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 createHash2("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
+  return createHash("sha256").update(JSON.stringify(normalizedSections)).digest("hex");
 }
 function isEntitySynthesisStale(entity) {
   const structuredFactCount = countEntityStructuredFacts(entity);
@@ -2110,7 +1858,7 @@ var StorageManager = class _StorageManager {
         void 0,
         this.baseDir
       );
-      const rel = path2.relative(this.baseDir, filePath).split(path2.sep).join("/");
+      const rel = path.relative(this.baseDir, filePath).split(path.sep).join("/");
       return `${rel}:${version.versionId}`;
     } catch (err) {
       log.warn(
@@ -2125,13 +1873,13 @@ var StorageManager = class _StorageManager {
   }
   identityFilePath(workspaceDir, namespace) {
     const rawNamespace = typeof namespace === "string" ? namespace.trim() : "";
-    if (!rawNamespace) return path2.join(workspaceDir, "IDENTITY.md");
+    if (!rawNamespace) return path.join(workspaceDir, "IDENTITY.md");
     const safeNamespace = rawNamespace.replace(/[^a-zA-Z0-9._-]/g, "-");
-    return path2.join(workspaceDir, `IDENTITY.${safeNamespace}.md`);
+    return path.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 path2.join(this.stateDir, fileName);
+    return path.join(this.stateDir, fileName);
   }
   bumpSharedVersion(kind, fallbackMap) {
     const filePath = this.versionFilePath(kind);
@@ -2177,7 +1925,7 @@ var StorageManager = class _StorageManager {
   // memories.
   // -------------------------------------------------------------------------
   get wearablesDir() {
-    return path2.join(this.baseDir, WEARABLES_DIR_NAME);
+    return path.join(this.baseDir, WEARABLES_DIR_NAME);
   }
   /**
    * Resolve the on-disk path for a source/day transcript. Throws on
@@ -2195,7 +1943,7 @@ var StorageManager = class _StorageManager {
         `invalid wearable transcript date '${String(date)}' \u2014 expected YYYY-MM-DD`
       );
     }
-    return path2.join(this.wearablesDir, sourceId, `${date}.md`);
+    return path.join(this.wearablesDir, sourceId, `${date}.md`);
   }
   async writeWearableDayTranscript(sourceId, date, serialized) {
     const targetPath = this.wearableTranscriptPath(sourceId, date);
@@ -2233,7 +1981,7 @@ var StorageManager = class _StorageManager {
       if (!/^[a-z][a-z0-9-]{0,63}$/.test(source)) continue;
       let entries;
       try {
-        entries = await readdir(path2.join(this.wearablesDir, source));
+        entries = await readdir(path.join(this.wearablesDir, source));
       } catch (err) {
         if (err.code === "ENOENT") continue;
         throw err;
@@ -2254,26 +2002,87 @@ var StorageManager = class _StorageManager {
     });
     return days;
   }
+  /**
+   * Locate a wearable-sourced memory by exact (trimmed) content,
+   * ignoring the "[Attributes: ...]" suffix writeMemory appends for
+   * structuredAttributes — callers pass the raw fact text. Used by the
+   * smart trust pipeline to find an earlier borderline write when the
+   * same fact re-extracts with stronger evidence.
+   */
+  async findWearableMemoryByContent(content) {
+    const needle = stripAttributesSuffix(content);
+    const memories = await this.readAllMemories();
+    for (const memory of memories) {
+      if (typeof memory.frontmatter.source === "string" && memory.frontmatter.source.startsWith("wearable:") && stripAttributesSuffix(memory.content) === needle) {
+        return { id: memory.frontmatter.id, status: memory.frontmatter.status };
+      }
+    }
+    return null;
+  }
+  /**
+   * Promote a pending_review wearable memory to active in place,
+   * merging updated trust evidence into structuredAttributes. Returns
+   * false when the memory is missing or no longer pending_review (a
+   * concurrent review decision wins).
+   */
+  async promoteWearableMemory(id, attributeUpdates, confidence) {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "active",
+      // Keep frontmatter confidence in step with the re-scored trust —
+      // new smart writes persist trust as confidence, and a promoted
+      // row must not keep its stale borderline value.
+      ...typeof confidence === "number" && Number.isFinite(confidence) ? { confidence: Math.min(1, Math.max(0, confidence)) } : {},
+      structuredAttributes: {
+        ...memory.frontmatter.structuredAttributes ?? {},
+        ...attributeUpdates
+      }
+    });
+  }
+  /**
+   * Demote a pending_review wearable memory to rejected when a re-pass
+   * produced an explicit judge-reject verdict, merging the evidence.
+   * Returns false when the memory is missing or no longer
+   * pending_review — active rows are NEVER auto-demoted (operator
+   * approvals and accrued recall signals win; contradiction scans and
+   * supersession own active-row retirement).
+   */
+  async demoteWearableMemory(id, attributeUpdates) {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "rejected",
+      structuredAttributes: {
+        ...memory.frontmatter.structuredAttributes ?? {},
+        ...attributeUpdates
+      }
+    });
+  }
   get factsDir() {
-    return path2.join(this.baseDir, "facts");
+    return path.join(this.baseDir, "facts");
   }
   get correctionsDir() {
-    return path2.join(this.baseDir, "corrections");
+    return path.join(this.baseDir, "corrections");
   }
   get proceduresDir() {
-    return path2.join(this.baseDir, "procedures");
+    return path.join(this.baseDir, "procedures");
   }
   get reasoningTracesDir() {
-    return path2.join(this.baseDir, "reasoning-traces");
+    return path.join(this.baseDir, "reasoning-traces");
   }
   get entitiesDir() {
-    return path2.join(this.baseDir, "entities");
+    return path.join(this.baseDir, "entities");
   }
   resolveEntityFilePath(name) {
     if (typeof name !== "string") return null;
-    const filePath = path2.resolve(this.entitiesDir, `${name}.md`);
-    const relative = path2.relative(this.entitiesDir, filePath);
-    if (relative === "" || relative.startsWith("..") || path2.isAbsolute(relative)) {
+    const filePath = path.resolve(this.entitiesDir, `${name}.md`);
+    const relative = path.relative(this.entitiesDir, filePath);
+    if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
       return null;
     }
     return filePath;
@@ -2285,10 +2094,10 @@ var StorageManager = class _StorageManager {
     return writeMaybeEncryptedFile(filePath, content, this.resolveWriteKey(), {}, this.baseDir);
   }
   assertManagedStoragePath(filePath, method) {
-    const resolved = path2.resolve(filePath);
-    const base = path2.resolve(this.baseDir);
-    const rel = path2.relative(base, resolved);
-    if (rel === "" || rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel)) {
+    const resolved = path.resolve(filePath);
+    const base = path.resolve(this.baseDir);
+    const rel = path.relative(base, resolved);
+    if (rel === "" || rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
       throw new Error(`${method}: file path escapes memory dir`);
     }
     return resolved;
@@ -2300,7 +2109,7 @@ var StorageManager = class _StorageManager {
   async digestOfflineSyncFile(filePath) {
     const target = this.assertManagedStoragePath(filePath, "storage.digestOfflineSyncFile");
     const st = await stat(target);
-    const relPath = path2.relative(this.baseDir, target).split(path2.sep).join("/");
+    const relPath = path.relative(this.baseDir, target).split(path.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) {
@@ -2314,11 +2123,11 @@ var StorageManager = class _StorageManager {
     if (encrypted) {
       const content = await readMaybeEncryptedFileBuffer(target, this._secureStoreKey, this.baseDir);
       digest = {
-        sha256: createHash2("sha256").update(content).digest("hex"),
+        sha256: createHash("sha256").update(content).digest("hex"),
         bytes: content.byteLength
       };
     } else {
-      const hash = createHash2("sha256");
+      const hash = createHash("sha256");
       let bytes = 0;
       for await (const rawChunk of createReadStream(target)) {
         const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
@@ -2361,7 +2170,7 @@ var StorageManager = 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("../") || path2.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("../") || path.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 });
@@ -2403,7 +2212,7 @@ var StorageManager = 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(path2.dirname(this.offlineSyncDigestCachePath), { recursive: true });
+      await mkdir(path.dirname(this.offlineSyncDigestCachePath), { recursive: true });
       await writeFile(
         this.offlineSyncDigestCachePath,
         `${JSON.stringify({ version: 1, entries })}
@@ -2457,10 +2266,10 @@ var StorageManager = class _StorageManager {
       if (isErrnoCode(error, "ENOENT")) return;
       throw error;
     });
-    if (filePath.includes(`${path2.sep}cold${path2.sep}`)) {
+    if (filePath.includes(`${path.sep}cold${path.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
-    if (filePath.includes(`${path2.sep}artifacts${path2.sep}`)) {
+    if (filePath.includes(`${path.sep}artifacts${path.sep}`)) {
       this.bumpArtifactWriteVersion();
     }
     this.bumpMemoryStatusVersion();
@@ -2488,7 +2297,7 @@ var StorageManager = class _StorageManager {
   }
   async appendStorageSecureFileUnlocked(filePath, content) {
     const writeKey = this.resolveWriteKey();
-    await mkdir(path2.dirname(filePath), { recursive: true });
+    await mkdir(path.dirname(filePath), { recursive: true });
     if (writeKey === null) {
       try {
         if (isEncryptedFile(await readFile(filePath))) {
@@ -2511,16 +2320,16 @@ var StorageManager = class _StorageManager {
     await writeMaybeEncryptedFile(filePath, `${existing}${content}`, writeKey, {}, this.baseDir);
   }
   get stateDir() {
-    return path2.join(this.baseDir, "state");
+    return path.join(this.baseDir, "state");
   }
   get offlineSyncDigestCachePath() {
-    return path2.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
+    return path.join(this.baseDir, ".offline-sync", "digest-cache.v1.json");
   }
   get entitySynthesisQueuePath() {
-    return path2.join(this.stateDir, "entity-synthesis-queue.json");
+    return path.join(this.stateDir, "entity-synthesis-queue.json");
   }
   get factHashIndexReadyPath() {
-    return path2.join(this.stateDir, "fact-hashes.ready");
+    return path.join(this.stateDir, "fact-hashes.ready");
   }
   async getFactHashIndex() {
     if (this.factHashIndex) {
@@ -2587,7 +2396,7 @@ var StorageManager = class _StorageManager {
         );
       }
       await factHashIndex.save();
-      await mkdir(path2.dirname(this.factHashIndexReadyPath), { recursive: true });
+      await mkdir(path.dirname(this.factHashIndexReadyPath), { recursive: true });
       await writeFile(this.factHashIndexReadyPath, "v1\n", "utf-8");
       this.factHashIndexAuthoritative = true;
     })().finally(() => {
@@ -2596,55 +2405,55 @@ var StorageManager = class _StorageManager {
     await this.factHashIndexAuthoritativePromise;
   }
   get questionsDir() {
-    return path2.join(this.baseDir, "questions");
+    return path.join(this.baseDir, "questions");
   }
   get artifactsDir() {
-    return path2.join(this.baseDir, "artifacts");
+    return path.join(this.baseDir, "artifacts");
   }
   get identityDir() {
-    return path2.join(this.baseDir, "identity");
+    return path.join(this.baseDir, "identity");
   }
   get identityAnchorPath() {
-    return path2.join(this.identityDir, "identity-anchor.md");
+    return path.join(this.identityDir, "identity-anchor.md");
   }
   get identityIncidentsDir() {
-    return path2.join(this.identityDir, "incidents");
+    return path.join(this.identityDir, "incidents");
   }
   get identityAuditsWeeklyDir() {
-    return path2.join(this.identityDir, "audits", "weekly");
+    return path.join(this.identityDir, "audits", "weekly");
   }
   get identityAuditsMonthlyDir() {
-    return path2.join(this.identityDir, "audits", "monthly");
+    return path.join(this.identityDir, "audits", "monthly");
   }
   get identityImprovementLoopsPath() {
-    return path2.join(this.identityDir, "improvement-loops.md");
+    return path.join(this.identityDir, "improvement-loops.md");
   }
   get identityReflectionsPath() {
-    return path2.join(this.identityDir, "reflections.md");
+    return path.join(this.identityDir, "reflections.md");
   }
   get profilePath() {
-    return path2.join(this.baseDir, "profile.md");
+    return path.join(this.baseDir, "profile.md");
   }
   get memoryActionsPath() {
-    return path2.join(this.stateDir, "memory-actions.jsonl");
+    return path.join(this.stateDir, "memory-actions.jsonl");
   }
   get memoryLifecycleLedgerPath() {
-    return path2.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
+    return path.join(this.stateDir, "memory-lifecycle-ledger.jsonl");
   }
   get compressionGuidelinesPath() {
-    return path2.join(this.stateDir, "compression-guidelines.md");
+    return path.join(this.stateDir, "compression-guidelines.md");
   }
   get compressionGuidelineDraftPath() {
-    return path2.join(this.stateDir, "compression-guidelines.draft.md");
+    return path.join(this.stateDir, "compression-guidelines.draft.md");
   }
   get compressionGuidelineStatePath() {
-    return path2.join(this.stateDir, "compression-guideline-state.json");
+    return path.join(this.stateDir, "compression-guideline-state.json");
   }
   get compressionGuidelineDraftStatePath() {
-    return path2.join(this.stateDir, "compression-guideline-draft-state.json");
+    return path.join(this.stateDir, "compression-guideline-draft-state.json");
   }
   get behaviorSignalsPath() {
-    return path2.join(this.stateDir, "behavior-signals.jsonl");
+    return path.join(this.stateDir, "behavior-signals.jsonl");
   }
   /**
    * Buffer surprise telemetry ledger (issue #563 PR 3).
@@ -2657,7 +2466,7 @@ var StorageManager = class _StorageManager {
    * governance sweeps can treat it uniformly.
    */
   get bufferSurpriseLedgerPath() {
-    return path2.join(this.stateDir, "buffer-surprise-ledger.jsonl");
+    return path.join(this.stateDir, "buffer-surprise-ledger.jsonl");
   }
   /**
    * Load user-defined entity aliases from config/aliases.json in the memory store.
@@ -2665,7 +2474,7 @@ var StorageManager = class _StorageManager {
    * Call this once at startup (e.g. from orchestrator.initialize()).
    */
   async loadAliases() {
-    const aliasPath = path2.join(this.baseDir, "config", "aliases.json");
+    const aliasPath = path.join(this.baseDir, "config", "aliases.json");
     try {
       const raw = await readFile(aliasPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -2679,9 +2488,9 @@ var StorageManager = class _StorageManager {
   }
   async ensureDirectories() {
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    await mkdir(path2.join(this.factsDir, today), { recursive: true });
-    await mkdir(path2.join(this.proceduresDir, today), { recursive: true });
-    await mkdir(path2.join(this.reasoningTracesDir, today), { recursive: true });
+    await mkdir(path.join(this.factsDir, today), { recursive: true });
+    await mkdir(path.join(this.proceduresDir, today), { recursive: true });
+    await mkdir(path.join(this.reasoningTracesDir, today), { recursive: true });
     await mkdir(this.correctionsDir, { recursive: true });
     await mkdir(this.entitiesDir, { recursive: true });
     await mkdir(this.stateDir, { recursive: true });
@@ -2691,7 +2500,7 @@ var StorageManager = class _StorageManager {
     await mkdir(this.identityIncidentsDir, { recursive: true });
     await mkdir(this.identityAuditsWeeklyDir, { recursive: true });
     await mkdir(this.identityAuditsMonthlyDir, { recursive: true });
-    await mkdir(path2.join(this.baseDir, "config"), { recursive: true });
+    await mkdir(path.join(this.baseDir, "config"), { recursive: true });
   }
   async writeMemory(category, content, options = {}) {
     await this.ensureDirectories();
@@ -2761,15 +2570,15 @@ ${sanitized.text}
 `;
     let filePath;
     if (category === "correction") {
-      filePath = path2.join(this.correctionsDir, `${id}.md`);
+      filePath = path.join(this.correctionsDir, `${id}.md`);
     } else if (category === "procedure") {
-      await mkdir(path2.join(this.proceduresDir, today), { recursive: true });
-      filePath = path2.join(this.proceduresDir, today, `${id}.md`);
+      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
+      filePath = path.join(this.proceduresDir, today, `${id}.md`);
     } else if (category === "reasoning_trace") {
-      await mkdir(path2.join(this.reasoningTracesDir, today), { recursive: true });
-      filePath = path2.join(this.reasoningTracesDir, today, `${id}.md`);
+      await mkdir(path.join(this.reasoningTracesDir, today), { recursive: true });
+      filePath = path.join(this.reasoningTracesDir, today, `${id}.md`);
     } else {
-      filePath = path2.join(this.factsDir, today, `${id}.md`);
+      filePath = path.join(this.factsDir, today, `${id}.md`);
     }
     await this.snapshotBeforeWrite(filePath, "write");
     await writeMaybeEncryptedFile(filePath, fileContent, this.resolveWriteKey(), {}, this.baseDir);
@@ -2884,7 +2693,7 @@ ${sanitized.text}
     await this.ensureDirectories();
     const now = /* @__PURE__ */ new Date();
     const day = now.toISOString().slice(0, 10);
-    const dir = path2.join(this.artifactsDir, day);
+    const dir = path.join(this.artifactsDir, day);
     await mkdir(dir, { recursive: true });
     const id = `artifact-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
     const fm = {
@@ -2908,7 +2717,7 @@ ${sanitized.text}
       log.warn(`artifact content rejected for ${id}; violations=${sanitized.violations.join(", ")}`);
       return "";
     }
-    const filePath = path2.join(dir, `${id}.md`);
+    const filePath = path.join(dir, `${id}.md`);
     await writeMaybeEncryptedFile(filePath, `${serializeFrontmatter(fm)}
 
 ${sanitized.text}
@@ -2936,7 +2745,7 @@ ${sanitized.text}
         try {
           const entries = await readdir(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = path2.join(dir, entry.name);
+            const fullPath = path.join(dir, entry.name);
             if (entry.isDirectory()) {
               await readDir(fullPath);
               continue;
@@ -3002,7 +2811,7 @@ ${sanitized.text}
       log.debug(`fuzzy match: "${normalized}" \u2192 existing "${match}"`);
       normalized = match;
     }
-    const filePath = path2.join(this.entitiesDir, `${normalized}.md`);
+    const filePath = path.join(this.entitiesDir, `${normalized}.md`);
     let entity = {
       name,
       type,
@@ -3237,7 +3046,7 @@ ${sanitized.text}
    * per-process in-memory cache safe across process boundaries.
    */
   invalidateColdMemoriesCache() {
-    const coldRoot = path2.join(this.baseDir, "cold");
+    const coldRoot = path.join(this.baseDir, "cold");
     _StorageManager.coldMemoriesCache.delete(coldRoot);
     this.bumpColdWriteVersion();
   }
@@ -3265,7 +3074,7 @@ ${sanitized.text}
         const entries = await readdir(dir, { withFileTypes: true });
         const subdirs = [];
         for (const entry of entries) {
-          const fullPath = path2.join(dir, entry.name);
+          const fullPath = path.join(dir, entry.name);
           if (entry.isDirectory()) {
             subdirs.push(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -3349,7 +3158,7 @@ ${sanitized.text}
     const correctionPaths = [];
     const factPaths = [];
     for (const filePath of filePaths) {
-      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path2.sep}`)) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path.sep}`)) {
         correctionPaths.push(filePath);
       } else {
         factPaths.push(filePath);
@@ -3469,7 +3278,7 @@ ${sanitized.text}
         const entries = await readdir(dir, { withFileTypes: true });
         const subdirs = [];
         for (const entry of entries) {
-          const fullPath = path2.join(dir, entry.name);
+          const fullPath = path.join(dir, entry.name);
           if (entry.isDirectory()) {
             subdirs.push(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -3498,7 +3307,7 @@ ${sanitized.text}
       try {
         const entries = await readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path2.join(dir, entry.name);
+          const fullPath = path.join(dir, entry.name);
           if (entry.isDirectory()) {
             await readDir(fullPath);
           } else if (entry.name.endsWith(".md")) {
@@ -3543,11 +3352,11 @@ ${sanitized.text}
           content: parsed.content
         };
       }
-      const normalizedPath = filePath.split(path2.sep).join("/");
+      const normalizedPath = filePath.split(path.sep).join("/");
       if (normalizedPath.includes("/entities/") && filePath.endsWith(".md")) {
         const entity = parseEntityFile(raw, this.entitySchemas);
         if (!entity.name) return null;
-        const nameWithoutExt = path2.basename(filePath, ".md");
+        const nameWithoutExt = path.basename(filePath, ".md");
         const fileMtime = entity.updated || await stat(filePath).then((s) => s.mtime.toISOString()).catch(() => (/* @__PURE__ */ new Date(0)).toISOString());
         return {
           path: filePath,
@@ -3571,7 +3380,7 @@ ${sanitized.text}
     }
   }
   resolveTierRootDir(tier) {
-    return tier === "cold" ? path2.join(this.baseDir, "cold") : this.baseDir;
+    return tier === "cold" ? path.join(this.baseDir, "cold") : this.baseDir;
   }
   resolveMemoryDateDir(memory) {
     const preferred = memory.frontmatter.created || memory.frontmatter.updated;
@@ -3586,18 +3395,18 @@ ${sanitized.text}
   buildTierMemoryPath(memory, tier) {
     const root = this.resolveTierRootDir(tier);
     if (this.isArtifactMemory(memory)) {
-      return path2.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "correction") {
-      return path2.join(root, "corrections", `${memory.frontmatter.id}.md`);
+      return path.join(root, "corrections", `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "procedure") {
-      return path2.join(root, "procedures", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path.join(root, "procedures", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
     if (memory.frontmatter.category === "reasoning_trace") {
-      return path2.join(root, "reasoning-traces", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+      return path.join(root, "reasoning-traces", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
     }
-    return path2.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    return path.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
   }
   async writeMemoryFileAtomic(targetPath, memory) {
     const fileContent = `${serializeFrontmatter(memory.frontmatter)}
@@ -3609,8 +3418,8 @@ ${memory.content}
   }
   async moveMemoryToPath(memory, targetPath) {
     await this.writeMemoryFileAtomic(targetPath, memory);
-    const sourcePath = path2.resolve(memory.path);
-    const destPath = path2.resolve(targetPath);
+    const sourcePath = path.resolve(memory.path);
+    const destPath = path.resolve(targetPath);
     if (sourcePath !== destPath) {
       try {
         await unlink(memory.path);
@@ -3625,8 +3434,8 @@ ${memory.content}
   }
   async migrateMemoryToTier(memory, targetTier) {
     const targetPath = this.buildTierMemoryPath(memory, targetTier);
-    const sourcePath = path2.resolve(memory.path);
-    const destPath = path2.resolve(targetPath);
+    const sourcePath = path.resolve(memory.path);
+    const destPath = path.resolve(targetPath);
     if (sourcePath === destPath) {
       return { changed: false, targetPath };
     }
@@ -3652,7 +3461,7 @@ ${memory.content}
     return { changed: true, targetPath };
   }
   get archiveDir() {
-    return path2.join(this.baseDir, "archive");
+    return path.join(this.baseDir, "archive");
   }
   /**
    * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
@@ -3663,7 +3472,7 @@ ${memory.content}
     try {
       const now = lifecycle?.at ?? /* @__PURE__ */ new Date();
       const today = now.toISOString().slice(0, 10);
-      const destDir = path2.join(this.archiveDir, today);
+      const destDir = path.join(this.archiveDir, today);
       await mkdir(destDir, { recursive: true });
       const updatedFm = {
         ...memory.frontmatter,
@@ -3675,7 +3484,7 @@ ${memory.content}
 
 ${memory.content}
 `;
-      const destPath = path2.join(destDir, path2.basename(memory.path));
+      const destPath = path.join(destDir, path.basename(memory.path));
       await writeMaybeEncryptedFile(destPath, fileContent, this.resolveWriteKey(), {}, this.baseDir);
       await unlink(memory.path);
       this.invalidateAllMemoriesCache();
@@ -3837,7 +3646,7 @@ ${memory.content}
 `;
     await writeMaybeEncryptedFile(memory.path, fileContent, this.resolveWriteKey(), {}, this.baseDir);
     this.invalidateAllMemoriesCache();
-    if (memory.path.includes(`${path2.sep}cold${path2.sep}`)) {
+    if (memory.path.includes(`${path.sep}cold${path.sep}`)) {
       this.invalidateColdMemoriesCache();
     }
     try {
@@ -3909,7 +3718,7 @@ ${memory.content}
     return deleted;
   }
   async loadBuffer() {
-    const bufferPath = path2.join(this.stateDir, "buffer.json");
+    const bufferPath = path.join(this.stateDir, "buffer.json");
     try {
       const raw = await this.readStorageSecureFile(bufferPath);
       return JSON.parse(raw);
@@ -3921,11 +3730,11 @@ ${memory.content}
   }
   async saveBuffer(state) {
     await this.ensureDirectories();
-    const bufferPath = path2.join(this.stateDir, "buffer.json");
+    const bufferPath = path.join(this.stateDir, "buffer.json");
     await this.writeStorageSecureFile(bufferPath, JSON.stringify(state, null, 2));
   }
   async loadMeta() {
-    const metaPath = path2.join(this.stateDir, "meta.json");
+    const metaPath = path.join(this.stateDir, "meta.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       const parsed = JSON.parse(raw);
@@ -3959,7 +3768,7 @@ ${memory.content}
   }
   async saveMeta(state) {
     await this.ensureDirectories();
-    const metaPath = path2.join(this.stateDir, "meta.json");
+    const metaPath = path.join(this.stateDir, "meta.json");
     await this.writeStorageSecureFile(metaPath, JSON.stringify(state, null, 2));
   }
   async appendMemoryActionEvents(events) {
@@ -4129,7 +3938,7 @@ ${memory.content}
   async appendReextractJobs(events) {
     if (events.length === 0) return 0;
     await this.ensureDirectories();
-    const filePath = path2.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path.join(this.stateDir, "reextract-jobs.jsonl");
     const lines = events.map((event) => JSON.stringify(event)).join("\n") + "\n";
     try {
       await this.appendStorageSecureFile(filePath, lines);
@@ -4142,7 +3951,7 @@ ${memory.content}
   }
   async readReextractJobs(limit = 200) {
     const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(1e3, Math.floor(limit))) : 200;
-    const filePath = path2.join(this.stateDir, "reextract-jobs.jsonl");
+    const filePath = path.join(this.stateDir, "reextract-jobs.jsonl");
     try {
       const raw = await this.readStorageSecureFile(filePath);
       const lines = raw.split("\n").filter((line) => line.trim().length > 0);
@@ -4314,7 +4123,7 @@ ${memory.content}
       return false;
     }
     if (draftState.contentHash) {
-      const contentHash = createHash2("sha256").update(draftContent).digest("hex");
+      const contentHash = createHash("sha256").update(draftContent).digest("hex");
       if (contentHash !== draftState.contentHash) return false;
     }
     await this.writeCompressionGuidelines(draftContent);
@@ -4396,7 +4205,7 @@ ${memory.content}
     const date = nowIso.slice(0, 10);
     const id = this.generateId("incident");
     const incident = createContinuityIncidentRecord(id, input, nowIso);
-    const filePath = path2.join(this.identityIncidentsDir, `${date}-${id}.md`);
+    const filePath = path.join(this.identityIncidentsDir, `${date}-${id}.md`);
     await this.writeStorageSecureFile(filePath, serializeContinuityIncident(incident));
     return { ...incident, filePath };
   }
@@ -4409,7 +4218,7 @@ ${memory.content}
       const incidents = [];
       for (const file of candidates) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path2.join(this.identityIncidentsDir, file);
+        const filePath = path.join(this.identityIncidentsDir, file);
         try {
           const raw = await this.readStorageSecureFile(filePath);
           const parsed = parseContinuityIncident(raw);
@@ -4440,7 +4249,7 @@ ${memory.content}
     await this.ensureDirectories();
     const safeKey = this.sanitizeIdentityAuditKey(key);
     const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-    const filePath = path2.join(dir, `${safeKey}.md`);
+    const filePath = path.join(dir, `${safeKey}.md`);
     await this.writeStorageSecureFile(filePath, content);
     return filePath;
   }
@@ -4448,7 +4257,7 @@ ${memory.content}
     try {
       const safeKey = this.sanitizeIdentityAuditKey(key);
       const dir = period === "weekly" ? this.identityAuditsWeeklyDir : this.identityAuditsMonthlyDir;
-      return await this.readStorageSecureFile(path2.join(dir, `${safeKey}.md`));
+      return await this.readStorageSecureFile(path.join(dir, `${safeKey}.md`));
     } catch (err) {
       if (err instanceof Error && err.message === "Invalid identity audit key") return null;
       if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -4512,12 +4321,12 @@ ${memory.content}
     const fileNames = await this.readContinuityIncidentFileNames();
     const directMatch = fileNames.find((name) => name.endsWith(`-${id}.md`));
     if (directMatch) {
-      const directPath = path2.join(this.identityIncidentsDir, directMatch);
+      const directPath = path.join(this.identityIncidentsDir, directMatch);
       const parsed = await this.readContinuityIncidentFile(directPath);
       if (parsed?.id === id) return directPath;
     }
     for (const fileName of fileNames) {
-      const filePath = path2.join(this.identityIncidentsDir, fileName);
+      const filePath = path.join(this.identityIncidentsDir, fileName);
       const parsed = await this.readContinuityIncidentFile(filePath);
       if (parsed?.id === id) return filePath;
     }
@@ -4547,7 +4356,7 @@ ${question}
 
 **Context:** ${context}
 `;
-    const filePath = path2.join(this.questionsDir, `${id}.md`);
+    const filePath = path.join(this.questionsDir, `${id}.md`);
     await writeFile(filePath, content, "utf-8");
     log.debug(`wrote question ${id} to ${filePath}`);
     this.invalidateQuestionsCache();
@@ -4571,7 +4380,7 @@ ${question}
       const questions = [];
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = path2.join(this.questionsDir, file);
+        const filePath = path.join(this.questionsDir, file);
         const raw = await readMaybeEncryptedFile(filePath, this._secureStoreKey, this.baseDir);
         const parsed = this.parseQuestionFile(raw, filePath);
         if (parsed) {
@@ -4594,7 +4403,7 @@ ${question}
     if (!match) return null;
     const frontmatterStr = match[1];
     const body = match[2].trim();
-    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path2.basename(filePath, ".md");
+    const id = this.extractFrontmatterValue(frontmatterStr, "id") ?? path.basename(filePath, ".md");
     const created = this.extractFrontmatterValue(frontmatterStr, "created") ?? "";
     const priority = parseFloat(
       this.extractFrontmatterValue(frontmatterStr, "priority") ?? "0.5"
@@ -4656,11 +4465,11 @@ ${question}
     } catch {
     }
     const hygiene = opts?.hygiene;
-    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path2.basename(identityPath));
+    const rotateEnabled = hygiene?.enabled === true && hygiene.rotateEnabled === true && Array.isArray(hygiene.rotatePaths) && hygiene.rotatePaths.includes(path.basename(identityPath));
     if (rotateEnabled) {
       const maxBytes = hygiene.rotateMaxBytes;
       if (existing.length > maxBytes) {
-        const archiveDir = path2.join(workspaceDir, hygiene.archiveDir);
+        const archiveDir = path.join(workspaceDir, hygiene.archiveDir);
         const { newContent } = await rotateMarkdownFileToArchive({
           filePath: identityPath,
           archiveDir,
@@ -4754,7 +4563,7 @@ ${reflection}
    * Deduplicates by target+label.
    */
   async addEntityRelationship(name, rel) {
-    const filePath = path2.join(this.entitiesDir, `${name}.md`);
+    const filePath = path.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -4779,7 +4588,7 @@ ${reflection}
    * Prepends to the beginning, prunes oldest entries beyond maxEntries.
    */
   async addEntityActivity(name, entry, maxEntries) {
-    const filePath = path2.join(this.entitiesDir, `${name}.md`);
+    const filePath = path.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -4802,7 +4611,7 @@ ${reflection}
    * Add an alias to an entity file. Deduplicates.
    */
   async addEntityAlias(name, alias) {
-    const filePath = path2.join(this.entitiesDir, `${name}.md`);
+    const filePath = path.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -4823,7 +4632,7 @@ ${reflection}
    * Set or rewrite the synthesis layer of an entity file.
    */
   async updateEntitySynthesis(name, synthesis, options = {}) {
-    const filePath = path2.join(this.entitiesDir, `${name}.md`);
+    const filePath = path.join(this.entitiesDir, `${name}.md`);
     let entity;
     try {
       const content = await this.readStorageSecureFile(filePath);
@@ -4861,7 +4670,7 @@ ${reflection}
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     let synthesisTimelineCount;
     try {
-      const filePath = path2.join(this.entitiesDir, `${name}.md`);
+      const filePath = path.join(this.entitiesDir, `${name}.md`);
       const content = await this.readStorageSecureFile(filePath);
       synthesisTimelineCount = parseEntityFile(content, this.entitySchemas).timeline.length;
     } catch (err) {
@@ -4944,7 +4753,7 @@ ${reflection}
       if (!raw) continue;
       const serialized = serializeEntityFile(parseEntityFile(raw, this.entitySchemas), this.entitySchemas);
       if (raw.trimEnd() === serialized.trimEnd()) continue;
-      await this.writeStorageSecureFile(path2.join(this.entitiesDir, `${entityName}.md`), serialized);
+      await this.writeStorageSecureFile(path.join(this.entitiesDir, `${entityName}.md`), serialized);
       migrated += 1;
     }
     if (migrated > 0) {
@@ -4980,7 +4789,7 @@ ${reflection}
         const results = await Promise.all(
           batch.map(async (entry) => {
             try {
-              return await this.readStorageSecureFile(path2.join(this.entitiesDir, entry));
+              return await this.readStorageSecureFile(path.join(this.entitiesDir, entry));
             } catch (err) {
               if (err instanceof SecureStoreLockedError) throw err;
               if (!isErrnoCode(err, "ENOENT")) throw err;
@@ -5126,7 +4935,7 @@ ${rows.join("\n")}
           extraSections: []
         };
         for (const file of files) {
-          const filePath = path2.join(this.entitiesDir, file);
+          const filePath = path.join(this.entitiesDir, file);
           try {
             const content = await this.readStorageSecureFile(filePath);
             const parsed = parseEntityFile(content, this.entitySchemas);
@@ -5257,10 +5066,10 @@ ${rows.join("\n")}
         }
         mergedEntity.created = mergedEntity.created || mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
         mergedEntity.updated = mergedEntity.updated || (/* @__PURE__ */ new Date()).toISOString();
-        const canonicalPath = path2.join(this.entitiesDir, `${canonical}.md`);
+        const canonicalPath = path.join(this.entitiesDir, `${canonical}.md`);
         await this.writeStorageSecureFile(canonicalPath, serializeEntityFile(mergedEntity, this.entitySchemas));
         for (const file of files) {
-          const filePath = path2.join(this.entitiesDir, file);
+          const filePath = path.join(this.entitiesDir, file);
           if (filePath !== canonicalPath) {
             try {
               await unlink(filePath);
@@ -5359,7 +5168,7 @@ ${memory.content}
     const filePaths = await this.collectActiveMemoryPaths();
     const foundIds = /* @__PURE__ */ new Set();
     for (const filePath of filePaths) {
-      const basename = path2.basename(filePath, ".md");
+      const basename = path.basename(filePath, ".md");
       if (wantedIds.has(basename)) {
         foundIds.add(basename);
         if (foundIds.size === wantedIds.size) break;
@@ -5459,15 +5268,15 @@ ${sanitized.text}
 `;
     let filePath;
     if (category === "correction") {
-      filePath = path2.join(this.correctionsDir, `${id}.md`);
+      filePath = path.join(this.correctionsDir, `${id}.md`);
     } else if (category === "procedure") {
-      await mkdir(path2.join(this.proceduresDir, today), { recursive: true });
-      filePath = path2.join(this.proceduresDir, today, `${id}.md`);
+      await mkdir(path.join(this.proceduresDir, today), { recursive: true });
+      filePath = path.join(this.proceduresDir, today, `${id}.md`);
     } else if (category === "reasoning_trace") {
-      await mkdir(path2.join(this.reasoningTracesDir, today), { recursive: true });
-      filePath = path2.join(this.reasoningTracesDir, today, `${id}.md`);
+      await mkdir(path.join(this.reasoningTracesDir, today), { recursive: true });
+      filePath = path.join(this.reasoningTracesDir, today, `${id}.md`);
     } else {
-      filePath = path2.join(this.factsDir, today, `${id}.md`);
+      filePath = path.join(this.factsDir, today, `${id}.md`);
     }
     await this.writeStorageSecureFile(filePath, fileContent);
     log.debug(`wrote chunk ${id} (${chunkIndex + 1}/${chunkTotal}) to ${filePath}`);
@@ -5536,14 +5345,14 @@ Reason: ${reason}`, {
   // Memory Summarization (Phase 4A)
   // ---------------------------------------------------------------------------
   get summariesDir() {
-    return path2.join(this.baseDir, "summaries");
+    return path.join(this.baseDir, "summaries");
   }
   /**
    * Write a memory summary.
    */
   async writeSummary(summary) {
     await mkdir(this.summariesDir, { recursive: true });
-    const filePath = path2.join(this.summariesDir, `${summary.id}.json`);
+    const filePath = path.join(this.summariesDir, `${summary.id}.json`);
     await this.writeStorageSecureFile(filePath, JSON.stringify(summary, null, 2));
     log.debug(`wrote summary ${summary.id}`);
   }
@@ -5556,7 +5365,7 @@ Reason: ${reason}`, {
       const summaries = [];
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
-        const filePath = path2.join(this.summariesDir, file);
+        const filePath = path.join(this.summariesDir, file);
         const raw = await this.readStorageSecureFile(filePath);
         summaries.push(JSON.parse(raw));
       }
@@ -5617,7 +5426,7 @@ ${memory.content}
    * Save topic scores to meta.json.
    */
   async saveTopics(topics) {
-    const metaPath = path2.join(this.stateDir, "topics.json");
+    const metaPath = path.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`);
@@ -5626,7 +5435,7 @@ ${memory.content}
    * Load topic scores from meta.json.
    */
   async loadTopics() {
-    const metaPath = path2.join(this.stateDir, "topics.json");
+    const metaPath = path.join(this.stateDir, "topics.json");
     try {
       const raw = await this.readStorageSecureFile(metaPath);
       return JSON.parse(raw);
@@ -5704,23 +5513,9 @@ ${memory.content}
 };
 
 export {
-  DEFAULT_SELF_NAME,
-  emptySpeakerRegistry,
-  speakersFilePath,
-  loadSpeakerRegistry,
-  saveSpeakerRegistry,
-  speakerRegistryKey,
-  resolveSpeaker,
-  distinctSpeakerLabels,
-  WEARABLES_DIR_NAME,
-  isValidTranscriptDate,
-  hashTranscriptBody,
-  composeDayTranscriptBody,
-  composeDayTranscriptMeta,
-  serializeDayTranscript,
-  parseDayTranscript,
   normalizeEntityName,
   ContentHashIndex,
+  stripAttributesSuffix,
   normalizeAttributePairs,
   compareEntityTimestamps,
   fingerprintEntityStructuredFacts,
@@ -5729,4 +5524,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-UGHUNQ74.js.map
+//# sourceMappingURL=chunk-QYGIQ5NM.js.map