@remnic/core 9.7.14 → 9.8.0

package/src/orchestration/session-context.ts

@@ -322,6 +322,27 @@ export class SessionContextCoordinator {
       bufferKey?: string;
     },
   ): Promise<void> {
+    // Force any pending debounced buffer save to land durably BEFORE we read
+    // and (via clearBufferAfterExtraction below) clear turns (issue #1909, PR
+    // #2016). In steady-state buffering a `keep_buffering` turn only SCHEDULES a
+    // trailing-edge save (see SmartBuffer.scheduleSave), so the newest turns
+    // live only in memory behind an unref'd timer. This lifecycle drain
+    // (before_reset / session_end / explicit flush) queues extraction with
+    // clearBufferAfterExtraction; if that extraction fails or times out and the
+    // host then exits, the debounce timer never fires and those turns are lost.
+    // Flushing first makes the in-memory turns durable, so a failed or aborted
+    // extraction leaves them on disk for re-extraction on next startup.
+    // Durability-preserving AND fail-closed: pass throwOnFailure so a failed
+    // durable save stops this lifecycle drain BEFORE any extraction runs
+    // (issue #1909, PR #2016). flushPendingSave still retains the pending state
+    // and re-arms a background retry on write failure, but it now rethrows so
+    // flushSession rejects instead of clearing turns behind a non-durable save.
+    // Without this, a force-drain could queue extraction with
+    // clearBufferAfterExtraction on turns that never reached disk; if extraction
+    // then failed and the host exited, the turn was lost.
+    if (typeof this.deps.buffer.flushPendingSave === "function") {
+      await this.deps.buffer.flushPendingSave({ throwOnFailure: true });
+    }
     const explicitBufferKey =
       typeof options.bufferKey === "string" && options.bufferKey.length > 0
         ? options.bufferKey

package/src/orchestration/workspace-ops.test.ts

@@ -0,0 +1,348 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { WorkspaceOpsCoordinator, type WorkspaceOpsDeps } from "./workspace-ops.js";
+import type { AccessTrackingEntry, PluginConfig } from "../types.js";
+
+test("flushAccessTracking keeps duplicate memory IDs scoped by memory path", async () => {
+  const defaultPath = path.join("/memory", "namespaces", "default", "facts", "same-id.md");
+  const sharedPath = path.join("/memory", "namespaces", "shared", "facts", "same-id.md");
+  const memories = [
+    {
+      path: defaultPath,
+      frontmatter: { id: "same-id", accessCount: 2 },
+    },
+    {
+      path: sharedPath,
+      frontmatter: { id: "same-id", accessCount: 7 },
+    },
+  ];
+  const flushed = new Map<string, AccessTrackingEntry[]>();
+  const config = {
+    namespacesEnabled: true,
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer: new Map([
+      ["default:same-id", { memoryId: "same-id", memoryPath: defaultPath, count: 1, lastAccessed: "2026-07-19T00:00:00.000Z" }],
+      ["shared:same-id", { memoryId: "same-id", memoryPath: sharedPath, count: 1, lastAccessed: "2026-07-19T00:00:01.000Z" }],
+    ]),
+    readAllMemoriesForNamespaces: async () => memories,
+    namespaceFromPath: (memoryPath: string) => (memoryPath.includes(`${path.sep}shared${path.sep}`) ? "shared" : "default"),
+    storageRouter: {
+      storageFor: async (namespace: string) => ({
+        flushAccessTracking: async (entries: AccessTrackingEntry[]) => {
+          flushed.set(namespace, entries);
+        },
+      }),
+    },
+  } as unknown as WorkspaceOpsDeps);
+
+  await coordinator.flushAccessTracking();
+
+  assert.deepEqual(flushed.get("default"), [
+    {
+      memoryId: "same-id",
+      memoryPath: defaultPath,
+      newCount: 3,
+      lastAccessed: "2026-07-19T00:00:00.000Z",
+    },
+  ]);
+  assert.deepEqual(flushed.get("shared"), [
+    {
+      memoryId: "same-id",
+      memoryPath: sharedPath,
+      newCount: 8,
+      lastAccessed: "2026-07-19T00:00:01.000Z",
+    },
+  ]);
+});
+test("flushAccessTracking reads buffered namespaces outside configured policies", async () => {
+  const projectPath = path.join("/memory", "namespaces", "project-x", "facts", "same-id.md");
+  const memories = [{ path: projectPath, frontmatter: { id: "same-id", accessCount: 4 } }];
+  const readNamespaces: string[][] = [];
+  let flushed: AccessTrackingEntry[] = [];
+  const config = {
+    namespacesEnabled: true,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer: new Map([
+      [
+        "project-x:same-id",
+        {
+          memoryId: "same-id",
+          memoryPath: projectPath,
+          namespace: "project-x",
+          count: 1,
+          lastAccessed: "2026-07-19T00:00:00.000Z",
+        },
+      ],
+    ]),
+    readAllMemoriesForNamespaces: async (namespaces: string[]) => {
+      readNamespaces.push(namespaces);
+      return memories;
+    },
+    namespaceFromPath: (memoryPath: string) =>
+      memoryPath.includes(`${path.sep}project-x${path.sep}`) ? "project-x" : "default",
+    storageRouter: {
+      storageFor: async (namespace: string) => ({
+        flushAccessTracking: async (entries: AccessTrackingEntry[]) => {
+          if (namespace === "project-x") flushed = entries;
+        },
+      }),
+    },
+  } as unknown as WorkspaceOpsDeps);
+
+  await coordinator.flushAccessTracking();
+
+  assert.deepEqual(readNamespaces, [["default", "shared", "project-x"]]);
+  assert.deepEqual(flushed, [
+    {
+      memoryId: "same-id",
+      memoryPath: projectPath,
+      newCount: 5,
+      lastAccessed: "2026-07-19T00:00:00.000Z",
+    },
+  ]);
+});
+
+test("flushAccessTracking selects the buffered path within one namespace", async () => {
+  const firstPath = path.join("/memory", "facts", "first.md");
+  const secondPath = path.join("/memory", "facts", "second.md");
+  const memories = [
+    { path: secondPath, frontmatter: { id: "same-id", accessCount: 7 } },
+    { path: firstPath, frontmatter: { id: "same-id", accessCount: 2 } },
+  ];
+  let flushed: AccessTrackingEntry[] = [];
+  const config = {
+    namespacesEnabled: false,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer: new Map([
+      ["default:same-id", { memoryId: "same-id", memoryPath: "facts/first.md", count: 1, lastAccessed: "2026-07-19T00:00:00.000Z" }],
+    ]),
+    readAllMemoriesForNamespaces: async () => memories,
+    namespaceFromPath: () => "default",
+    storageRouter: {
+      storageFor: async () => ({
+        flushAccessTracking: async (entries: AccessTrackingEntry[]) => {
+          flushed = entries;
+        },
+      }),
+    },
+  } as unknown as WorkspaceOpsDeps);
+
+  await coordinator.flushAccessTracking();
+
+  assert.deepEqual(flushed, [
+    {
+      memoryId: "same-id",
+      memoryPath: firstPath,
+      newCount: 3,
+      lastAccessed: "2026-07-19T00:00:00.000Z",
+    },
+  ]);
+});
+
+test("flushAccessTracking resolves collection-prefixed QMD paths", async () => {
+  const memoryPath = path.join("/memory", "facts", "same-id.md");
+  const memories = [{ path: memoryPath, frontmatter: { id: "same-id", accessCount: 2 } }];
+  let flushed: AccessTrackingEntry[] = [];
+  const config = {
+    namespacesEnabled: false,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer: new Map([
+      [
+        "default:collection/facts/same-id.md",
+        {
+          memoryId: "same-id",
+          memoryPath: "collection/facts/same-id.md",
+          count: 1,
+          lastAccessed: "2026-07-19T00:00:00.000Z",
+        },
+      ],
+    ]),
+    readAllMemoriesForNamespaces: async () => memories,
+    namespaceFromPath: () => "default",
+    storageRouter: {
+      storageFor: async () => ({
+        dir: "/memory",
+        flushAccessTracking: async (entries: AccessTrackingEntry[]) => {
+          flushed = entries;
+        },
+      }),
+    },
+  } as unknown as WorkspaceOpsDeps);
+
+  await coordinator.flushAccessTracking();
+
+  assert.deepEqual(flushed, [
+    {
+      memoryId: "same-id",
+      memoryPath,
+      newCount: 3,
+      lastAccessed: "2026-07-19T00:00:00.000Z",
+    },
+  ]);
+});
+
+test("flushAccessTracking coalesces aliases for one memory", async () => {
+  const memoryPath = path.join("/memory", "facts", "same-id.md");
+  const memories = [{ path: memoryPath, frontmatter: { id: "same-id", accessCount: 2 } }];
+  let flushed: AccessTrackingEntry[] = [];
+  const config = {
+    namespacesEnabled: false,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+    sharedNamespace: "shared",
+    namespacePolicies: [],
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer: new Map([
+      [
+        "default:collection/facts/same-id.md",
+        {
+          memoryId: "same-id",
+          memoryPath: "collection/facts/same-id.md",
+          count: 1,
+          lastAccessed: "2026-07-19T00:00:01.000Z",
+        },
+      ],
+      [
+        "default:facts/same-id.md",
+        {
+          memoryId: "same-id",
+          memoryPath: "facts/same-id.md",
+          count: 1,
+          lastAccessed: "2026-07-19T00:00:00.000Z",
+        },
+      ],
+    ]),
+    readAllMemoriesForNamespaces: async () => memories,
+    namespaceFromPath: () => "default",
+    storageRouter: {
+      storageFor: async () => ({
+        dir: "/memory",
+        flushAccessTracking: async (entries: AccessTrackingEntry[]) => {
+          flushed = entries;
+        },
+      }),
+    },
+  } as unknown as WorkspaceOpsDeps);
+
+  await coordinator.flushAccessTracking();
+
+  assert.deepEqual(flushed, [
+    {
+      memoryId: "same-id",
+      memoryPath,
+      newCount: 4,
+      lastAccessed: "2026-07-19T00:00:01.000Z",
+    },
+  ]);
+});
+
+test("trackMemoryAccess keeps same-id accesses separate by path", () => {
+  const firstPath = path.join("/memory", "facts", "first", "same-id.md");
+  const secondPath = path.join("/memory", "facts", "second", "same-id.md");
+  const accessTrackingBuffer = new Map<string, AccessTrackingEntry & { count: number }>();
+  const config = {
+    accessTrackingEnabled: true,
+    accessTrackingBufferMaxSize: 100,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer,
+    namespaceFromPath: () => "default",
+  } as unknown as WorkspaceOpsDeps);
+
+  coordinator.trackMemoryAccess(["same-id", "same-id"], [firstPath, secondPath]);
+
+  assert.equal(accessTrackingBuffer.size, 2);
+  assert.deepEqual(
+    Array.from(accessTrackingBuffer.values()).map((entry) => ({
+      memoryId: entry.memoryId,
+      memoryPath: entry.memoryPath,
+      count: entry.count,
+    })),
+    [
+      { memoryId: "same-id", memoryPath: firstPath, count: 1 },
+      { memoryId: "same-id", memoryPath: secondPath, count: 1 },
+    ],
+  );
+});
+
+test("trackMemoryAccess coalesces absolute and relative paths for one file", () => {
+  const absolutePath = path.join("/memory", "facts", "same-id.md");
+  const relativePath = path.join("facts", "same-id.md");
+  const accessTrackingBuffer = new Map<string, AccessTrackingEntry & { count: number }>();
+  const config = {
+    accessTrackingEnabled: true,
+    accessTrackingBufferMaxSize: 100,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer,
+    namespaceFromPath: () => "default",
+  } as unknown as WorkspaceOpsDeps);
+
+  coordinator.trackMemoryAccess(["same-id", "same-id"], [absolutePath, relativePath]);
+
+  assert.equal(accessTrackingBuffer.size, 1);
+  assert.equal(Array.from(accessTrackingBuffer.values())[0]?.count, 2);
+});
+test("trackMemoryAccess preserves namespaces for relative paths", () => {
+  const accessTrackingBuffer = new Map<string, AccessTrackingEntry & { count: number }>();
+  const config = {
+    accessTrackingEnabled: true,
+    accessTrackingBufferMaxSize: 100,
+    memoryDir: "/memory",
+    defaultNamespace: "default",
+  } as unknown as PluginConfig;
+  const coordinator = new WorkspaceOpsCoordinator({
+    config,
+    accessTrackingBuffer,
+    namespaceFromPath: () => "default",
+  } as unknown as WorkspaceOpsDeps);
+
+  coordinator.trackMemoryAccess(
+    ["same-id", "same-id"],
+    ["facts/same-id.md", "facts/same-id.md"],
+    ["main", "shared"],
+  );
+
+  assert.deepEqual(
+    Array.from(accessTrackingBuffer.entries()).map(([key, entry]) => ({
+      key,
+      memoryPath: entry.memoryPath,
+    })),
+    [
+      { key: "main:/memory/facts/same-id.md", memoryPath: "facts/same-id.md" },
+      { key: "shared:/memory/facts/same-id.md", memoryPath: "facts/same-id.md" },
+    ],
+  );
+});

