hippo-memory 1.61.0 → 1.63.0

package/dist/api/dormant.js

@@ -63,7 +63,7 @@ export function restoreDormant(ctx, id) {
             writeEntryDbOnly(db, restored, { actor: ctx.actor.subject });
             deleteDormantRow(db, ctx.tenantId, id);
             // A restore is a labelled "forgot it, then needed it" event: the
-            // signal a learned lifecycle (ROADMAP LC3) trains on. Same transaction
+            // signal a learned lifecycle trains on. Same transaction
             // as the restore, so the label exists exactly when the restore does.
             appendAuditEvent(db, {
                 tenantId: ctx.tenantId,

package/dist/api/drill-down.d.ts

@@ -73,11 +73,11 @@ export type DrillDownOutcome = DrillDownResult | DrillDownFailure;
  * if the underlying DAG accidentally linked across scopes.
  *
  * Returns a discriminated `DrillDownOutcome`: `DrillDownResult` on success,
- * or `{failure: '...'}` for `not_found` (covers genuinely-missing AND wrong-
- * tenant, intentionally indistinguishable), `not_drillable` (id is a leaf
- * row), or `scope_blocked` (caller has no scope grant for the row's scope).
+ * or `{failure: '...'}` for `not_found` (covers genuinely-missing, wrong-
+ * tenant and scope-blocked, intentionally indistinguishable) or
+ * `not_drillable` (id is a leaf row).
  *
- * Pre-v1.6.4 returned null for all four cases. JS callers migrate via
+ * Pre-v1.6.4 returned null for all three cases. JS callers migrate via
  * `'failure' in result` checks; HTTP route maps `not_drillable` to 422.
  */
 export declare function drillDown(ctx: Context, summaryId: string, opts?: DrillDownOpts): DrillDownOutcome;

package/dist/api/drill-down.js

@@ -1,5 +1,7 @@
 // DAG drill-down from a summary to its children.
-import { readEntry, loadChildrenOf } from '../store/entry-reads.js';
+import { closeHippoDb } from '../db.js';
+import { openStore } from '../store/open.js';
+import { selectEntriesByIds, selectChildrenByParent } from '../store/entry-reads.js';
 import { estimateTokens } from '../token-ledger.js';
 import { passesScopeFilterForRecall } from '../recall-scope.js';
 /**
@@ -14,11 +16,11 @@ import { passesScopeFilterForRecall } from '../recall-scope.js';
  * if the underlying DAG accidentally linked across scopes.
  *
  * Returns a discriminated `DrillDownOutcome`: `DrillDownResult` on success,
- * or `{failure: '...'}` for `not_found` (covers genuinely-missing AND wrong-
- * tenant, intentionally indistinguishable), `not_drillable` (id is a leaf
- * row), or `scope_blocked` (caller has no scope grant for the row's scope).
+ * or `{failure: '...'}` for `not_found` (covers genuinely-missing, wrong-
+ * tenant and scope-blocked, intentionally indistinguishable) or
+ * `not_drillable` (id is a leaf row).
  *
- * Pre-v1.6.4 returned null for all four cases. JS callers migrate via
+ * Pre-v1.6.4 returned null for all three cases. JS callers migrate via
  * `'failure' in result` checks; HTTP route maps `not_drillable` to 422.
  */
 export function drillDown(ctx, summaryId, opts = {}) {
@@ -26,8 +28,17 @@ export function drillDown(ctx, summaryId, opts = {}) {
     // v0.30 / E5: depth defaults 1 (backward compat); hard cap 10 levels
     // prevents pathological deep trees. CLI/HTTP/MCP reject invalid values.
     const depth = Math.max(1, Math.min(Math.trunc(opts.depth ?? 1), 10));
-    const summary = readEntry(ctx.hippoRoot, summaryId, ctx.tenantId);
-    // No unscoped cross-tenant probe here — readEntry's null return covers
+    const db = openStore(ctx.hippoRoot);
+    try {
+        return drillDownOn(db, ctx, summaryId, depth, opts, limit);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+function drillDownOn(db, ctx, summaryId, depth, opts, limit) {
+    const summary = selectEntriesByIds(db, [summaryId], ctx.tenantId).get(summaryId) ?? null;
+    // No unscoped cross-tenant probe here: the tenant-scoped read's miss covers
     // both "doesn't exist" and "exists in another tenant" by design.
     // Distinguishing them via an unscoped lookup would leak existence to
     // unauthorised tenants. The two cases collapse into not_found.
@@ -42,21 +53,46 @@ export function drillDown(ctx, summaryId, opts = {}) {
         // already preventing. Match the HTTP behaviour at the API level.
         return { failure: 'not_found' };
     }
-    // v0.30 / E5: BFS walk levels 1..depth with visited-Set dedup. Defensive
-    // against shared-child data anomalies (dag_parent_id has no uniqueness
-    // constraint, so a misconfigured tree could double-emit at depth > 1).
-    // Each level uses loadChildrenOf which is tenant-scoped via ctx.tenantId.
+    const { collected, level0DirectCount } = collectDescendants(db, ctx.tenantId, summaryId, depth);
+    const summaryOut = {
+        id: summary.id,
+        content: summary.content,
+        // v0.30 / E5: the STORED direct-child count; the legacy fallback counts
+        // level-0 children, never the BFS-depth-N total (independent-review MED #4).
+        descendantCount: summary.descendant_count ?? level0DirectCount,
+        earliestAt: summary.earliest_at ?? null,
+        latestAt: summary.latest_at ?? null,
+    };
+    const all = collected.map((c) => ({
+        id: c.id,
+        content: c.content,
+        layer: c.layer,
+        dagLevel: c.dag_level ?? 0,
+        created: c.created,
+    }));
+    const { children, truncated } = capChildren(all, summaryOut, opts, limit);
+    return {
+        summary: summaryOut,
+        children,
+        // v0.30 / E5: totalChildren = BFS-collected count (depth-aware). For
+        // depth=1 this equals the eligible direct-children count (backward
+        // compat). For depth>1 it is the cumulative count across levels.
+        totalChildren: collected.length,
+        truncated,
+    };
+}
+// BFS with a visited set: dag_parent_id is not unique, so a misconfigured tree could emit a child twice past depth 1.
+// The level-0 count is kept apart so a legacy summary's descendantCount fallback counts direct children only.
+function collectDescendants(db, tenantId, summaryId, depth) {
     const collected = [];
     const visited = new Set([summaryId]);
     let frontier = [summaryId];
-    // independent-review MED #4 fold: track level-0 direct-children count
-    // separately so the descendantCount fallback (for legacy summaries with
-    // null descendant_count) reflects DIRECT children, not BFS-collected total.
     let level0DirectCount = 0;
     for (let level = 0; level < depth; level++) {
         const nextFrontier = [];
+        const kidsByParent = selectChildrenByParent(db, frontier, tenantId);
         for (const parentId of frontier) {
-            const kids = loadChildrenOf(ctx.hippoRoot, parentId, ctx.tenantId);
+            const kids = kidsByParent.get(parentId) ?? [];
             const eligibleKids = kids.filter((c) => passesScopeFilterForRecall(c.scope ?? null, undefined));
             for (const k of eligibleKids) {
                 if (visited.has(k.id))
@@ -72,23 +108,10 @@ export function drillDown(ctx, summaryId, opts = {}) {
             break;
         frontier = nextFrontier;
     }
-    const summaryOut = {
-        id: summary.id,
-        content: summary.content,
-        // v0.30 / E5: the STORED direct-child count; the legacy fallback counts
-        // level-0 children, never the BFS-depth-N total (independent-review MED #4).
-        descendantCount: summary.descendant_count ?? level0DirectCount,
-        earliestAt: summary.earliest_at ?? null,
-        latestAt: summary.latest_at ?? null,
-    };
-    const all = collected.map((c) => ({
-        id: c.id,
-        content: c.content,
-        layer: c.layer,
-        dagLevel: c.dag_level ?? 0,
-        created: c.created,
-    }));
-    // Apply global cumulative token budget + limit cap on collected.
+    return { collected, level0DirectCount };
+}
+/** Global cumulative token budget first, then the `limit` cap. */
+function capChildren(all, summaryOut, opts, limit) {
     let children = all;
     let truncated = false;
     if (opts.budget !== undefined) {
@@ -110,14 +133,6 @@ export function drillDown(ctx, summaryId, opts = {}) {
         children = children.slice(0, limit);
         truncated = true;
     }
-    return {
-        summary: summaryOut,
-        children,
-        // v0.30 / E5: totalChildren = BFS-collected count (depth-aware). For
-        // depth=1 this equals the eligible direct-children count (backward
-        // compat). For depth>1 it is the cumulative count across levels.
-        totalChildren: collected.length,
-        truncated,
-    };
+    return { children, truncated };
 }
 //# sourceMappingURL=drill-down.js.map

package/dist/api/outcome.d.ts

@@ -8,14 +8,13 @@ import type { Context } from './types.js';
  * op='outcome' tagged with ctx.actor.subject.
  *
  * Returns `{applied, appliedIds}`. `appliedIds` is the tenant-filtered subset
- * of input ids that actually had `applyOutcome` run on them (i.e. ids whose
- * `readEntry(..., ctx.tenantId)` resolved). Callers that surface the id list
+ * of input ids that actually had `applyOutcome` run on them (i.e. ids found
+ * in ctx.tenantId). Callers that surface the id list
  * over a multi-tenant boundary (HTTP /v1/outcome last-recall path, Python SDK)
  * MUST return `appliedIds` instead of the raw input list — otherwise the
- * non-applied (cross-tenant) ids leak to the caller. Added in v1.11.4 to
- * close that disclosure path on POST /v1/outcome.
+ * non-applied (cross-tenant) ids leak to the caller.
  *
- * `opts.traceId` (LC1, docs/plans/2026-08-02-lc1-recall-trace-persistence.md):
+ * `opts.traceId`:
  * OPTIONAL additive opt so a programmatic caller can link this outcome to
  * the recall_traces row it judges. NOT applied unconditionally — an SDK
  * caller passing explicit ids with no preceding CLI/context recall would
@@ -36,18 +35,14 @@ export declare function outcome(ctx: Context, ids: ReadonlyArray<string>, good:
  *
  * Reads `loadIndex(ctx.hippoRoot).last_retrieval_ids` (per-hippoRoot local
  * state; not tenant-scoped at the index layer) and forwards to `outcome()`,
- * which DOES tenant-filter via `readEntry(..., ctx.tenantId)`. Cross-tenant
+ * which DOES tenant-filter its read by `ctx.tenantId`. Cross-tenant
  * ids in `last_retrieval_ids` are silently skipped, matching the MCP
  * `hippo_outcome` semantics.
  *
- * **Tenant-safe response shape (v1.11.4 security fix):** the returned `ids`
+ * **Tenant-safe response shape:** the returned `ids`
  * field contains ONLY the tenant-filtered subset that actually had outcomes
- * applied (i.e. `appliedIds` from the inner `outcome()` call). Earlier
- * versions returned the raw `last_retrieval_ids` regardless of tenant, which
- * leaked cross-tenant memory IDs to the caller via POST /v1/outcome's
- * no-body last-recall response. The fix is at this helper so all callers
- * (CLI cmdOutcome, HTTP /v1/outcome, MCP `hippo_outcome` if added later)
- * inherit the tenant-safe contract.
+ * applied (i.e. `appliedIds` from the inner `outcome()` call). It lives in this
+ * helper so every caller (CLI, HTTP /v1/outcome, MCP) inherits the contract.
  *
  * Do NOT tighten `loadIndex` with `tenantId` inside this helper — doing so
  * would break the (correct) cross-tenant-silent-skip behavior covered by

package/dist/api/outcome.js

@@ -1,24 +1,27 @@
 // Outcome feedback on recalled memories.
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { writeEntry } from '../store/entry-writes.js';
-import { readEntry } from '../store/entry-reads.js';
+import { closeHippoDb } from '../db.js';
+import { openStore } from '../store/open.js';
+import { writeEntryOn } from '../store/entry-writes.js';
+import { selectEntriesByIds } from '../store/entry-reads.js';
 import { loadIndex } from '../store/index-and-stats.js';
 import { applyOutcome, CHURN_STALE_TAG } from '../memory.js';
 import { appendAuditEvent } from '../audit.js';
 import { recordTraceOutcome } from '../recall-trace.js';
 export function outcome(ctx, ids, good, opts) {
     const appliedIds = [];
-    const db = openHippoDb(ctx.hippoRoot);
+    const db = openStore(ctx.hippoRoot);
     try {
+        const live = selectEntriesByIds(db, ids, ctx.tenantId);
         for (const id of ids) {
-            const entry = readEntry(ctx.hippoRoot, id, ctx.tenantId);
+            const entry = live.get(id);
             if (!entry)
                 continue;
             let updated = applyOutcome(entry, good);
-            if (good && updated.tags.includes(CHURN_STALE_TAG)) { // FE2: a good outcome reconfirms the entry
+            if (good && updated.tags.includes(CHURN_STALE_TAG)) { // a good outcome reconfirms the entry
                 updated = { ...updated, tags: updated.tags.filter((t) => t !== CHURN_STALE_TAG) };
             }
-            writeEntry(ctx.hippoRoot, updated, { actor: ctx.actor.subject });
+            writeEntryOn(db, ctx.hippoRoot, updated, { actor: ctx.actor.subject });
+            live.set(id, updated); // a repeated id builds on its first outcome, as a fresh read would
             appendAuditEvent(db, {
                 tenantId: ctx.tenantId,
                 actor: ctx.actor.subject,
@@ -28,7 +31,7 @@ export function outcome(ctx, ids, good, opts) {
             });
             appliedIds.push(id);
         }
-        // LC1: link the outcome to its trace, recording only the ids actually
+        // Link the outcome to its trace, recording only the ids actually
         // credited (post tenant-filtering, matches appliedIds). Lives in its own
         // append-only table so audit_log pruning can never erase training data.
         if (opts?.traceId !== undefined && appliedIds.length > 0) {
@@ -50,15 +53,8 @@ export function outcomeForLastRecall(ctx, good) {
     const ids = idx.last_retrieval_ids;
     if (ids.length === 0)
         return { applied: 0, ids: [] };
-    // LC1 F1(d) structural fix (docs/plans/2026-08-02-lc1-recall-trace-persistence.md):
-    // read the trace id from the SAME `loadIndex` snapshot already in hand
-    // (idx.last_trace_id) — a single-snapshot read, not a second DB round
-    // trip via a now-deleted readLastTraceId helper. The value is already
-    // strict-parsed by buildIndexFromDb's parseLastTraceId (store.ts): every
-    // consumer gets a clean positive-integer string or null, never a garbage
-    // value that could reach outcome() and INSERT trace_id=0/NaN. null on a
-    // fresh store / pre-v40 flow / api.recall-only usage — outcome() skips
-    // linkage silently when traceId is undefined.
+    // Same `loadIndex` snapshot as the ids; buildIndexFromDb already strict-parses it to a
+    // positive-integer string or null, so no trace_id=0/NaN reaches outcome().
     const traceId = idx.last_trace_id !== null ? Number(idx.last_trace_id) : null;
     const { applied, appliedIds } = outcome(ctx, ids, good, traceId !== null ? { traceId } : undefined);
     return { applied, ids: appliedIds };

package/dist/api/promote.d.ts

@@ -8,8 +8,7 @@ import type { Context } from './types.js';
  *
  * Note: `promoteToGlobal` does not currently take a tenantId override — it
  * reads the entry from the local root via `readEntry` (no tenant filter) and
- * preserves the entry's existing tenantId on the global side. Task 4 may
- * tighten this once writeEntry/readEntry thread tenant context.
+ * preserves the entry's existing tenantId on the global side.
  */
 export interface PromoteResult {
     ok: true;
@@ -19,9 +18,8 @@ export interface PromoteResult {
 export declare function promote(ctx: Context, id: string): PromoteResult;
 /**
  * Replace an old memory with new content, chaining old.superseded_by = new.id.
- * Mirrors `cmdSupersede` in cli.ts (without flag-driven layer/tag/pin overrides
- * — A1 keeps the API minimal; the CLI handler will continue to handle those
- * flags and pass the resolved values once Task 4 lands).
+ * Mirrors `cmdSupersede` in cli.ts minus the flag-driven layer/tag/pin
+ * overrides: the CLI handler resolves those so the API stays minimal.
  */
 export interface SupersedeResult {
     ok: true;
@@ -34,13 +32,12 @@ export declare function supersede(ctx: Context, oldId: string, newContent: strin
  *
  * `archiveRawMemory` audits the operation internally (op='archive_raw') using the
  * row's own tenant_id. We DO NOT emit a second audit event here to avoid double-
- * emitting the archive_raw op (unlike Task 1 remember/forget where the underlying
- * helpers hardcode actor='cli'). Instead we pass `ctx.actor.subject` through as `who`,
+ * emitting the archive_raw op. Instead we pass `ctx.actor.subject` through as `who`,
  * and raw-archive.ts uses that for the audit row.
  */
 export interface ArchiveRawOpts {
     /**
-     * Connector idempotency hook (v0.39 commit 3). Runs inside the same
+     * Connector idempotency hook. Runs inside the same
      * SAVEPOINT as the archive — throwing rolls the archive back. Used by the
      * Slack deletion connector to mark the deletion event seen atomically.
      */

package/dist/api/promote.js

@@ -47,19 +47,7 @@ export function promote(ctx, id) {
     return { ok: true, sourceId: id, globalId: globalEntry.id };
 }
 export function supersede(ctx, oldId, newContent) {
-    // Read old (tenant-scoped). readEntry filters by tenantId, so a Bearer for
-    // tenant A on tenant B's id throws "Memory not found" here without any
-    // info leak.
-    const old = readEntry(ctx.hippoRoot, oldId, ctx.tenantId);
-    if (!old) {
-        throw new NotFoundError(`Memory not found: ${oldId}`);
-    }
-    // Guard: not already superseded. The CAS UPDATE below race-safely closes
-    // the window between this read and the write; this check just produces a
-    // clearer error in the common single-writer case.
-    if (old.superseded_by) {
-        throw new ConflictError(`Memory ${oldId} is already superseded by ${old.superseded_by}. Supersede that one instead.`);
-    }
+    const old = readSupersedable(ctx, oldId);
     const newEntry = createSuccessor(old, newContent, {
         tenantId: ctx.tenantId,
         baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
@@ -72,59 +60,7 @@ export function supersede(ctx, oldId, newContent) {
     // the old.superseded_by pointer.
     const db = openHippoDb(ctx.hippoRoot);
     try {
-        db.exec('BEGIN IMMEDIATE');
-        try {
-            // 1. CAS update: only succeed if old.superseded_by IS NULL AND the
-            //    row still belongs to ctx.tenantId. Tenant filter is belt-and-
-            //    braces with the readEntry above — it costs nothing and closes
-            //    a hypothetical window where ownership changes between read and
-            //    update.
-            const result = db.prepare(`
-        UPDATE memories
-        SET superseded_by = ?
-        WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL
-      `).run(newEntry.id, oldId, ctx.tenantId);
-            if ((result.changes ?? 0) === 0) {
-                db.exec('ROLLBACK');
-                throw new ConflictError(`Memory ${oldId} already superseded by another writer`);
-            }
-            // v0.30 / E2 — DAG live-coupling: OLD entry just transitioned to
-            // superseded. Its parent (if any) needs rebuild. Lands strictly
-            // between the rollback guard above and the writeEntryDbOnly(NEW)
-            // below so a failed CAS hits throw before this hook. The NEW
-            // entry's parent (typically same parent) is auto-marked by the
-            // writeEntryDbOnly hook (same parent → idempotent, audits once).
-            if (old.dag_parent_id) {
-                markSummaryDirtyInTx(db, old.dag_parent_id, ctx.tenantId, ctx.actor.subject);
-            }
-            // 2. Write new memory inside same tx via writeEntryDbOnly (DB-only
-            //    path). This emits its OWN 'remember' audit row for the new
-            //    memory inside the SAVEPOINT — atomic with the row INSERT.
-            writeEntryDbOnly(db, stampOriginProject(ctx.hippoRoot, newEntry), { actor: ctx.actor.subject });
-            // 3. User-facing 'supersede' audit row inside the same tx so the
-            //    chain pointer + audit trail commit atomically.
-            appendAuditEvent(db, {
-                tenantId: ctx.tenantId,
-                actor: ctx.actor.subject,
-                op: 'supersede',
-                targetId: oldId,
-                metadata: { newId: newEntry.id },
-            });
-            db.exec('COMMIT');
-        }
-        catch (err) {
-            try {
-                db.exec('ROLLBACK');
-            }
-            catch { /* already rolled back */ }
-            // AT1 (plan §3): refusal audit lands post-ROLLBACK, in a fresh
-            // implicit transaction the aborted outer one cannot claw back — then
-            // rethrow so the caller sees the refusal.
-            if (err instanceof RejectedValueError) {
-                auditRejectionRefusal(db, err, ctx.actor.subject);
-            }
-            throw err;
-        }
+        commitSupersede(db, ctx, oldId, old, newEntry);
         // Mirrors after COMMIT, while the db handle is still open. Same
         // invariant as the original writeEntry: a mirror failure leaves disk
         // MISSING the markdown for the new memory (rebuildIndex rewrites every
@@ -142,6 +78,59 @@ export function supersede(ctx, oldId, newContent) {
     }
     return { ok: true, oldId, newId: newEntry.id };
 }
+/** The tenant-scoped row to supersede; readEntry's tenant filter makes another tenant's id read as not found. */
+function readSupersedable(ctx, oldId) {
+    const old = readEntry(ctx.hippoRoot, oldId, ctx.tenantId);
+    if (!old) {
+        throw new NotFoundError(`Memory not found: ${oldId}`);
+    }
+    // The CAS UPDATE closes the race; this check only gives a clearer error in the common single-writer case.
+    if (old.superseded_by) {
+        throw new ConflictError(`Memory ${oldId} is already superseded by ${old.superseded_by}. Supersede that one instead.`);
+    }
+    return old;
+}
+/** CAS on the old row, the successor's insert and the 'supersede' audit row, in one BEGIN IMMEDIATE transaction. */
+function commitSupersede(db, ctx, oldId, old, newEntry) {
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        // The tenant filter repeats readEntry's check at no cost, closing an ownership change between read and update.
+        const result = db.prepare(`
+      UPDATE memories
+      SET superseded_by = ?
+      WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL
+    `).run(newEntry.id, oldId, ctx.tenantId);
+        if ((result.changes ?? 0) === 0) {
+            db.exec('ROLLBACK');
+            throw new ConflictError(`Memory ${oldId} already superseded by another writer`);
+        }
+        // After the CAS guard, so a lost race throws before the old parent is marked for rebuild.
+        if (old.dag_parent_id) {
+            markSummaryDirtyInTx(db, old.dag_parent_id, ctx.tenantId, ctx.actor.subject);
+        }
+        // Emits its own 'remember' audit row inside the same transaction.
+        writeEntryDbOnly(db, stampOriginProject(ctx.hippoRoot, newEntry), { actor: ctx.actor.subject });
+        appendAuditEvent(db, {
+            tenantId: ctx.tenantId,
+            actor: ctx.actor.subject,
+            op: 'supersede',
+            targetId: oldId,
+            metadata: { newId: newEntry.id },
+        });
+        db.exec('COMMIT');
+    }
+    catch (err) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { /* already rolled back */ }
+        // The refusal audit lands after ROLLBACK, in a fresh implicit transaction the aborted one cannot undo.
+        if (err instanceof RejectedValueError) {
+            auditRejectionRefusal(db, err, ctx.actor.subject);
+        }
+        throw err;
+    }
+}
 export function archiveRaw(ctx, id, reason, opts = {}) {
     const db = openHippoDb(ctx.hippoRoot);
     let mirrorOk = false;

package/dist/api/quarantine.js

@@ -2,7 +2,7 @@
 import { openHippoDb, closeHippoDb } from '../db.js';
 import { ConflictError, ForbiddenError, NotFoundError } from '../api-errors.js';
 import { writeEntryMirrors } from '../store/entry-writes.js';
-import { readEntry } from '../store/entry-reads.js';
+import { readEntry, selectEntriesByIds } from '../store/entry-reads.js';
 import { quarantineScopeFor, getQuarantineRow, listQuarantineRows, approveQuarantineRow, rejectQuarantineRow, } from '../quarantine.js';
 import { log } from '../log.js';
 import { appendAuditEvent } from '../audit.js';
@@ -12,8 +12,9 @@ export function quarantineList(ctx, opts = {}) {
     const db = openHippoDb(ctx.hippoRoot);
     try {
         const rows = listQuarantineRows(db, ctx.tenantId, opts.status ?? 'pending', opts.limit, opts.after);
+        const entries = selectEntriesByIds(db, rows.map((row) => row.memoryId), ctx.tenantId);
         return rows.map((row) => {
-            const entry = readEntry(ctx.hippoRoot, row.memoryId, ctx.tenantId);
+            const entry = entries.get(row.memoryId);
             return {
                 id: row.memoryId,
                 originalScope: row.originalScope,