@remnic/core 9.7.8 → 9.7.10

package/dist/{chunk-HHAA35A3.js → chunk-2VN4JAX7.js}

@@ -1,8 +1,17 @@
-// src/temporal-index.ts
+// src/temporal-index-compat.ts
 import { execFileSync } from "child_process";
+import * as crypto2 from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/temporal-index.ts
+import { execFile } from "child_process";
 import * as crypto from "crypto";
 import * as fs from "fs";
 import * as path from "path";
+import { setTimeout as delay } from "timers/promises";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
 var INDEX_VERSION = 2;
 var TEMPORAL_INDEX_FILE = "index_time.json";
 var TAG_INDEX_FILE = "index_tags.json";
@@ -10,8 +19,14 @@ var TAG_INDEX_VERSION = 2;
 var INDEX_LOCK_STALE_MS = 6e4;
 var INDEX_LOCK_POLL_MS = 10;
 var INDEX_PROCESS_START_TOLERANCE_MS = 2e3;
-var INDEX_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
 var INDEX_PROCESS_STARTED_AT_MS = Date.now() - process.uptime() * 1e3;
+var parsedIndexCache = /* @__PURE__ */ new Map();
+var writeChains = /* @__PURE__ */ new Map();
+var opChains = /* @__PURE__ */ new Map();
+var indexReadObserverForTest;
+function setIndexReadObserverForTest(observer) {
+  indexReadObserverForTest = observer;
+}
 function stateDir(memoryDir) {
   return path.join(memoryDir, "state");
 }
