@remnic/core 9.63.6 → 9.63.8

package/src/orchestration/recall-internal.ts

@@ -622,7 +622,7 @@ export class RecallInternalCoordinator {
               qmdHybridFetchLimit,
             }),
             latencyMs: Date.now() - recallStart,
-            resultPaths: [],
+            includedMemories: [],
             policyVersion,
             appendImpression: this.deps.config.recordEmptyRecallImpressions,
             identityInjection: {
@@ -4944,14 +4944,14 @@ export class RecallInternalCoordinator {
     const assembledRecall = this.deps.assembleRecallSections(
       sectionBuckets, contextBudgetForFooter(recallBudgetChars, curiosityFooter),
     );
-    recalledMemoryIds = assembledRecall.includedMemoryIds;
-    recalledMemoryPaths = assembledRecall.includedMemoryPaths;
-    recalledMemoryNamespaces = assembledRecall.includedMemoryNamespaces;
-    recalledMemoryCount = assembledRecall.includedMemoryIds.length;
+    recalledMemoryIds = assembledRecall.includedMemories.map((memory) => memory.id);
+    recalledMemoryPaths = assembledRecall.includedMemories.map((memory) => memory.path);
+    recalledMemoryNamespaces = assembledRecall.includedMemories.map((memory) => memory.namespace);
+    recalledMemoryCount = assembledRecall.includedMemories.length;
     this.deps.trackMemoryAccess(
-      assembledRecall.includedMemoryIds,
-      assembledRecall.includedMemoryPaths,
-      assembledRecall.includedMemoryNamespaces,
+      recalledMemoryIds,
+      recalledMemoryPaths,
+      recalledMemoryNamespaces,
     );
     const recalledContext = assembledRecall.sections.join("\n\n---\n\n");
     const composition = boundRecallContextComposition({
@@ -4987,9 +4987,6 @@ export class RecallInternalCoordinator {
       truncated: assembledRecall.truncated || compositionTruncated || curiosityFooterTruncated,
       includedSections,
       omittedSections,
-      includedMemoryIds: assembledRecall.includedMemoryIds,
-      includedMemoryPaths: assembledRecall.includedMemoryPaths,
-      includedMemoryNamespaces: assembledRecall.includedMemoryNamespaces,
       omittedMemoryIds: assembledRecall.omittedMemoryIds,
     });
     // X-ray capture (issue #570 PR 1).  Only fires when the caller
@@ -5241,8 +5238,7 @@ export class RecallInternalCoordinator {
           sourcesUsed,
           budgetsApplied,
           latencyMs: Date.now() - recallStart,
-          resultPaths: recalledMemoryPaths,
-          resultNamespaces: recalledMemoryNamespaces,
+          includedMemories: assembledRecall.includedMemories,
           policyVersion,
           appendImpression:
             recalledMemoryIds.length > 0 ||

package/src/orchestration/recall-result-formatter-display-safe.test.ts

@@ -2,19 +2,17 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { displaySafeRecallSnapshot } from "./recall-result-formatter.js";
 
-test("displaySafeRecallSnapshot relativizes result, budget, and tier-anchor paths without mutating input (#2077)", () => {
+test("displaySafeRecallSnapshot relativizes included-memory and tier-anchor paths without mutating input (#2077)", () => {
   const memoryDir = "/srv/memory";
   const flatAbs = `${memoryDir}/facts/2026-07-19/b.md`;
   const nsResultAbs = `${memoryDir}/namespaces/tok-team/facts/2026-07-19/r.md`;
-  // An anchor that is NOT among the returned results — no authoritative owner.
+  // An anchor that is NOT among the included memories — no authoritative owner.
   const unmatchedAnchorAbs = `${memoryDir}/namespaces/ns-616c706861/facts/2026-07-19/a.md`;
   const snapshot = {
-    resultPaths: [flatAbs, nsResultAbs],
-    resultNamespaces: [undefined, "team-alpha"],
-    budgetsApplied: {
-      includedMemoryPaths: [flatAbs, nsResultAbs],
-      includedMemoryNamespaces: [undefined, "team-alpha"],
-    },
+    includedMemories: [
+      { id: "mem-b", path: flatAbs },
+      { id: "mem-r", path: nsResultAbs, namespace: "team-alpha" },
+    ],
     tierExplain: {
       tier: "direct-answer",
       tierReason: "single high-confidence hit",
@@ -31,21 +29,20 @@ test("displaySafeRecallSnapshot relativizes result, budget, and tier-anchor path
 
   const safe = displaySafeRecallSnapshot(snapshot, memoryDir);
 
-  assert.deepEqual(safe.resultPaths, ["facts/2026-07-19/b.md", "team-alpha/facts/2026-07-19/r.md"]);
-  assert.deepEqual(safe.budgetsApplied.includedMemoryPaths, [
-    "facts/2026-07-19/b.md",
-    "team-alpha/facts/2026-07-19/r.md",
+  assert.deepEqual(safe.includedMemories, [
+    { id: "mem-b", path: "facts/2026-07-19/b.md" },
+    { id: "mem-r", path: "team-alpha/facts/2026-07-19/r.md", namespace: "team-alpha" },
   ]);
   assert.deepEqual(safe.tierExplain.sourceAnchors, [
-    // Anchor coincides with a namespaced result → reuses its authoritative namespace.
+    // Anchor coincides with a namespaced included memory → reuses its authoritative namespace.
     { path: "team-alpha/facts/2026-07-19/r.md", lineRange: [1, 2] },
-    // Anchor not among the results → truthful storage-relative segment, never a decode.
+    // Anchor not among the included memories → truthful storage-relative segment, never a decode.
     { path: "namespaces/ns-616c706861/facts/2026-07-19/a.md" },
-    // Anchor coincides with a default-namespace result → memoryDir-relative.
+    // Anchor coincides with a default-namespace included memory → memoryDir-relative.
     { path: "facts/2026-07-19/b.md" },
   ]);
 
   // The input snapshot must not be mutated — the live cache keeps absolute paths.
   assert.equal(snapshot.tierExplain.sourceAnchors[0].path, nsResultAbs);
-  assert.equal(snapshot.resultPaths[1], nsResultAbs);
+  assert.equal(snapshot.includedMemories[1].path, nsResultAbs);
 });

package/src/orchestration/recall-result-formatter.ts

@@ -33,6 +33,7 @@ import type { WorkProductLedgerSearchResult } from "../work-product-ledger.js";
 import { trustResultFor, type TrustStageResultItem } from "../trust-score-stage.js";
 import { CONNECTOR_ID_PATTERN, CONNECTOR_LABEL_MAX_LENGTH } from "../connectors/label.js";
 import { isValidConnectorId } from "../connectors/index.js";
+import { coerceIncludedMemories, type IncludedMemory } from "../included-memories.js";
 import type {
   ContinuityIncidentRecord,
   IdentityInjectionMode,
@@ -112,43 +113,26 @@ export function displayResultPath(
     : resultPath;
 }
 
-/**
- * Return a copy of budget metadata with `includedMemoryPaths` rendered
- * memoryDir-relative, so recall/last-recall API callers never receive operator
- * filesystem paths via budget output even though the internal snapshot keeps
- * absolute paths for tracking/x-ray (#2020). Other fields are unchanged.
- */
-export function displaySafeBudgetsApplied<
-  T extends {
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
-  },
->(budgetsApplied: T | undefined, memoryDir: string): T | undefined {
-  if (!budgetsApplied?.includedMemoryPaths) return budgetsApplied;
-  return {
-    ...budgetsApplied,
-    includedMemoryPaths: budgetsApplied.includedMemoryPaths.map((p, i) =>
-      displayResultPath(p, memoryDir, budgetsApplied.includedMemoryNamespaces?.[i]),
-    ),
-  };
-}
-
 /**
  * Return a display-safe copy of a recall snapshot for the `includeDebug=true`
- * surface (#2077). `resultPaths` and `budgetsApplied.includedMemoryPaths` are
- * rendered namespace-relative from their aligned namespace metadata; a
- * `tierExplain.sourceAnchors[]` entry reuses that SAME authoritative metadata
- * when its absolute path matches a result/included path, and otherwise falls
- * back to the memoryDir-relative on-disk form. Either way the debug flag never
- * leaks absolute operator paths, and an anchor is never attributed to a decoded
- * (guessed) namespace — an anchor carries no owner of its own. Returns a
- * shallow copy; the input snapshot is never mutated.
+ * surface (#2077). `includedMemories[].path` is rendered namespace-relative
+ * from each memory's own namespace — the same rendering `resultPaths` received
+ * before the struct consolidation; a `tierExplain.sourceAnchors[]` entry
+ * reuses that SAME authoritative metadata when its absolute path matches an
+ * included memory's path, and otherwise falls back to the memoryDir-relative
+ * on-disk form. Either way the debug flag never leaks absolute operator
+ * paths, and an anchor is never attributed to a decoded (guessed) namespace —
+ * an anchor carries no owner of its own. Returns a shallow copy; the input
+ * snapshot is never mutated.
  */
 export function displaySafeRecallSnapshot<
   T extends {
+    includedMemories?: IncludedMemory[];
+    memoryIds?: string[];
     resultPaths?: string[];
     resultNamespaces?: Array<string | undefined>;
     budgetsApplied?: {
+      includedMemoryIds?: string[];
       includedMemoryPaths?: string[];
       includedMemoryNamespaces?: Array<string | undefined>;
     };
@@ -157,21 +141,14 @@ export function displaySafeRecallSnapshot<
     };
   },
 >(snapshot: T, memoryDir: string): T {
-  const resultPaths = snapshot.resultPaths?.map((p, i) =>
-    displayResultPath(p, memoryDir, snapshot.resultNamespaces?.[i]),
-  );
-  // Authoritative absolute-path -> namespace map recorded at capture time, so a
-  // tier anchor that coincides with a returned result renders under the SAME
-  // namespace as that result instead of the raw storage segment (#2077).
+  const includedMemories = coerceIncludedMemories(snapshot).map((memory) => ({
+    ...memory,
+    path: displayResultPath(memory.path, memoryDir, memory.namespace),
+  }));
   const namespaceByPath = new Map<string, string | undefined>();
-  snapshot.resultPaths?.forEach((p, i) => {
-    if (!namespaceByPath.has(p)) namespaceByPath.set(p, snapshot.resultNamespaces?.[i]);
-  });
-  snapshot.budgetsApplied?.includedMemoryPaths?.forEach((p, i) => {
-    if (!namespaceByPath.has(p)) {
-      namespaceByPath.set(p, snapshot.budgetsApplied?.includedMemoryNamespaces?.[i]);
-    }
-  });
+  for (const memory of coerceIncludedMemories(snapshot)) {
+    if (!namespaceByPath.has(memory.path)) namespaceByPath.set(memory.path, memory.namespace);
+  }
   const tierExplain =
     snapshot.tierExplain?.sourceAnchors
       ? {
@@ -182,11 +159,21 @@ export function displaySafeRecallSnapshot<
           })),
         }
       : undefined;
+  const resultPaths = includedMemories.map((memory) => memory.path);
+  const resultNamespaces = includedMemories.map((memory) => memory.namespace);
   return {
     ...snapshot,
-    ...(resultPaths ? { resultPaths } : {}),
+    includedMemories,
+    resultPaths,
+    resultNamespaces,
     ...(snapshot.budgetsApplied
-      ? { budgetsApplied: displaySafeBudgetsApplied(snapshot.budgetsApplied, memoryDir) }
+      ? {
+          budgetsApplied: {
+            ...snapshot.budgetsApplied,
+            includedMemoryPaths: resultPaths,
+            includedMemoryNamespaces: resultNamespaces,
+          },
+        }
       : {}),
     ...(tierExplain ? { tierExplain } : {}),
   };

package/src/orchestration/recall-section-coordinator.ts

@@ -17,7 +17,7 @@
  * TierMigrationCoordinator accessor pattern.
  */
 
-import type { LastRecallBudgetSummary } from "../recall-state.js";
+import type { IncludedMemory, LastRecallBudgetSummary } from "../recall-state.js";
 import { estimateTokenCount } from "../token-estimate.js";
 import { graphemeUnits, truncateGraphemeSafe } from "../whitespace.js";
 import type { PluginConfig, RecallSectionConfig } from "../types.js";
@@ -273,6 +273,7 @@ export class RecallSectionCoordinator {
     omittedIds: string[];
     truncated: boolean;
     finalChars: number;
+    includedMemories: IncludedMemory[];
     includedMemoryIds: string[];
     includedMemoryPaths: string[];
     includedMemoryNamespaces: Array<string | undefined>;
@@ -340,6 +341,7 @@ export class RecallSectionCoordinator {
         omittedIds: orderedSections.map((entry) => entry.id),
         truncated: orderedSections.length > 0,
         finalChars: 0,
+        includedMemories: [],
         includedMemoryIds: [],
         includedMemoryPaths: [],
         includedMemoryNamespaces: [],
@@ -372,9 +374,7 @@ export class RecallSectionCoordinator {
         break;
       }
     }
-    const includedMemoryIds: string[] = [];
-    const includedMemoryPaths: string[] = [];
-    const includedMemoryNamespaces: Array<string | undefined> = [];
+    const includedMemories: IncludedMemory[] = [];
     let usedChars = 0;
     let usedTokens = 0;
     let truncated = false;
@@ -492,12 +492,12 @@ export class RecallSectionCoordinator {
               rendered = chunk.content;
               includedLeadingContent = false;
               includedAtomicCount = 1;
-              // Push id/path/namespace together so the parallel tracking arrays
-              // never misalign when a chunk carries only one of them (#2020).
               if (chunk.memoryId && chunk.memoryPath) {
-                includedMemoryIds.push(chunk.memoryId);
-                includedMemoryPaths.push(chunk.memoryPath);
-                includedMemoryNamespaces.push(chunk.memoryNamespace);
+                includedMemories.push(
+                  chunk.memoryNamespace
+                    ? { id: chunk.memoryId, path: chunk.memoryPath, namespace: chunk.memoryNamespace }
+                    : { id: chunk.memoryId, path: chunk.memoryPath },
+                );
               }
               continue;
             }
@@ -522,9 +522,11 @@ export class RecallSectionCoordinator {
           if (chunk.atomic) {
             includedAtomicCount += 1;
             if (chunk.memoryId && chunk.memoryPath) {
-              includedMemoryIds.push(chunk.memoryId);
-              includedMemoryPaths.push(chunk.memoryPath);
-              includedMemoryNamespaces.push(chunk.memoryNamespace);
+              includedMemories.push(
+                chunk.memoryNamespace
+                  ? { id: chunk.memoryId, path: chunk.memoryPath, namespace: chunk.memoryNamespace }
+                  : { id: chunk.memoryId, path: chunk.memoryPath },
+              );
             }
           } else {
             includedPostAtomicContent = true;
@@ -574,16 +576,14 @@ export class RecallSectionCoordinator {
       omittedIds,
       truncated,
       finalChars: usedChars,
-      includedMemoryIds,
-      includedMemoryPaths,
-      includedMemoryNamespaces,
+      includedMemories,
+      includedMemoryIds: includedMemories.map((memory) => memory.id),
+      includedMemoryPaths: includedMemories.map((memory) => memory.path),
+      includedMemoryNamespaces: includedMemories.map((memory) => memory.namespace),
       omittedMemoryIds: (() => {
-        // Key by (namespace, id): the same memory id can exist in more than one
-        // namespace, so an id-only subtraction would hide a budget-dropped copy
-        // when another namespace's copy was included (#2020).
         const includedKeys = new Set(
-          includedMemoryIds.map(
-            (id, i) => `${includedMemoryNamespaces[i] ?? ""}\u0000${id}`,
+          includedMemories.map(
+            (memory) => `${memory.namespace ?? ""}\u0000${memory.id}`,
           ),
         );
         return candidateMemoryChunks
@@ -604,9 +604,6 @@ export class RecallSectionCoordinator {
     finalContextChars?: number;
     truncated?: boolean;
     includedSections?: string[];
-    includedMemoryIds?: string[];
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
     omittedMemoryIds?: string[];
     omittedSections?: string[];
   }): LastRecallBudgetSummary {
@@ -619,9 +616,6 @@ export class RecallSectionCoordinator {
       qmdHybridFetchLimit: options.qmdHybridFetchLimit,
       finalContextChars: options.finalContextChars,
       truncated: options.truncated,
-      includedMemoryIds: [...(options.includedMemoryIds ?? [])],
-      includedMemoryPaths: [...(options.includedMemoryPaths ?? [])],
-      includedMemoryNamespaces: [...(options.includedMemoryNamespaces ?? [])],
       omittedMemoryIds: [...(options.omittedMemoryIds ?? [])],
       includedSections: [...(options.includedSections ?? [])],
       omittedSections: [...(options.omittedSections ?? [])],

package/src/orchestrator.ts

@@ -260,6 +260,7 @@ import { NegativeExampleStore } from "./negative.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
+  type IncludedMemory,
   type LastRecallBudgetSummary,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries,
@@ -2716,7 +2717,7 @@ export class Orchestrator {
     includedIds: string[];
     omittedIds: string[];
     truncated: boolean;
-    finalChars: number;
+    includedMemories: IncludedMemory[];
     includedMemoryIds: string[];
     includedMemoryPaths: string[];
     includedMemoryNamespaces: Array<string | undefined>;
@@ -3542,9 +3543,6 @@ export class Orchestrator {
     finalContextChars?: number;
     truncated?: boolean;
     includedSections?: string[];
-    includedMemoryIds?: string[];
-    includedMemoryPaths?: string[];
-    includedMemoryNamespaces?: Array<string | undefined>;
     omittedMemoryIds?: string[];
     omittedSections?: string[];
   }): LastRecallBudgetSummary {

package/src/recall-explain-renderer.test.ts

@@ -17,6 +17,10 @@ function legacySnapshot(
     queryHash: "deadbeef",
     queryLen: 21,
     memoryIds: ["mem-1", "mem-2"],
+    includedMemories: [
+      { id: "mem-1", path: "" },
+      { id: "mem-2", path: "" },
+    ],
     source: "hot_qmd",
     sourcesUsed: ["hot_qmd", "memories"],
     namespace: "workspace-a",

package/src/recall-state.test.ts

@@ -4,7 +4,7 @@ import { chmod, lstat, mkdir, mkdtemp, readFile, readdir, rm, stat, symlink, wri
 import os from "node:os";
 import path from "node:path";
 
-import { clampGraphRecallExpandedEntries, LastRecallStore } from "./recall-state.js";
+import { clampGraphRecallExpandedEntries, LastRecallStore, RecallHandleHistoryStore } from "./recall-state.js";
 import type { RecallTierExplain } from "./types.js";
 import { listContainedSpillFiles } from "./utils/path-containment.js";
 
@@ -83,19 +83,69 @@ test("LastRecallStore.record persists tierExplain and round-trips to JSON on dis
   assert.deepEqual(parsed["s1"]?.tierExplain, tierExplain);
 });
 
-test("LastRecallStore.record persists per-result namespaces", async () => {
+test("LastRecallStore.record shims legacy resultPaths/resultNamespaces into includedMemories", async () => {
   const { store } = await freshStore();
-  const resultNamespaces = ["main", "shared"] as Array<string | undefined>;
   await store.record({
     sessionKey: "s1",
     query: "namespaced recall",
     memoryIds: ["same-id", "same-id"],
     resultPaths: ["facts/same-id.md", "facts/same-id.md"],
-    resultNamespaces,
+    resultNamespaces: ["main", "shared"],
   });
   const snap = store.get("s1");
   assert.ok(snap);
-  assert.deepEqual(snap.resultNamespaces, resultNamespaces);
+  assert.deepEqual(snap.includedMemories, [
+    { id: "same-id", path: "facts/same-id.md", namespace: "main" },
+    { id: "same-id", path: "facts/same-id.md", namespace: "shared" },
+  ]);
+  assert.deepEqual(snap.memoryIds, ["same-id", "same-id"]);
+});
+
+// ── Legacy on-disk shapes hydrate to includedMemories (#2476) ─────────────
+
+test("LastRecallStore.load shims legacy last_recall.json shapes to includedMemories", async () => {
+  const { dir } = await freshStore();
+  const fixturePath = path.resolve(
+    import.meta.dirname,
+    "../../../tests/fixtures/last-recall-legacy-shape.json",
+  );
+  const fixture = JSON.parse(await readFile(fixturePath, "utf-8")) as Record<string, unknown>;
+
+  await mkdir(path.join(dir, "state"), { recursive: true });
+  await writeFile(
+    path.join(dir, "state", "last_recall.json"),
+    JSON.stringify(fixture),
+    "utf-8",
+  );
+  const store = new LastRecallStore(dir);
+  await store.load();
+
+  const full = store.get("legacy-full");
+  assert.ok(full);
+  assert.deepEqual(full.includedMemories, [
+    {
+      id: "fact-alpha",
+      path: "/memory-under-test/namespaces/team-alpha/facts/2026-08-01/fact-alpha.md",
+      namespace: "team-alpha",
+    },
+    { id: "fact-beta", path: "/memory-under-test/facts/2026-08-01/fact-beta.md" },
+    {
+      id: "fact-gamma",
+      path: "/memory-under-test/namespaces/team-alpha/facts/2026-08-01/fact-gamma.md",
+      namespace: "team-alpha",
+    },
+  ]);
+  assert.deepEqual(full.memoryIds, ["fact-alpha", "fact-beta", "fact-gamma"]);
+  assert.deepEqual(
+    full.resultPaths,
+    full.includedMemories?.map((memory) => memory.path),
+  );
+  assert.deepEqual(full.budgetsApplied?.omittedMemoryIds, ["fact-dropped"]);
+
+  const idsOnly = store.get("legacy-ids-only");
+  assert.ok(idsOnly);
+  assert.deepEqual(idsOnly.includedMemories, [{ id: "fact-delta", path: "" }]);
+  assert.deepEqual(idsOnly.memoryIds, ["fact-delta"]);
 });
 
 // ── Defensive copies isolate the stored snapshot from caller mutation ──────
@@ -1083,3 +1133,56 @@ test("LastRecallStore.drainPendingImpressions reports pendingDeferred when a spi
     await rm(dir, { recursive: true, force: true });
   }
 });
++
+test("LastRecallStore rejects unsafe session keys on every read/write path", async () => {
+  const { store, dir } = await freshStore();
+  for (const key of ["__proto__", "constructor", "prototype"]) {
+    await store.record({ sessionKey: key, query: "q", memoryIds: ["m-1"] });
+    assert.equal(store.get(key), null, `get(${key}) must not surface prototype junk`);
+  }
+  assert.equal(store.getMostRecent(), null);
+
+  await store.annotateTierExplain("__proto__", {
+    tier: "direct-answer",
+    tierReason: "",
+    filteredBy: [],
+    candidatesConsidered: 0,
+    latencyMs: 0,
+  });
+  assert.equal(store.get("__proto__"), null);
+  const persistedKeys = await readFile(path.join(dir, "state", "last_recall.json"), "utf-8")
+    .then((raw) => Object.keys(JSON.parse(raw) as object))
+    .catch(() => [] as string[]);
+  assert.deepEqual(persistedKeys, [], "no unsafe key persisted");
+});
+
+test("RecallHandleHistoryStore rejects unsafe session keys", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "engram-handle-history-"));
+  const store = new RecallHandleHistoryStore(dir);
+  await store.load();
+
+  await store.record("__proto__", ["m-1"]);
+  await store.record("constructor", ["m-2"]);
+  assert.deepEqual(store.recent("__proto__"), []);
+  assert.deepEqual(store.recent("constructor"), []);
+
+  await store.record("ok", ["m-3"]);
+  assert.deepEqual(store.recent("ok"), [["m-3"]]);
+  await rm(dir, { recursive: true, force: true });
+});
+
+test("RecallHandleHistoryStore.load drops unsafe and malformed entries from persisted state", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "engram-handle-history-"));
+  await mkdir(path.join(dir, "state"), { recursive: true });
+  // JSON.parse materializes "__proto__" as an OWN key; load must not adopt it.
+  const poisoned =
+    '{"__proto__": [{"at": "t", "ids": ["evil"]}], "bad": "not-an-array", "ok": [{"at": "t", "ids": ["m-1"]}]}';
+  await writeFile(path.join(dir, "state", "handle_history.json"), poisoned, "utf-8");
+
+  const store = new RecallHandleHistoryStore(dir);
+  await store.load();
+  assert.deepEqual(store.recent("__proto__"), []);
+  assert.deepEqual(store.recent("bad"), []);
+  assert.deepEqual(store.recent("ok"), [["m-1"]]);
+  await rm(dir, { recursive: true, force: true });
+});