@remnic/core 9.7.15 → 9.8.0

package/src/structured-attributes.ts

@@ -14,6 +14,8 @@
  * suffix-anchored patterns over library-supplied content.
  */
 
+import { sanitizeMemoryContent } from "./sanitize.js";
+
 /**
  * Remove the `[Attributes: …]` suffix `writeMemory` appends to the stored
  * body when structuredAttributes are present, yielding the raw fact/card text
@@ -37,3 +39,53 @@ export function stripAttributesSuffix(content: string): string {
   if (inner.includes("]") || inner.includes("\n")) return content.trim();
   return trimmed.slice(0, markerIndex).trim();
 }
+// ---------------------------------------------------------------------------
+// Persisted-body assembly (issue #1989 PR2)
+// ---------------------------------------------------------------------------
+//
+// `writeMemory` historically enriched content with the attribute suffix and
+// then sanitized the COMBINED body inline. That assembly is the persisted
+// form both the file body and write-idempotency fingerprints must agree on
+// (AGENTS.md §13), so it lives here — shared by `StorageManager.writeMemory`
+// and `composeMemoryEnvelope` — instead of existing twice.
+
+/**
+ * Canonical `key: value; …` rendering of structured attributes. Keys are
+ * trimmed + lowercased, values trimmed, pairs sorted by normalized key.
+ * Moved verbatim from `storage.ts` (which re-exports it for API stability);
+ * used at the write path, the dedup-lookup path, and envelope assembly.
+ */
+export function normalizeAttributePairs(pairs: Record<string, string>): string {
+  return Object.entries(pairs)
+    .map(([k, v]) => [k.trim().toLowerCase(), v.trim()] as [string, string])
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}: ${v}`)
+    .join("; ");
+}
+
+export interface AssembledPersistBody {
+  /** The exact body persistence writes: enriched then sanitized. */
+  text: string;
+  /** False when sanitization redacted injection-bearing text. */
+  clean: boolean;
+  /** Matched injection pattern sources (for the storage warn log). */
+  violations: string[];
+}
+
+/**
+ * Assemble the persisted body exactly as `writeMemory` does: append the
+ * normalized attribute suffix when attributes are present, then sanitize the
+ * combined result. ONE definition — byte-identity between the legacy write
+ * path and the sealed-envelope path is structural, not tested-by-hope.
+ */
+export function assemblePersistedBody(
+  content: string,
+  structuredAttributes?: Record<string, string>,
+): AssembledPersistBody {
+  let enriched = content;
+  if (structuredAttributes && Object.keys(structuredAttributes).length > 0) {
+    enriched = `${content}\n[Attributes: ${normalizeAttributePairs(structuredAttributes)}]`;
+  }
+  const sanitized = sanitizeMemoryContent(enriched);
+  return { text: sanitized.text, clean: sanitized.clean, violations: sanitized.violations };
+}

package/src/temporal-index-batch.ts

@@ -0,0 +1,112 @@
+/**
+ * Batch temporal/tag index mutations.
+ *
+ * Split from temporal-index.ts (issue #1911B / #1995): maintenance loops that
+ * add or invalidate N memories at once collect their entries and call these once
+ * instead of paying the per-memory read-parse-stringify-write amplification.
+ * Both operations reuse the low-level primitives exported from temporal-index.ts;
+ * per-entry semantics are byte-identical to indexMemoryAsync / deindexMemoryAsync.
+ */
+
+import {
+  INDEX_VERSION,
+  addPathToSet,
+  addTagGraphEntry,
+  ensureStateDir,
+  isoDateFromTimestamp,
+  removePathFromAllSets,
+  removePathFromAllTagEntries,
+  removePathFromSet,
+  removeTagGraphEntry,
+  temporalEventFromEntry,
+  updateTagIndex,
+  updateTemporalIndex,
+  withMemoryDirMutex,
+  type TemporalIndexEntry,
+} from "./temporal-index.js";
+
+/**
+ * Batch-add multiple memories to both indexes in a single read-modify-write cycle.
+ * More efficient than calling indexMemoryAsync() per file when adding many at once.
+ */
+export async function indexMemoriesBatchAsync(
+  memoryDir: string,
+  entries: TemporalIndexEntry[]
+): Promise<void> {
+  if (entries.length === 0) return;
+  try {
+    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 {
+    // Fail silently
+  }
+}
+
+/**
+ * Batch-remove multiple memories from both indexes in a single read-modify-write
+ * cycle per index. Mirrors {@link indexMemoriesBatchAsync}: maintenance loops that
+ * invalidate/archive N memories collect their entries and call this once, replacing
+ * the O(N) full read-parse-stringify-write amplification of per-memory
+ * deindexMemoryAsync with O(1) temporal + O(1) tag write cycles.
+ *
+ * Per-entry semantics are byte-identical to deindexMemoryAsync: the date
+ * set for each entry's `createdAt` drops the path, the temporal event is deleted,
+ * and each tag graph entry is removed. The temporal half commits first; the tag
+ * half only runs if it succeeds, so a partial failure never leaves tags orphaned
+ * from a temporal entry that still exists.
+ */
+export async function deindexMemoriesBatchAsync(
+  memoryDir: string,
+  entries: ReadonlyArray<Pick<TemporalIndexEntry, "path" | "createdAt" | "tags">>,
+): Promise<void> {
+  if (entries.length === 0) return;
+  try {
+    await ensureStateDir(memoryDir);
+
+    await withMemoryDirMutex(memoryDir, async () => {
+      const temporalOk = await updateTemporalIndex(memoryDir, (index) => {
+        for (const entry of entries) {
+          const dateKey = isoDateFromTimestamp(entry.createdAt);
+          removePathFromSet(index.dates, dateKey, entry.path);
+          delete index.events[entry.path];
+        }
+      });
+      if (temporalOk) {
+        await updateTagIndex(memoryDir, (index) => {
+          for (const entry of entries) {
+            for (const tag of entry.tags) {
+              if (tag && typeof tag === "string") {
+                removeTagGraphEntry(index, tag, entry.path);
+              }
+            }
+          }
+        });
+      }
+    });
+  } catch {
+    // Fail silently — indexes are advisory only
+  }
+}

package/src/temporal-index.test.ts

@@ -21,7 +21,10 @@ import {
   queryTemporalTimelineAsync,
   resolvePromptTagPrefilterAsync,
   setIndexReadObserverForTest,
+  setIndexWriteFailureForTest,
+  setIndexWriteObserverForTest,
 } from "./temporal-index.js";
+import { deindexMemoriesBatchAsync } from "./temporal-index-batch.js";
 
 test("legacy temporal-index exports preserve synchronous return timing and booleans", async () => {
   const memoryDir = await mkdtemp(join(tmpdir(), "remnic-temporal-index-sync-compat-"));
@@ -644,3 +647,193 @@ test("temporal timeline generic edge selection honors small and zero limits", as
     4,
   );
 });
+
+// ─── #1911B: batch de-index ─────────────────────────────────────────────────
+
+interface DeindexEntry {
+  path: string;
+  createdAt: string;
+  tags: string[];
+}
+
+// A spread of memories across distinct dates with hierarchical (alias-producing)
+// and flat tags, so equivalence covers date sets, event map, tag graph, and aliases.
+function sampleMemories(prefix: string, count: number): DeindexEntry[] {
+  const entries: DeindexEntry[] = [];
+  for (let i = 0; i < count; i += 1) {
+    const day = String((i % 28) + 1).padStart(2, "0");
+    entries.push({
+      path: `/tmp/${prefix}-memory-${i}.md`,
+      createdAt: `2026-05-${day}T09:00:00.000Z`,
+      tags: ["project/remnic", `worker/${i % 3}`, "shared", `flat-${i}`],
+    });
+  }
+  return entries;
+}
+
+async function seedIndex(memoryDir: string, entries: DeindexEntry[]): Promise<void> {
+  for (const e of entries) {
+    await indexMemory(memoryDir, e.path, e.createdAt, e.tags);
+  }
+}
+
+async function readRawIndexes(memoryDir: string): Promise<{ temporal: unknown; tags: unknown }> {
+  const temporal = JSON.parse(
+    await readFile(join(memoryDir, "state", "index_time.json"), "utf8"),
+  );
+  const tags = JSON.parse(
+    await readFile(join(memoryDir, "state", "index_tags.json"), "utf8"),
+  );
+  return { temporal, tags };
+}
+
+test("#1911B batch de-index yields the same final index as per-memory de-index", async () => {
+  const sequentialDir = await mkdtemp(join(tmpdir(), "remnic-deindex-seq-"));
+  const batchDir = await mkdtemp(join(tmpdir(), "remnic-deindex-batch-"));
+  const all = sampleMemories("equiv", 12);
+  await seedIndex(sequentialDir, all);
+  await seedIndex(batchDir, all);
+
+  // Remove a non-contiguous subset in a scrambled order; batching must not depend
+  // on removal order to reach the same final index.
+  const removed = [all[10], all[1], all[7], all[4], all[0]];
+
+  for (const e of removed) {
+    await deindexMemory(sequentialDir, e.path, e.createdAt, e.tags);
+  }
+  await deindexMemoriesBatchAsync(batchDir, removed);
+
+  const seq = await readRawIndexes(sequentialDir);
+  const batch = await readRawIndexes(batchDir);
+  assert.deepEqual(batch.temporal, seq.temporal);
+  assert.deepEqual(batch.tags, seq.tags);
+
+  // Survivors remain, removed paths are gone from both indexes.
+  const survivorPaths = all.filter((e) => !removed.includes(e)).map((e) => e.path);
+  const stillIndexed = await queryByTagsAsync(batchDir, ["shared"]);
+  assert.deepEqual(stillIndexed, new Set(survivorPaths));
+});
+
+test("#1911B de-indexing N memories performs exactly one temporal + one tag write", async () => {
+  const batchDir = await mkdtemp(join(tmpdir(), "remnic-deindex-writes-batch-"));
+  const seqDir = await mkdtemp(join(tmpdir(), "remnic-deindex-writes-seq-"));
+  const entries = sampleMemories("writes", 8);
+  await seedIndex(batchDir, entries);
+  await seedIndex(seqDir, entries);
+
+  const countWrites = (dir: string) => {
+    let temporal = 0;
+    let tags = 0;
+    setIndexWriteObserverForTest((filePath) => {
+      // Scope to this directory so unrelated index writes never skew the count.
+      if (!filePath.startsWith(dir)) return;
+      if (filePath.endsWith("index_time.json")) temporal += 1;
+      else if (filePath.endsWith("index_tags.json")) tags += 1;
+    });
+    return () => {
+      setIndexWriteObserverForTest(undefined);
+      return { temporal, tags };
+    };
+  };
+
+  // try/finally guarantees the global observer is cleared even if an awaited
+  // op throws, so it can never leak into a later test.
+  let batchWrites = { temporal: 0, tags: 0 };
+  const stopBatch = countWrites(batchDir);
+  try {
+    await deindexMemoriesBatchAsync(batchDir, entries);
+  } finally {
+    batchWrites = stopBatch();
+  }
+  assert.deepEqual(batchWrites, { temporal: 1, tags: 1 });
+
+  let seqWrites = { temporal: 0, tags: 0 };
+  const stopSeq = countWrites(seqDir);
+  try {
+    for (const e of entries) {
+      await deindexMemory(seqDir, e.path, e.createdAt, e.tags);
+    }
+  } finally {
+    seqWrites = stopSeq();
+  }
+  // The per-memory path is the O(N) amplification this batch API replaces.
+  assert.deepEqual(seqWrites, { temporal: entries.length, tags: entries.length });
+});
+
+test("#1911B empty batch is a no-op that performs no writes", async () => {
+  const memoryDir = await mkdtemp(join(tmpdir(), "remnic-deindex-empty-"));
+  await seedIndex(memoryDir, sampleMemories("empty", 2));
+  let writes = 0;
+  setIndexWriteObserverForTest(() => {
+    writes += 1;
+  });
+  try {
+    await deindexMemoriesBatchAsync(memoryDir, []);
+  } finally {
+    setIndexWriteObserverForTest(undefined);
+  }
+  assert.equal(writes, 0);
+});
+
+test("#1911B batch de-index keeps tag index consistent when the temporal write fails", async () => {
+  const memoryDir = await mkdtemp(join(tmpdir(), "remnic-deindex-partialfail-"));
+  const entries = sampleMemories("partial", 4);
+  await seedIndex(memoryDir, entries);
+  const before = await readRawIndexes(memoryDir);
+
+  // Deterministically fail the temporal write via the test-only hook. chmod is a
+  // no-op for privileged users (common in CI) and differs on Windows; the hook
+  // fails the same branch in every environment. Temporal fails first, so the tag
+  // half is skipped, leaving BOTH indexes at their pre-batch contents.
+  setIndexWriteFailureForTest((filePath) => filePath.endsWith("index_time.json"));
+  try {
+    await deindexMemoriesBatchAsync(memoryDir, entries);
+  } finally {
+    setIndexWriteFailureForTest(undefined);
+  }
+
+  const after = await readRawIndexes(memoryDir);
+  assert.deepEqual(after.temporal, before.temporal);
+  assert.deepEqual(after.tags, before.tags);
+});
+
+test("#1911B a throwing write observer cannot fail a committed index write", async () => {
+  const throwDir = await mkdtemp(join(tmpdir(), "remnic-deindex-observer-throw-"));
+  const controlDir = await mkdtemp(join(tmpdir(), "remnic-deindex-observer-control-"));
+  const entries = sampleMemories("obsthrow", 3);
+  await seedIndex(throwDir, entries);
+  await seedIndex(controlDir, entries);
+
+  // Control: a clean batch de-index with no observer installed.
+  await deindexMemoriesBatchAsync(controlDir, entries);
+
+  // Same batch, but the committed-write observer throws. The exception fires
+  // only after the temporal rename has committed; if it escaped, the write would
+  // retry and ultimately report failure, skipping the paired tag phase and
+  // leaving a half-applied index. Isolation must keep the outcome identical to
+  // the control on BOTH indexes.
+  const observedWrites: string[] = [];
+  setIndexWriteObserverForTest((filePath) => {
+    // Scope to this directory so a concurrent test's index write never counts.
+    if (filePath.startsWith(throwDir)) observedWrites.push(filePath);
+    throw new Error("observer boom");
+  });
+  try {
+    await deindexMemoriesBatchAsync(throwDir, entries);
+  } finally {
+    setIndexWriteObserverForTest(undefined);
+  }
+
+  // The observer must have fired once per committed index write, in order:
+  // temporal commits first, then tags. This guards against a silent regression
+  // where observer dispatch is dropped and the isolation assertions below pass
+  // vacuously because nothing ever threw.
+  assert.equal(observedWrites.length, 2);
+  assert.ok(observedWrites[0]?.endsWith("index_time.json"));
+  assert.ok(observedWrites[1]?.endsWith("index_tags.json"));
+
+  const control = await readRawIndexes(controlDir);
+  const thrown = await readRawIndexes(throwDir);
+  assert.deepEqual(thrown.temporal, control.temporal);
+  assert.deepEqual(thrown.tags, control.tags);
+});

package/src/temporal-index.ts

@@ -32,6 +32,11 @@ export {
   indexesExist,
 } from "./temporal-index-compat.js";
 
+export {
+  deindexMemoriesBatchAsync,
+  indexMemoriesBatchAsync,
+} from "./temporal-index-batch.js";
+
 export interface TemporalIndex {
   /** version bumped when schema changes */
   version: number;
@@ -87,7 +92,7 @@ export interface TagNode {
   parents?: string[];
 }
 
-const INDEX_VERSION = 2;
+export const INDEX_VERSION = 2;
 const TEMPORAL_INDEX_FILE = "index_time.json";
 const TAG_INDEX_FILE = "index_tags.json";
 const TAG_INDEX_VERSION = 2;
@@ -130,6 +135,25 @@ export function setIndexReadObserverForTest(observer?: () => void): void {
   indexReadObserverForTest = observer;
 }
 
+let indexWriteObserverForTest: ((filePath: string) => void) | undefined;
+
+/** Test-only observer fired once per committed atomic index write. */
+export function setIndexWriteObserverForTest(observer?: (filePath: string) => void): void {
+  indexWriteObserverForTest = observer;
+}
+
+let indexWriteFailureForTest: ((filePath: string) => boolean) | undefined;
+
+/**
+ * Test-only hook to deterministically fail an atomic index write for matching
+ * paths. Return true to fail the write for a given path. Lets partial-failure
+ * branches be exercised without relying on filesystem permissions, which no-op
+ * for privileged users (common in containerized CI) and differ on Windows.
+ */
+export function setIndexWriteFailureForTest(shouldFail?: (filePath: string) => boolean): void {
+  indexWriteFailureForTest = shouldFail;
+}
+
 interface IndexLockOwner {
   pid: number;
   createdAt?: string;
@@ -150,7 +174,7 @@ function tagIndexPath(memoryDir: string): string {
   return path.join(stateDir(memoryDir), TAG_INDEX_FILE);
 }
 
-async function ensureStateDir(memoryDir: string): Promise<void> {
+export async function ensureStateDir(memoryDir: string): Promise<void> {
   await fs.promises.mkdir(stateDir(memoryDir), { recursive: true });
 }
 
@@ -222,7 +246,7 @@ function withPathMutex<T>(filePath: string, update: () => Promise<T>): Promise<T
  * per-file writes and commit mismatched halves. The inner per-file writeChains
  * still protect each file; this outer chain just orders complete operations.
  */
-function withMemoryDirMutex<T>(memoryDir: string, op: () => Promise<T>): Promise<T> {
+export function withMemoryDirMutex<T>(memoryDir: string, op: () => Promise<T>): Promise<T> {
   const previous = opChains.get(memoryDir) ?? Promise.resolve();
   const run = previous.then(op, op);
   const tail = run.then(() => undefined, () => undefined);
@@ -413,8 +437,20 @@ async function writeJsonAtomic(filePath: string, data: unknown): Promise<boolean
   for (let attempt = 0; attempt < 3; attempt += 1) {
     const tmp = uniqueTempPath(filePath);
     try {
+      if (indexWriteFailureForTest?.(filePath)) {
+        throw new Error("injected atomic-write failure (test)");
+      }
       await fs.promises.writeFile(tmp, payload, "utf8");
       await fs.promises.rename(tmp, filePath);
+      // The observer fires only after the committed rename. Isolate its
+      // exceptions so a test hook can never turn a successful write into a
+      // retry or a false (failed) result, which would clear the cache and
+      // skip the paired tag-index phase.
+      try {
+        indexWriteObserverForTest?.(filePath);
+      } catch {
+        // Test hooks must not alter committed index-write results.
+      }
       return true;
     } catch {
       try {
@@ -453,7 +489,7 @@ function hasCurrentTemporalIndexSchema(raw: unknown): boolean {
     isRecord(raw.events);
 }
 
-async function updateTemporalIndex(memoryDir: string, update: (index: TemporalIndex) => void): Promise<boolean> {
+export async function updateTemporalIndex(memoryDir: string, update: (index: TemporalIndex) => void): Promise<boolean> {
   const indexPath = temporalIndexPath(memoryDir);
   return withPathMutex(indexPath, async () => {
     const ok = await withIndexFileLock(indexPath, async () => {
@@ -475,7 +511,7 @@ async function updateTemporalIndex(memoryDir: string, update: (index: TemporalIn
   });
 }
 
-async function updateTagIndex(memoryDir: string, update: (index: TagIndex) => void): Promise<void> {
+export async function updateTagIndex(memoryDir: string, update: (index: TagIndex) => void): Promise<void> {
   const indexPath = tagIndexPath(memoryDir);
   await withPathMutex(indexPath, async () => {
     await withIndexFileLock(indexPath, async () => {
@@ -499,7 +535,7 @@ async function updateTagIndex(memoryDir: string, update: (index: TagIndex) => vo
   });
 }
 
-function isoDateFromTimestamp(isoString: string): string {
+export function isoDateFromTimestamp(isoString: string): string {
   if (typeof isoString !== "string" || isoString.length < 10) {
     // Malformed frontmatter — fall back to today so the memory is still indexed.
     // Log a warning to surface data-quality issues without aborting the write.
@@ -520,7 +556,7 @@ function normalizedIsoTimestamp(value: string | undefined): string | undefined {
   }
 }
 
-function temporalEventFromEntry(entry: TemporalIndexEntry): TemporalIndexEvent {
+export function temporalEventFromEntry(entry: TemporalIndexEntry): TemporalIndexEvent {
   const createdAt = normalizedIsoTimestamp(entry.createdAt) ?? new Date(0).toISOString();
   const eventAt = normalizedIsoTimestamp(entry.validAt) ?? createdAt;
   const observedAt = normalizedIsoTimestamp(entry.observedAt);
@@ -565,7 +601,7 @@ function compareTemporalIndexEvents(
   return left.path.localeCompare(right.path);
 }
 
-function addPathToSet(record: Record<string, string[]>, key: string, p: string): void {
+export function addPathToSet(record: Record<string, string[]>, key: string, p: string): void {
   if (!record[key]) {
     record[key] = [];
   }
@@ -574,7 +610,7 @@ function addPathToSet(record: Record<string, string[]>, key: string, p: string):
   }
 }
 
-function removePathFromSet(record: Record<string, string[]>, key: string, p: string): void {
+export function removePathFromSet(record: Record<string, string[]>, key: string, p: string): void {
   if (!record[key]) return;
   record[key] = record[key].filter((x) => x !== p);
   if (record[key].length === 0) {
@@ -582,7 +618,7 @@ function removePathFromSet(record: Record<string, string[]>, key: string, p: str
   }
 }
 
-function removePathFromAllSets(record: Record<string, string[]>, p: string): void {
+export function removePathFromAllSets(record: Record<string, string[]>, p: string): void {
   for (const key of Object.keys(record)) {
     removePathFromSet(record, key, p);
   }
@@ -736,7 +772,7 @@ function ensureTagNode(index: TagIndex, canonical: string): TagNode {
   return created;
 }
 
-function addTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void {
+export function addTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void {
   const canonical = normalizeCanonicalTag(rawTag);
   if (!canonical) return;
   const node = ensureTagNode(index, canonical);
@@ -757,7 +793,7 @@ function addTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string):
   }
 }
 
-function removeTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void {
+export function removeTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string): void {
   const canonical = normalizeCanonicalTag(rawTag);
   if (!canonical) return;
   const node = index.tags[canonical];
@@ -769,7 +805,7 @@ function removeTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string
   }
 }
 
-function removePathFromAllTagEntries(index: TagIndex, memoryPath: string): void {
+export function removePathFromAllTagEntries(index: TagIndex, memoryPath: string): void {
   for (const [canonical, nodeOrPaths] of Object.entries(index.tags)) {
     if (Array.isArray(nodeOrPaths)) {
       const paths = nodeOrPaths.filter((value) => value !== memoryPath);
@@ -1023,46 +1059,6 @@ export async function indexesExistAsync(memoryDir: string): Promise<boolean> {
   }
 }
 
-/**
- * Batch-add multiple memories to both indexes in a single read-modify-write cycle.
- * More efficient than calling indexMemoryAsync() per file when adding many at once.
- */
-export async function indexMemoriesBatchAsync(
-  memoryDir: string,
-  entries: TemporalIndexEntry[]
-): Promise<void> {
-  if (entries.length === 0) return;
-  try {
-    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 {
-    // Fail silently
-  }
-}
-
 /**
  * Return the set of memory paths whose index date falls in [fromDate, toDate).
  *