@@ -21,20 +36,73 @@ function temporalIndexPath(memoryDir) {
 function tagIndexPath(memoryDir) {
   return path.join(stateDir(memoryDir), TAG_INDEX_FILE);
 }
-function ensureStateDir(memoryDir) {
-  const dir = stateDir(memoryDir);
-  fs.mkdirSync(dir, { recursive: true });
+async function ensureStateDir(memoryDir) {
+  await fs.promises.mkdir(stateDir(memoryDir), { recursive: true });
+}
+function identityFromStat(stat) {
+  return {
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+    ctimeMs: stat.ctimeMs,
+    ino: stat.ino
+  };
+}
+function identityEquals(left, right) {
+  return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs && left.ino === right.ino;
 }
-function readJsonSafe(filePath, fallback) {
+async function loadIndexCached(filePath, normalize, hasCurrentSchema) {
+  let handle;
   try {
-    const raw = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
+    handle = await fs.promises.open(filePath, "r");
+  } catch (error) {
+    return error?.code === "ENOENT" ? { kind: "missing" } : { kind: "invalid" };
+  }
+  try {
+    const identity = identityFromStat(await handle.stat());
+    const cached = parsedIndexCache.get(filePath);
+    if (cached && identityEquals(cached.identity, identity)) {
+      return { kind: "ok", index: cached.index, currentSchema: cached.currentSchema };
+    }
+    indexReadObserverForTest?.();
+    const parsed = JSON.parse(await handle.readFile("utf8"));
+    const index = normalize(parsed);
+    const currentSchema = hasCurrentSchema(parsed);
+    parsedIndexCache.set(filePath, { identity, index, currentSchema });
+    return { kind: "ok", index, currentSchema };
   } catch {
-    return fallback;
+    parsedIndexCache.delete(filePath);
+    return { kind: "invalid" };
+  } finally {
+    await handle.close().catch(() => void 0);
   }
 }
-function sleepSync(ms) {
-  Atomics.wait(INDEX_LOCK_SLEEP, 0, 0, ms);
+function withPathMutex(filePath, update) {
+  const previous = writeChains.get(filePath) ?? Promise.resolve();
+  const run = previous.then(update, update);
+  const tail = run.then(() => void 0, () => void 0);
+  writeChains.set(filePath, tail);
+  void tail.then(() => {
+    if (writeChains.get(filePath) === tail) writeChains.delete(filePath);
+  });
+  return run;
+}
+function withMemoryDirMutex(memoryDir, op) {
+  const previous = opChains.get(memoryDir) ?? Promise.resolve();
+  const run = previous.then(op, op);
+  const tail = run.then(() => void 0, () => void 0);
+  opChains.set(memoryDir, tail);
+  void tail.then(() => {
+    if (opChains.get(memoryDir) === tail) opChains.delete(memoryDir);
+  });
+  return run;
+}
+async function primeCacheAfterWrite(filePath, index, isCurrentSchema) {
+  try {
+    const identity = identityFromStat(await fs.promises.stat(filePath));
+    parsedIndexCache.set(filePath, { identity, index, currentSchema: isCurrentSchema() });
+  } catch {
+    parsedIndexCache.delete(filePath);
+  }
 }
 function uniqueTempPath(filePath) {
   const dir = path.dirname(filePath);
@@ -45,9 +113,9 @@ function uniqueTempPath(filePath) {
 function lockOwnerPath(lockDir) {
   return path.join(lockDir, "owner.json");
 }
-function writeIndexLockOwner(lockDir) {
+async function writeIndexLockOwner(lockDir) {
   try {
-    fs.writeFileSync(
+    await fs.promises.writeFile(
       lockOwnerPath(lockDir),
       JSON.stringify({
         pid: process.pid,
@@ -62,9 +130,9 @@ function writeIndexLockOwner(lockDir) {
   } catch {
   }
 }
-function readIndexLockOwner(lockDir) {
+async function readIndexLockOwner(lockDir) {
   try {
-    const parsed = JSON.parse(fs.readFileSync(lockOwnerPath(lockDir), "utf8"));
+    const parsed = JSON.parse(await fs.promises.readFile(lockOwnerPath(lockDir), "utf8"));
     if (!(typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0)) return null;
     const owner = { pid: parsed.pid };
     if ("createdAt" in parsed && typeof parsed.createdAt === "string" && parsed.createdAt.length > 0) {
@@ -88,13 +156,13 @@ function processIsAlive(pid) {
     return code === "EPERM";
   }
 }
-function readProcessStartedAtMs(pid) {
+async function readProcessStartedAtMs(pid) {
   try {
-    const output = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+    const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
       timeout: 1e3
-    }).trim();
+    });
+    const output = stdout.trim();
     if (!output) return null;
     const startedAtMs = Date.parse(output);
     return Number.isFinite(startedAtMs) ? startedAtMs : null;
@@ -102,10 +170,10 @@ function readProcessStartedAtMs(pid) {
     return null;
   }
 }
-function lockOwnerIsRunning(owner) {
+async function lockOwnerIsRunning(owner) {
   if (!processIsAlive(owner.pid)) return false;
   if (owner.processStartedAtMs === void 0) return true;
-  const runningStartedAtMs = readProcessStartedAtMs(owner.pid);
+  const runningStartedAtMs = await readProcessStartedAtMs(owner.pid);
   if (runningStartedAtMs === null) return true;
   return runningStartedAtMs <= owner.processStartedAtMs + INDEX_PROCESS_START_TOLERANCE_MS;
 }
@@ -114,76 +182,79 @@ function lockIsFresh(lockInfo, owner) {
   const referenceMs = Number.isFinite(ownerCreatedAtMs) ? ownerCreatedAtMs : lockInfo.mtimeMs;
   return Date.now() - referenceMs < INDEX_LOCK_STALE_MS;
 }
-function removeAbandonedIndexLock(lockDir) {
+async function removeAbandonedIndexLock(lockDir) {
   try {
-    const info = fs.lstatSync(lockDir);
+    const info = await fs.promises.lstat(lockDir);
     if (info.isSymbolicLink()) return "blocked";
     if (!info.isDirectory()) {
-      fs.rmSync(lockDir, { force: true });
+      await fs.promises.rm(lockDir, { force: true });
       return "removed";
     }
-    const owner = readIndexLockOwner(lockDir);
+    const owner = await readIndexLockOwner(lockDir);
     if (owner !== null) {
-      if (lockOwnerIsRunning(owner)) return "wait";
+      if (await lockOwnerIsRunning(owner)) return "wait";
     }
     if (owner === null && lockIsFresh(info, null)) return "wait";
-    fs.rmSync(lockDir, { recursive: true, force: true });
+    await fs.promises.rm(lockDir, { recursive: true, force: true });
     return "removed";
   } catch (error) {
     if (error?.code === "ENOENT") return "removed";
     return "blocked";
   }
 }
-function withIndexFileLock(filePath, update) {
+async function withIndexFileLock(filePath, update) {
   const lockDir = `${filePath}.lock.d`;
   let acquired = false;
   while (!acquired) {
     try {
-      fs.mkdirSync(lockDir);
-      writeIndexLockOwner(lockDir);
+      await fs.promises.mkdir(lockDir);
+      await writeIndexLockOwner(lockDir);
       acquired = true;
     } catch (error) {
       const code = error?.code;
       if (code === "ENOENT") {
         try {
-          fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+          await fs.promises.mkdir(path.dirname(lockDir), { recursive: true });
         } catch {
-          return;
+          return void 0;
         }
-        sleepSync(INDEX_LOCK_POLL_MS);
+        await delay(INDEX_LOCK_POLL_MS);
         continue;
       }
-      if (code !== "EEXIST") return;
-      const cleanupResult = removeAbandonedIndexLock(lockDir);
-      if (cleanupResult === "blocked") return;
-      sleepSync(INDEX_LOCK_POLL_MS);
+      if (code !== "EEXIST") return void 0;
+      const cleanupResult = await removeAbandonedIndexLock(lockDir);
+      if (cleanupResult === "blocked") return void 0;
+      await delay(INDEX_LOCK_POLL_MS);
     }
   }
+  let result;
   try {
-    update();
+    result = await update();
   } finally {
     try {
-      fs.rmSync(lockDir, { recursive: true, force: true });
+      await fs.promises.rm(lockDir, { recursive: true, force: true });
     } catch {
     }
   }
+  return result;
 }
-function writeJsonAtomic(filePath, data) {
-  const payload = JSON.stringify(data, null, 2);
+async function writeJsonAtomic(filePath, data) {
+  const payload = JSON.stringify(data);
   for (let attempt = 0; attempt < 3; attempt += 1) {
     const tmp = uniqueTempPath(filePath);
     try {
-      fs.writeFileSync(tmp, payload, "utf8");
-      fs.renameSync(tmp, filePath);
-      return;
+      await fs.promises.writeFile(tmp, payload, "utf8");
+      await fs.promises.rename(tmp, filePath);
+      return true;
     } catch {
       try {
-        fs.unlinkSync(tmp);
+        await fs.promises.unlink(tmp);
       } catch {
       }
-      sleepSync(INDEX_LOCK_POLL_MS);
+      await delay(INDEX_LOCK_POLL_MS);
     }
   }
+  return false;
 }
 function emptyTemporalIndex() {
   return { version: INDEX_VERSION, dates: {}, events: {} };
@@ -200,22 +271,49 @@ function normalizeTemporalIndex(raw) {
     ...typeof raw.lastRebuildAt === "string" ? { lastRebuildAt: raw.lastRebuildAt } : {}
   };
 }
-function updateTemporalIndex(memoryDir, update) {
+function hasCurrentTemporalIndexSchema(raw) {
+  return isRecord(raw) && raw.version === INDEX_VERSION && isRecord(raw.dates) && isRecord(raw.events);
+}
+async function updateTemporalIndex(memoryDir, update) {
   const indexPath = temporalIndexPath(memoryDir);
-  withIndexFileLock(indexPath, () => {
-    const index = normalizeTemporalIndex(readJsonSafe(indexPath, emptyTemporalIndex()));
-    update(index);
-    writeJsonAtomic(indexPath, index);
+  return withPathMutex(indexPath, async () => {
+    const ok = await withIndexFileLock(indexPath, async () => {
+      const loaded = await loadIndexCached(
+        indexPath,
+        (raw) => normalizeTemporalIndex(raw),
+        hasCurrentTemporalIndexSchema
+      );
+      const index = structuredClone(loaded.kind === "ok" ? loaded.index : emptyTemporalIndex());
+      update(index);
+      if (await writeJsonAtomic(indexPath, index)) {
+        await primeCacheAfterWrite(indexPath, index, () => hasCurrentTemporalIndexSchema(index));
+        return true;
+      }
+      parsedIndexCache.delete(indexPath);
+      return false;
+    });
+    return ok === true;
   });
 }
-function updateTagIndex(memoryDir, update) {
+async function updateTagIndex(memoryDir, update) {
   const indexPath = tagIndexPath(memoryDir);
-  withIndexFileLock(indexPath, () => {
-    const index = normalizeTagIndex(
-      readJsonSafe(indexPath, { version: TAG_INDEX_VERSION, tags: {}, aliases: {} })
-    );
-    update(index);
-    writeJsonAtomic(indexPath, index);
+  await withPathMutex(indexPath, async () => {
+    await withIndexFileLock(indexPath, async () => {
+      const loaded = await loadIndexCached(
+        indexPath,
+        (raw) => normalizeTagIndex(raw),
+        () => true
+      );
+      const index = structuredClone(
+        loaded.kind === "ok" ? loaded.index : { version: TAG_INDEX_VERSION, tags: {}, aliases: {} }
+      );
+      update(index);
+      if (await writeJsonAtomic(indexPath, index)) {
+        await primeCacheAfterWrite(indexPath, index, () => true);
+      } else {
+        parsedIndexCache.delete(indexPath);
+      }
+    });
   });
 }
 function isoDateFromTimestamp(isoString) {
@@ -487,104 +585,159 @@ function expandCanonicalTags(index, rawTags) {
 function aliasPhrase(alias) {
   return alias.replace(/\//g, " ").replace(/-/g, " ").replace(/\s+/g, " ").trim();
 }
-function promptContainsAlias(prompt, alias) {
-  const phrase = aliasPhrase(alias);
-  if (!phrase) return false;
-  const normalizedPrompt = ` ${normalizeAliasKey(prompt)} `;
-  return normalizedPrompt.includes(` ${phrase} `);
+function applyTemporalIndexCompatibilityMutation(raw, mutation) {
+  const index = structuredClone(normalizeTemporalIndex(raw));
+  if (mutation.kind === "clear") {
+    return emptyTemporalIndex();
+  }
+  if (mutation.kind === "index") index.version = INDEX_VERSION;
+  for (const entry of mutation.entries) {
+    const dateKey = isoDateFromTimestamp(entry.createdAt);
+    if (mutation.kind === "index") {
+      removePathFromAllSets(index.dates, entry.path);
+      addPathToSet(index.dates, dateKey, entry.path);
+      index.events[entry.path] = temporalEventFromEntry(entry);
+    } else {
+      removePathFromSet(index.dates, dateKey, entry.path);
+      delete index.events[entry.path];
+    }
+  }
+  return index;
 }
-function indexMemory(memoryDir, memoryPath, createdAt, tags, temporal = {}) {
+function applyTagIndexCompatibilityMutation(raw, mutation) {
+  const index = structuredClone(normalizeTagIndex(raw));
+  if (mutation.kind === "clear") {
+    return { version: TAG_INDEX_VERSION, tags: {}, aliases: {} };
+  }
+  for (const entry of mutation.entries) {
+    if (mutation.kind === "index") {
+      removePathFromAllTagEntries(index, entry.path);
+      for (const tag of entry.tags) {
+        if (tag && typeof tag === "string") addTagGraphEntry(index, tag, entry.path);
+      }
+    } else {
+      for (const tag of entry.tags) {
+        if (tag && typeof tag === "string") removeTagGraphEntry(index, tag, entry.path);
+      }
+    }
+  }
+  return index;
+}
+function hasCurrentTemporalIndexSchemaForCompatibility(raw) {
+  return hasCurrentTemporalIndexSchema(raw);
+}
+async function indexMemoryAsync(memoryDir, memoryPath, createdAt, tags, temporal = {}) {
   try {
-    ensureStateDir(memoryDir);
+    await ensureStateDir(memoryDir);
     const dateKey = isoDateFromTimestamp(createdAt);
-    updateTemporalIndex(memoryDir, (index) => {
-      index.version = INDEX_VERSION;
-      removePathFromAllSets(index.dates, memoryPath);
-      addPathToSet(index.dates, dateKey, memoryPath);
-      index.events[memoryPath] = temporalEventFromEntry({
-        path: memoryPath,
-        createdAt,
-        tags,
-        ...temporal
+    await withMemoryDirMutex(memoryDir, async () => {
+      const temporalOk = await updateTemporalIndex(memoryDir, (index) => {
+        index.version = INDEX_VERSION;
+        removePathFromAllSets(index.dates, memoryPath);
+        addPathToSet(index.dates, dateKey, memoryPath);
+        index.events[memoryPath] = temporalEventFromEntry({
+          path: memoryPath,
+          createdAt,
+          tags,
+          ...temporal
+        });
       });
-    });
-    updateTagIndex(memoryDir, (index) => {
-      removePathFromAllTagEntries(index, memoryPath);
-      for (const tag of tags) {
-        if (tag && typeof tag === "string") {
-          addTagGraphEntry(index, tag, memoryPath);
-        }
+      if (temporalOk) {
+        await updateTagIndex(memoryDir, (index) => {
+          removePathFromAllTagEntries(index, memoryPath);
+          for (const tag of tags) {
+            if (tag && typeof tag === "string") {
+              addTagGraphEntry(index, tag, memoryPath);
+            }
+          }
+        });
       }
     });
   } catch {
   }
 }
-function deindexMemory(memoryDir, memoryPath, createdAt, tags) {
+async function deindexMemoryAsync(memoryDir, memoryPath, createdAt, tags) {
   try {
-    ensureStateDir(memoryDir);
+    await ensureStateDir(memoryDir);
     const dateKey = isoDateFromTimestamp(createdAt);
-    updateTemporalIndex(memoryDir, (index) => {
-      removePathFromSet(index.dates, dateKey, memoryPath);
-      delete index.events[memoryPath];
-    });
-    updateTagIndex(memoryDir, (index) => {
-      for (const tag of tags) {
-        if (tag && typeof tag === "string") {
-          removeTagGraphEntry(index, tag, memoryPath);
-        }
+    await withMemoryDirMutex(memoryDir, async () => {
+      const temporalOk = await updateTemporalIndex(memoryDir, (index) => {
+        removePathFromSet(index.dates, dateKey, memoryPath);
+        delete index.events[memoryPath];
+      });
+      if (temporalOk) {
+        await updateTagIndex(memoryDir, (index) => {
+          for (const tag of tags) {
+            if (tag && typeof tag === "string") {
+              removeTagGraphEntry(index, tag, memoryPath);
+            }
+          }
+        });
       }
     });
   } catch {
   }
 }
-function clearIndexes(memoryDir) {
+async function clearIndexesAsync(memoryDir) {
   try {
-    ensureStateDir(memoryDir);
-    updateTemporalIndex(memoryDir, (index) => {
-      index.version = INDEX_VERSION;
-      index.lastRebuildAt = void 0;
-      index.dates = {};
-      index.events = {};
-    });
-    updateTagIndex(memoryDir, (index) => {
-      index.version = TAG_INDEX_VERSION;
-      index.lastRebuildAt = void 0;
-      index.tags = {};
-      index.aliases = {};
+    await ensureStateDir(memoryDir);
+    await withMemoryDirMutex(memoryDir, async () => {
+      const temporalOk = await updateTemporalIndex(memoryDir, (index) => {
+        index.version = INDEX_VERSION;
+        index.lastRebuildAt = void 0;
+        index.dates = {};
+        index.events = {};
+      });
+      if (temporalOk) {
+        await updateTagIndex(memoryDir, (index) => {
+          index.version = TAG_INDEX_VERSION;
+          index.lastRebuildAt = void 0;
+          index.tags = {};
+          index.aliases = {};
+        });
+      }
     });
   } catch {
   }
 }
-function indexesExist(memoryDir) {
+async function indexesExistAsync(memoryDir) {
   try {
-    if (!fs.existsSync(tagIndexPath(memoryDir))) return false;
-    const raw = JSON.parse(fs.readFileSync(temporalIndexPath(memoryDir), "utf8"));
-    return isRecord(raw) && raw.version === INDEX_VERSION && isRecord(raw.dates) && isRecord(raw.events);
+    await fs.promises.access(tagIndexPath(memoryDir));
+    const loaded = await loadIndexCached(
+      temporalIndexPath(memoryDir),
+      (raw) => normalizeTemporalIndex(raw),
+      hasCurrentTemporalIndexSchema
+    );
+    return loaded.kind === "ok" && loaded.currentSchema;
   } catch {
     return false;
   }
 }
-function indexMemoriesBatch(memoryDir, entries) {
+async function indexMemoriesBatchAsync(memoryDir, entries) {
   if (entries.length === 0) return;
   try {
-    ensureStateDir(memoryDir);
-    updateTemporalIndex(memoryDir, (index) => {
-      index.version = INDEX_VERSION;
-      for (const entry of entries) {
-        const dateKey = isoDateFromTimestamp(entry.createdAt);
-        removePathFromAllSets(index.dates, entry.path);
-        addPathToSet(index.dates, dateKey, entry.path);
-        index.events[entry.path] = temporalEventFromEntry(entry);
-      }
-    });
-    updateTagIndex(memoryDir, (index) => {
-      for (const entry of entries) {
-        removePathFromAllTagEntries(index, entry.path);
-        for (const tag of entry.tags) {
-          if (tag && typeof tag === "string") {
-            addTagGraphEntry(index, tag, entry.path);
-          }
+    await ensureStateDir(memoryDir);
+    await withMemoryDirMutex(memoryDir, async () => {
+      const temporalOk = await updateTemporalIndex(memoryDir, (index) => {
+        index.version = INDEX_VERSION;
+        for (const entry of entries) {
+          const dateKey = isoDateFromTimestamp(entry.createdAt);
+          removePathFromAllSets(index.dates, entry.path);
+          addPathToSet(index.dates, dateKey, entry.path);
+          index.events[entry.path] = temporalEventFromEntry(entry);
         }
+      });
+      if (temporalOk) {
+        await updateTagIndex(memoryDir, (index) => {
+          for (const entry of entries) {
+            removePathFromAllTagEntries(index, entry.path);
+            for (const tag of entry.tags) {
+              if (tag && typeof tag === "string") {
+                addTagGraphEntry(index, tag, entry.path);
+              }
+            }
+          }
+        });
       }
     });
   } catch {
@@ -593,18 +746,13 @@ function indexMemoriesBatch(memoryDir, entries) {
 async function queryByDateRangeAsync(memoryDir, fromDate, toDate) {
   try {
     const tPath = temporalIndexPath(memoryDir);
-    let raw;
-    try {
-      raw = await fs.promises.readFile(tPath, "utf8");
-    } catch {
-      return null;
-    }
-    let tIndex;
-    try {
-      tIndex = normalizeTemporalIndex(JSON.parse(raw));
-    } catch {
-      tIndex = emptyTemporalIndex();
-    }
+    const loaded = await loadIndexCached(
+      tPath,
+      (raw) => normalizeTemporalIndex(raw),
+      hasCurrentTemporalIndexSchema
+    );
+    if (loaded.kind === "missing") return null;
+    const tIndex = loaded.kind === "ok" ? loaded.index : emptyTemporalIndex();
     const end = toDate ?? new Date(Date.now() + 864e5).toISOString().slice(0, 10);
     const results = /* @__PURE__ */ new Set();
     for (const [date, paths] of Object.entries(tIndex.dates)) {
@@ -621,10 +769,13 @@ async function queryByDateRangeAsync(memoryDir, fromDate, toDate) {
 }
 async function queryTemporalTimelineAsync(memoryDir, options = {}) {
   try {
-    const raw = await fs.promises.readFile(temporalIndexPath(memoryDir), "utf8");
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed) || parsed.version !== INDEX_VERSION || !isRecord(parsed.dates) || !isRecord(parsed.events)) return null;
-    const index = normalizeTemporalIndex(parsed);
+    const loaded = await loadIndexCached(
+      temporalIndexPath(memoryDir),
+      (raw) => normalizeTemporalIndex(raw),
+      hasCurrentTemporalIndexSchema
+    );
+    if (loaded.kind !== "ok" || !loaded.currentSchema) return null;
+    const index = loaded.index;
     const chronology = Object.values(index.events).filter(
       (event) => typeof event?.path === "string" && event.path.length > 0 && normalizedIsoTimestamp(event.eventAt) !== void 0
     ).map((event) => ({
@@ -664,19 +815,13 @@ async function queryByTagsAsync(memoryDir, tags) {
   if (tags.length === 0) return null;
   try {
     const gPath = tagIndexPath(memoryDir);
-    let raw;
-    try {
-      raw = await fs.promises.readFile(gPath, "utf8");
-    } catch {
-      return null;
-    }
-    let gIndex;
-    try {
-      gIndex = normalizeTagIndex(JSON.parse(raw));
-    } catch {
-      return null;
-    }
-    return queryByTagsFromIndex(gIndex, tags);
+    const loaded = await loadIndexCached(
+      gPath,
+      (raw) => normalizeTagIndex(raw),
+      () => true
+    );
+    if (loaded.kind !== "ok") return null;
+    return queryByTagsFromIndex(loaded.index, tags);
   } catch {
     return null;
   }
@@ -705,16 +850,28 @@ function extractTagsFromPrompt(prompt) {
 async function resolvePromptTagPrefilterAsync(memoryDir, prompt) {
   const explicitTags = extractTagsFromPrompt(prompt);
   try {
-    const raw = await fs.promises.readFile(tagIndexPath(memoryDir), "utf8");
-    const tagIndex = normalizeTagIndex(JSON.parse(raw));
+    const loaded = await loadIndexCached(
+      tagIndexPath(memoryDir),
+      (raw) => normalizeTagIndex(raw),
+      () => true
+    );
+    if (loaded.kind !== "ok") {
+      return { matchedTags: explicitTags, expandedTags: explicitTags, paths: null };
+    }
+    const tagIndex = loaded.index;
     const matched = new Set(explicitTags);
+    const normalizedPrompt = ` ${normalizeAliasKey(prompt)} `;
+    const containsAlias = (alias) => {
+      const phrase = aliasPhrase(alias);
+      return phrase.length > 0 && normalizedPrompt.includes(` ${phrase} `);
+    };
     for (const canonical of Object.keys(tagIndex.tags)) {
-      if (promptContainsAlias(prompt, canonical)) {
+      if (containsAlias(canonical)) {
         matched.add(canonical);
       }
     }
     for (const [alias, canonicals] of Object.entries(tagIndex.aliases ?? {})) {
-      if (!promptContainsAlias(prompt, alias)) continue;
+      if (!containsAlias(alias)) continue;
       for (const canonical of canonicals) {
         matched.add(canonical);
       }
@@ -737,6 +894,9 @@ async function resolvePromptTagPrefilterAsync(memoryDir, prompt) {
     return { matchedTags: explicitTags, expandedTags: explicitTags, paths: null };
   }
 }
+function readIndexSnapshotAsync(memoryDir, read) {
+  return withMemoryDirMutex(memoryDir, read);
+}
 function isTemporalQuery(prompt) {
   return /\b(today|yesterday|this week|last week|this month|last month|recent(?:ly)?|lately|just now|earlier today|this morning|last night|last year|this year|\d+ days? ago|\d+ hours? ago|\d+ weeks? ago|\d+ months? ago|(?:in |on |during |since |before |after )?(?:january|february|march|april|may|june|july|august|september|october|november|december)(?:\s+\d{1,4})?|\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}\/\d{2,4}|(?:spring|summer|fall|autumn|winter)\s+\d{4}|on the \d{1,2}(?:st|nd|rd|th)?|last (?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b/i.test(
     prompt
@@ -934,19 +1094,246 @@ function recencyWindowBoundsFromPrompt(prompt, nowMs = Date.now()) {
   return { fromDate, toDate };
 }
 
+// src/temporal-index-compat.ts
+var TEMPORAL_INDEX_FILE2 = "index_time.json";
+var TAG_INDEX_FILE2 = "index_tags.json";
+var INDEX_LOCK_STALE_MS2 = 6e4;
+var SYNC_INDEX_LOCK_BOUND_MS = 1500;
+var INDEX_LOCK_POLL_MS2 = 10;
+var INDEX_PROCESS_START_TOLERANCE_MS2 = 2e3;
+var INDEX_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(4));
+var INDEX_PROCESS_STARTED_AT_MS2 = Date.now() - process.uptime() * 1e3;
+function stateDir2(memoryDir) {
+  return path2.join(memoryDir, "state");
+}
+function temporalIndexPath2(memoryDir) {
+  return path2.join(stateDir2(memoryDir), TEMPORAL_INDEX_FILE2);
+}
+function tagIndexPath2(memoryDir) {
+  return path2.join(stateDir2(memoryDir), TAG_INDEX_FILE2);
+}
+function sleepSync(ms) {
+  Atomics.wait(INDEX_LOCK_SLEEP, 0, 0, ms);
+}
+function uniqueTempPath2(filePath) {
+  const nonce = crypto2.randomBytes(6).toString("hex");
+  return path2.join(
+    path2.dirname(filePath),
+    `.${path2.basename(filePath)}.${process.pid}.${Date.now()}.${nonce}.tmp`
+  );
+}
+function lockOwnerPath2(lockDir) {
+  return path2.join(lockDir, "owner.json");
+}
+function writeIndexLockOwner2(lockDir) {
+  try {
+    fs2.writeFileSync(
+      lockOwnerPath2(lockDir),
+      JSON.stringify({
+        pid: process.pid,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        processStartedAtMs: INDEX_PROCESS_STARTED_AT_MS2
+      }),
+      { encoding: "utf8", flag: "wx" }
+    );
+  } catch {
+  }
+}
+function readIndexLockOwner2(lockDir) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(lockOwnerPath2(lockDir), "utf8"));
+    if (!(typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0)) return null;
+    return {
+      pid: parsed.pid,
+      ...typeof parsed.createdAt === "string" && parsed.createdAt.length > 0 ? { createdAt: parsed.createdAt } : {},
+      ...typeof parsed.processStartedAtMs === "number" && Number.isFinite(parsed.processStartedAtMs) && parsed.processStartedAtMs > 0 ? { processStartedAtMs: parsed.processStartedAtMs } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function processIsAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+function readProcessStartedAtMs2(pid) {
+  try {
+    const output = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).trim();
+    if (!output) return null;
+    const startedAtMs = Date.parse(output);
+    return Number.isFinite(startedAtMs) ? startedAtMs : null;
+  } catch {
+    return null;
+  }
+}
+function lockOwnerIsRunning2(owner) {
+  if (!processIsAlive2(owner.pid)) return false;
+  if (owner.processStartedAtMs === void 0) return true;
+  const runningStartedAtMs = readProcessStartedAtMs2(owner.pid);
+  if (runningStartedAtMs === null) return true;
+  return runningStartedAtMs <= owner.processStartedAtMs + INDEX_PROCESS_START_TOLERANCE_MS2;
+}
+function lockIsFresh2(lockInfo, owner) {
+  const ownerCreatedAtMs = owner?.createdAt ? Date.parse(owner.createdAt) : Number.NaN;
+  const referenceMs = Number.isFinite(ownerCreatedAtMs) ? ownerCreatedAtMs : lockInfo.mtimeMs;
+  return Date.now() - referenceMs < INDEX_LOCK_STALE_MS2;
+}
+function removeAbandonedIndexLock2(lockDir) {
+  try {
+    const info = fs2.lstatSync(lockDir);
+    if (info.isSymbolicLink()) return "blocked";
+    if (!info.isDirectory()) {
+      fs2.rmSync(lockDir, { force: true });
+      return "removed";
+    }
+    const owner = readIndexLockOwner2(lockDir);
+    if (owner && lockOwnerIsRunning2(owner)) return "wait";
+    if (!owner && lockIsFresh2(info, null)) return "wait";
+    fs2.rmSync(lockDir, { recursive: true, force: true });
+    return "removed";
+  } catch (error) {
+    return error?.code === "ENOENT" ? "removed" : "blocked";
+  }
+}
+function withIndexFileLock2(filePath, update) {
+  const lockDir = `${filePath}.lock.d`;
+  const maxAttempts = Math.max(1, Math.ceil(SYNC_INDEX_LOCK_BOUND_MS / INDEX_LOCK_POLL_MS2));
+  let acquired = false;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      fs2.mkdirSync(lockDir);
+      writeIndexLockOwner2(lockDir);
+      acquired = true;
+      break;
+    } catch (error) {
+      const code = error?.code;
+      if (code === "ENOENT") {
+        try {
+          fs2.mkdirSync(path2.dirname(lockDir), { recursive: true });
+        } catch {
+          return;
+        }
+        sleepSync(INDEX_LOCK_POLL_MS2);
+        continue;
+      }
+      if (code !== "EEXIST") return;
+      if (removeAbandonedIndexLock2(lockDir) === "blocked") return;
+      sleepSync(INDEX_LOCK_POLL_MS2);
+    }
+  }
+  if (!acquired) return;
+  try {
+    update();
+  } finally {
+    try {
+      fs2.rmSync(lockDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs2.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonAtomic2(filePath, value) {
+  const payload = JSON.stringify(value);
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const tempPath = uniqueTempPath2(filePath);
+    try {
+      fs2.writeFileSync(tempPath, payload, "utf8");
+      fs2.renameSync(tempPath, filePath);
+      return;
+    } catch {
+      try {
+        fs2.unlinkSync(tempPath);
+      } catch {
+      }
+      sleepSync(INDEX_LOCK_POLL_MS2);
+    }
+  }
+}
+function applyMutation(memoryDir, mutation) {
+  try {
+    fs2.mkdirSync(stateDir2(memoryDir), { recursive: true });
+    const temporalPath = temporalIndexPath2(memoryDir);
+    const tagPath = tagIndexPath2(memoryDir);
+    withIndexFileLock2(temporalPath, () => {
+      withIndexFileLock2(tagPath, () => {
+        writeJsonAtomic2(
+          temporalPath,
+          applyTemporalIndexCompatibilityMutation(readJson(temporalPath), mutation)
+        );
+        writeJsonAtomic2(
+          tagPath,
+          applyTagIndexCompatibilityMutation(readJson(tagPath), mutation)
+        );
+      });
+    });
+  } catch {
+  }
+}
+function indexMemory(memoryDir, memoryPath, createdAt, tags, temporal = {}) {
+  applyMutation(memoryDir, {
+    kind: "index",
+    entries: [{ path: memoryPath, createdAt, tags, ...temporal }]
+  });
+}
+function deindexMemory(memoryDir, memoryPath, createdAt, tags) {
+  applyMutation(memoryDir, {
+    kind: "deindex",
+    entries: [{ path: memoryPath, createdAt, tags }]
+  });
+}
+function clearIndexes(memoryDir) {
+  applyMutation(memoryDir, { kind: "clear" });
+}
+function indexesExist(memoryDir) {
+  try {
+    if (!fs2.existsSync(tagIndexPath2(memoryDir))) return false;
+    return hasCurrentTemporalIndexSchemaForCompatibility(readJson(temporalIndexPath2(memoryDir)));
+  } catch {
+    return false;
+  }
+}
+function indexMemoriesBatch(memoryDir, entries) {
+  if (entries.length === 0) return;
+  applyMutation(memoryDir, { kind: "index", entries });
+}
+
 export {
   indexMemory,
   deindexMemory,
   clearIndexes,
   indexesExist,
   indexMemoriesBatch,
+  setIndexReadObserverForTest,
+  applyTemporalIndexCompatibilityMutation,
+  applyTagIndexCompatibilityMutation,
+  hasCurrentTemporalIndexSchemaForCompatibility,
+  indexMemoryAsync,
+  deindexMemoryAsync,
+  clearIndexesAsync,
+  indexesExistAsync,
+  indexMemoriesBatchAsync,
   queryByDateRangeAsync,
   queryTemporalTimelineAsync,
   queryByTagsAsync,
   extractTagsFromPrompt,
   resolvePromptTagPrefilterAsync,
+  readIndexSnapshotAsync,
   isTemporalQuery,
   recencyWindowFromPrompt,
   recencyWindowBoundsFromPrompt
 };
-//# sourceMappingURL=chunk-HHAA35A3.js.map
+//# sourceMappingURL=chunk-2VN4JAX7.js.map