package/src/orchestration/workspace-ops.ts

@@ -17,7 +17,7 @@
 
 import { lstat, mkdir, readFile, readdir, realpath, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { resolveCompressionCapabilities, resolveConsolidationCapabilities, resolveNamespaceCapabilities } from "../capabilities.js";
+import { resolveCompressionCapabilities, resolveConsolidationCapabilities, resolveNamespaceCapabilities, resolveRecallEnhancementCapabilities } from "../capabilities.js";
 import { formatDaySummaryMemories } from "../day-summary.js";
 import { type JudgeVerdict, judgeFactDurability } from "../extraction-judge.js";
 import { ExtractionEngine } from "../extraction.js";
@@ -37,6 +37,7 @@ import { type AccessTrackingEntry, type MemoryActionEvent, type MemoryFile, type
 import { RECALL_FALLBACK_DIRS } from "../utils/category-dir.js";
 import { assertPathInsideRoot } from "../utils/path-containment.js";
 import { WearablesService } from "../wearables/service.js";
+import { qmdCollectionPathParts, qmdResultPathCandidates } from "./qmd-result-resolver.js";
 import {
   Orchestrator,
   filterHourlySummaryMarkdownForLocalDay,
@@ -48,7 +49,17 @@ import {
 } from "../orchestrator.js";
 
 export interface WorkspaceOpsDeps {
-  readonly accessTrackingBuffer: Map<string, { count: number; lastAccessed: string }>;
+  readonly accessTrackingBuffer: Map<
+    string,
+    {
+      memoryId: string;
+      memoryPath?: string;
+      namespace?: string;
+      count: number;
+      lastAccessed: string;
+    }
+  >;
+  trackRecallBackgroundWrite(promise: Promise<void>, label: string): void;
   bulkImportWriteNamespace(): string;
   readonly config: PluginConfig;
   readonly extraction: ExtractionEngine;
@@ -87,6 +98,26 @@ export interface WorkspaceOpsDeps {
   wearablesServiceInstance: WearablesService | null;
 }
 
+function matchesMemoryPath(candidatePath: string, requestedPath: string, memoryDir: string): boolean {
+  const normalizedCandidate = path.resolve(candidatePath);
+  return normalizedCandidate === path.resolve(requestedPath) || normalizedCandidate === path.resolve(memoryDir, requestedPath);
+}
+
+function accessTrackingPathCandidates(storageDir: string, memoryPath: string): string[] {
+  const candidates = qmdResultPathCandidates(storageDir, memoryPath);
+  const parts = qmdCollectionPathParts(memoryPath);
+  if (!parts) return candidates;
+
+  candidates.push(
+    ...qmdResultPathCandidates(storageDir, parts.relativePath),
+    ...qmdResultPathCandidates(path.join(storageDir, "cold"), parts.relativePath),
+  );
+  return [...new Set(candidates)];
+}
+
+function canonicalMemoryPath(memoryPath: string, memoryDir: string): string {
+  return path.resolve(path.isAbsolute(memoryPath) ? memoryPath : path.resolve(memoryDir, memoryPath));
+}
 export class WorkspaceOpsCoordinator {
   constructor(
     private readonly deps: WorkspaceOpsDeps,
@@ -646,6 +677,10 @@ export class WorkspaceOpsCoordinator {
           },
         },
         reindexSearch: async () => {
+          // qmd.update() clears the global QMD result caches itself on success
+          // (QmdClient.runUpdateForCollection), so newly-indexed wearable
+          // transcript/fact content is never hidden by a pre-sync cache entry
+          // (#1904, Codex).
           await this.deps.qmd.update();
         },
       });
@@ -738,6 +773,58 @@ export class WorkspaceOpsCoordinator {
       );
     }
   }
+  trackMemoryAccess(
+    memoryIds: string[],
+    memoryPaths: string[] = [],
+    memoryNamespaces: Array<string | undefined> = [],
+  ): void {
+    if (!resolveRecallEnhancementCapabilities(this.deps.config).accessTracking) return;
+
+    const now = new Date().toISOString();
+    const pathsByMemoryId = new Map<
+      string,
+      Array<{ path: string; namespace?: string }>
+    >();
+    for (const [index, memoryPath] of memoryPaths.entries()) {
+      const basename = memoryPath.split(/[\\/]/).pop() ?? memoryPath;
+      const memoryId = basename.endsWith(".md") ? basename.slice(0, -3) : basename;
+      if (memoryId.length > 0 && memoryIds.includes(memoryId)) {
+        const paths = pathsByMemoryId.get(memoryId) ?? [];
+        const namespace = memoryNamespaces[index];
+        paths.push({
+          path: memoryPath,
+          ...(namespace ? { namespace } : {}),
+        });
+        pathsByMemoryId.set(memoryId, paths);
+      }
+    }
+    for (const id of memoryIds) {
+      const references = pathsByMemoryId.get(id);
+      const reference = references?.shift();
+      const memoryPath = reference?.path;
+      const namespace = reference?.namespace ?? (
+        memoryPath
+          ? this.deps.namespaceFromPath(memoryPath)
+          : this.deps.config.defaultNamespace
+      );
+      const key = memoryPath
+        ? `${namespace}:${canonicalMemoryPath(memoryPath, this.deps.config.memoryDir)}`
+        : `${namespace}:${id}`;
+      const existing = this.deps.accessTrackingBuffer.get(key);
+      this.deps.accessTrackingBuffer.set(key, {
+        memoryId: id,
+        ...(memoryPath ? { memoryPath, namespace } : {}),
+        count: (existing?.count ?? 0) + 1,
+        lastAccessed: now,
+      });
+    }
+    if (this.deps.accessTrackingBuffer.size >= this.deps.config.accessTrackingBufferMaxSize) {
+      this.deps.trackRecallBackgroundWrite(
+        this.flushAccessTracking(),
+        "background access tracking flush",
+      );
+    }
+  }
 
   /**
    * Flush access tracking buffer to disk.
@@ -746,44 +833,95 @@ export class WorkspaceOpsCoordinator {
   async flushAccessTracking(): Promise<void> {
     if (this.deps.accessTrackingBuffer.size === 0) return;
 
-    // Build entries from buffer, merging with existing counts
-    const entries: AccessTrackingEntry[] = [];
-    const namespaces = resolveNamespaceCapabilities(this.deps.config).namespaces
-      ? Array.from(
-          new Set<string>([
-            this.deps.config.defaultNamespace,
-            this.deps.config.sharedNamespace,
-            ...this.deps.config.namespacePolicies.map((p) => p.name),
-          ]),
-        )
+    const bufferedNamespaces = new Set<string>();
+    for (const [, update] of this.deps.accessTrackingBuffer) {
+      bufferedNamespaces.add(
+        update.namespace ??
+          (update.memoryPath
+            ? this.deps.namespaceFromPath(update.memoryPath)
+            : this.deps.config.defaultNamespace),
+      );
+    }
+    const configuredNamespaces = resolveNamespaceCapabilities(this.deps.config).namespaces
+      ? [
+          this.deps.config.defaultNamespace,
+          this.deps.config.sharedNamespace,
+          ...this.deps.config.namespacePolicies.map((p) => p.name),
+        ]
       : [this.deps.config.defaultNamespace];
+    const namespaces = Array.from(new Set([...configuredNamespaces, ...bufferedNamespaces]));
+    const memoriesByNamespace = new Map<string, MemoryFile[]>();
     const memories = await this.deps.readAllMemoriesForNamespaces(namespaces);
-    const memoryMap = new Map(memories.map((m) => [m.frontmatter.id, m]));
-
-    for (const [memoryId, update] of this.deps.accessTrackingBuffer) {
-      const memory = memoryMap.get(memoryId);
-      const existingCount = memory?.frontmatter.accessCount ?? 0;
-      entries.push({
-        memoryId,
-        newCount: existingCount + update.count,
-        lastAccessed: update.lastAccessed,
-      });
+    for (const memory of memories) {
+      const namespace = this.deps.namespaceFromPath(memory.path);
+      const list = memoriesByNamespace.get(namespace) ?? [];
+      list.push(memory);
+      memoriesByNamespace.set(namespace, list);
     }
 
-    const byNamespace = new Map<string, AccessTrackingEntry[]>();
-    for (const e of entries) {
-      const m = memoryMap.get(e.memoryId);
-      if (!m) continue;
-      const ns = this.deps.namespaceFromPath(m.path);
-      const list = byNamespace.get(ns) ?? [];
-      list.push(e);
-      byNamespace.set(ns, list);
+    const entriesByNamespace = new Map<string, AccessTrackingEntry[]>();
+    const mergedEntriesByNamespace = new Map<string, Map<string, AccessTrackingEntry>>();
+    const storageDirByNamespace = new Map<string, string | null>();
+    for (const [, update] of this.deps.accessTrackingBuffer) {
+      const memoryPath = update.memoryPath;
+      const namespace =
+        update.namespace ??
+        (memoryPath
+          ? this.deps.namespaceFromPath(memoryPath)
+          : this.deps.config.defaultNamespace);
+      const namespaceMemories = memoriesByNamespace.get(namespace);
+      let storageDir = storageDirByNamespace.get(namespace);
+      if (storageDir === undefined) {
+        const storage = await this.deps.storageRouter.storageFor(namespace);
+        storageDir = typeof storage.dir === "string" && storage.dir.length > 0 ? storage.dir : null;
+        storageDirByNamespace.set(namespace, storageDir);
+      }
+      const requestedPaths = memoryPath
+        ? [
+            memoryPath,
+            ...(storageDir ? accessTrackingPathCandidates(storageDir, memoryPath) : []),
+          ]
+        : [];
+      const memory = memoryPath
+        ? namespaceMemories?.find((candidate) =>
+            matchesMemoryPath(candidate.path, memoryPath, this.deps.config.memoryDir),
+          ) ??
+          namespaceMemories?.find((candidate) =>
+            requestedPaths.some((requestedPath) =>
+              matchesMemoryPath(candidate.path, requestedPath, this.deps.config.memoryDir),
+            ),
+          )
+        : namespaceMemories?.find((candidate) => candidate.frontmatter.id === update.memoryId);
+      if (!memory) continue;
+
+      const namespaceEntries = mergedEntriesByNamespace.get(namespace) ?? new Map();
+      const existing = namespaceEntries.get(memory.path);
+      const existingLastAccessed = existing?.lastAccessed;
+      const lastAccessed =
+        existingLastAccessed &&
+        Date.parse(existingLastAccessed) > Date.parse(update.lastAccessed)
+          ? existingLastAccessed
+          : update.lastAccessed;
+      namespaceEntries.set(memory.path, {
+        memoryId: existing?.memoryId ?? update.memoryId,
+        memoryPath: memory.path,
+        newCount:
+          (existing?.newCount ?? (memory.frontmatter.accessCount ?? 0)) + update.count,
+        lastAccessed,
+      });
+      mergedEntriesByNamespace.set(namespace, namespaceEntries);
     }
-    for (const [ns, list] of byNamespace) {
-      const sm = await this.deps.storageRouter.storageFor(ns);
-      await sm.flushAccessTracking(list);
+    for (const [namespace, entries] of mergedEntriesByNamespace) {
+      entriesByNamespace.set(namespace, Array.from(entries.values()));
+    }
+
+    let flushedCount = 0;
+    for (const [namespace, entries] of entriesByNamespace) {
+      const storage = await this.deps.storageRouter.storageFor(namespace);
+      await storage.flushAccessTracking(entries);
+      flushedCount += entries.length;
     }
     this.deps.accessTrackingBuffer.clear();
-    log.debug(`flushed ${entries.length} access tracking entries`);
+    log.debug(`flushed ${flushedCount} access tracking entries`);
   }
 }