hippo-memory 1.72.0 → 2.1.0

package/dist/consolidate/conflicts.js

@@ -3,7 +3,8 @@ import { jaccardMinShared, overlapPartners } from './overlap-index.js';
 import { isQuarantineScope } from '../trust/quarantine.js';
 import { isPersonalScope } from '../core/recall-scope.js';
 import { DECAY_THRESHOLD } from './decay.js';
-// Gate contradictions on content overlap, not shared tags (`feedback`/`policy` are too coarse). The Jaccard threshold on stopword-filtered tokens
+// Gate contradictions on content overlap, not shared tags (`feedback`/`policy` are too coarse). The Jaccard threshold
+// on stopword-filtered tokens
 // only applies after a polarity signal, so it filters drive-by topic similarity, not semantic drift.
 const CONFLICT_OVERLAP_THRESHOLD = 0.5;
 // Minimum distinctive shared tokens before we trust an overlap score. Filters
@@ -45,8 +46,9 @@ rescuedIds = new Set()) {
                 continue;
             if (!recalledTogether(survivors[i], survivors[j]))
                 continue;
-            if ([survivors[i], survivors[j]].some((e) => e.tags.includes('extracted') || e.tags.includes('session-digest')))
+            if ([survivors[i], survivors[j]].some((e) => e.tags.includes('extracted') || e.tags.includes('session-digest'))) {
                 continue;
+            }
             const reasonAndScore = describeConflict(profiles[i], profiles[j]);
             if (!reasonAndScore)
                 continue;
@@ -60,21 +62,29 @@ rescuedIds = new Set()) {
     }
     return detected;
 }
-/** One project's ambient context can show both: same tenant, and the same project or a user-global row beside a project's. */
+/**
+ * One project's ambient context can show both: same tenant, and the same project or a user-global row beside a
+ * project's.
+ */
 function recalledTogether(a, b) {
     // A personal row pairs only inside its own scope; any other pair shows its id to someone else.
     if ((isPersonalScope(a.scope) || isPersonalScope(b.scope)) && a.scope !== b.scope)
         return false;
-    if (a.tenantId !== b.tenantId)
+    if (a.tenant_id !== b.tenant_id)
         return false;
     const [x, y] = [a.origin_project ?? null, b.origin_project ?? null];
     return x === y || (x === '' && y !== null) || (y === '' && x !== null);
 }
 function conflictProfile(text) {
     const opening = openingWindow(text);
-    // Polarity is measured only in the first POLARITY_WINDOW_WORDS, so a stray negation deep in a prose memory doesn't flip the intent.
+    // Polarity is measured only in the first POLARITY_WINDOW_WORDS, so a stray negation deep in a prose memory doesn't
+    // flip the intent.
     // Pad with spaces so space-delimited patterns match words at the start/end.
-    return { distinct: distinctiveTokens(text), polarity: inferConflictPolarity(opening), window: ' ' + opening.toLowerCase() + ' ' };
+    return {
+        distinct: distinctiveTokens(text),
+        polarity: inferConflictPolarity(opening),
+        window: ' ' + opening.toLowerCase() + ' ',
+    };
 }
 function describeConflict(a, b) {
     // Jaccard on stopword-stripped tokens. Defer the threshold check until we
@@ -122,20 +132,24 @@ function openingWindow(text) {
 }
 // Takes opening windows only, so " on " and " off " as prepositions deep in long prose don't read as enabled/disabled.
 function classifyConflictType(a, b, aPolarity, bPolarity) {
-    // Whole-word boundaries so " on " alone doesn't match "on/off"; pair only `enabled` <-> `disabled` and explicit on/off in imperative context.
+    // Whole-word boundaries so " on " alone doesn't match "on/off"; pair only `enabled` <-> `disabled` and explicit
+    // on/off in imperative context.
     const enabledDisabled = (containsAny(a, [' enabled ', ' enable ']) && containsAny(b, [' disabled ', ' disable ']))
         || (containsAny(b, [' enabled ', ' enable ']) && containsAny(a, [' disabled ', ' disable ']));
     if (enabledDisabled)
         return 'enabled/disabled mismatch on overlapping statement';
-    const trueFalse = (containsAny(a, [' true ', ' true.', ' true,', ' yes ']) && containsAny(b, [' false ', ' false.', ' false,', ' no ']))
-        || (containsAny(b, [' true ', ' true.', ' true,', ' yes ']) && containsAny(a, [' false ', ' false.', ' false,', ' no ']));
+    const trueFalse = (containsAny(a, [' true ', ' true.', ' true,', ' yes ']) &&
+        containsAny(b, [' false ', ' false.', ' false,', ' no '])) ||
+        (containsAny(b, [' true ', ' true.', ' true,', ' yes ']) &&
+            containsAny(a, [' false ', ' false.', ' false,', ' no ']));
     if (trueFalse)
         return 'true/false mismatch on overlapping statement';
     const alwaysNever = (containsAny(a, [' always ', ' must ']) && containsAny(b, [' never ', ' must not ']))
         || (containsAny(b, [' always ', ' must ']) && containsAny(a, [' never ', ' must not ']));
     if (alwaysNever)
         return 'always/never mismatch on overlapping statement';
-    if ((aPolarity === 'positive' && bPolarity === 'negative') || (aPolarity === 'negative' && bPolarity === 'positive')) {
+    if ((aPolarity === 'positive' && bPolarity === 'negative') ||
+        (aPolarity === 'negative' && bPolarity === 'positive')) {
         return 'negation polarity mismatch on overlapping statement';
     }
     return null;

package/dist/consolidate/dag-summary.js

@@ -1,4 +1,5 @@
-// The one LLM call behind every DAG summary, kept apart from the graph writes so its request bytes are tested on their own.
+// The one LLM call behind every DAG summary, kept apart from the graph writes so its request bytes are tested on their
+// own.
 import { redactSecretsStrict } from '../util/secret-detect.js';
 import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
 import { certainDefect } from '../core/memory-quality.js';

package/dist/consolidate/dag.d.ts

@@ -1,5 +1,8 @@
 import { type MemoryEntry } from '../core/memory.js';
+import type { Consolidation, LocalFiles } from '../store/port.js';
 import { type DagSummaryOptions } from './dag-summary.js';
+/** Sleep's store, with the folder whose config sets a new summary's half-life. */
+type DagStore = Pick<LocalFiles, 'hippoRoot' | 'consolidation'>;
 export interface FactCluster {
     label: string;
     members: MemoryEntry[];
@@ -14,7 +17,7 @@ export interface DagBuildResult {
      *  guard-exempt (same id + content), so only summary-creation refusals count. */
     rejected: number;
 }
-export declare function buildDag(hippoRoot: string, facts: MemoryEntry[], opts: DagSummaryOptions): Promise<DagBuildResult>;
+export declare function buildDag(local: DagStore, facts: MemoryEntry[], opts: DagSummaryOptions): Promise<DagBuildResult>;
 export interface DagRebuildResult {
     attempted: number;
     rebuilt: number;
@@ -23,9 +26,10 @@ export interface DagRebuildResult {
     failed: number;
     capped: boolean;
 }
-/** Sleep-cycle phase draining the dirty L2 summary queue; one throwing rebuild does not abort the rest.
- * A concurrent sleep's second writer gets changed=false (UPDATE requires summary_dirty=1) and is skipped silently; a tombstone hit counts as `refused`. */
-export declare function rebuildDirtySummaries(hippoRoot: string, opts: DagSummaryOptions & {
+/** Sleep-cycle phase draining the dirty L2 summary queue; one throwing rebuild does not abort the rest. A concurrent
+ * sleep's second writer gets changed=false (UPDATE requires summary_dirty=1) and is skipped silently; a tombstone hit
+ * counts as `refused`. */
+export declare function rebuildDirtySummaries(store: Consolidation, opts: DagSummaryOptions & {
     cap?: number;
 }): Promise<DagRebuildResult>;
 export interface EntityProfilesBuildResult {
@@ -39,5 +43,6 @@ export interface EntityProfilesBuildResult {
 }
 /** Build L3 entity profiles by clustering L2 summaries sharing entity tags (2+ L2s per entity).
  * Each L2 link write marks the new L3 dirty, so clear it or the same cycle re-rebuilds it. */
-export declare function buildEntityProfiles(hippoRoot: string, l2Summaries: MemoryEntry[], opts: DagSummaryOptions): Promise<EntityProfilesBuildResult>;
+export declare function buildEntityProfiles(local: DagStore, l2Summaries: MemoryEntry[], opts: DagSummaryOptions): Promise<EntityProfilesBuildResult>;
+export {};
 //# sourceMappingURL=dag.d.ts.map

package/dist/consolidate/dag.js

@@ -1,6 +1,4 @@
 import { createMemory, Layer } from '../core/memory.js';
-import { writeEntry, writeEntriesTogether } from '../store/entry-writes.js';
-import { loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildResult, clearSummaryDirtyAfterBuild, } from '../store/summaries.js';
 import { RejectedValueError } from '../core/api-errors.js';
 import { generateDagSummary } from './dag-summary.js';
 import { overlapPartners } from './overlap-index.js';
@@ -17,7 +15,8 @@ export function clusterFacts(facts) {
         return [];
     const entityTags = facts.map((f) => f.tags.filter((t) => t.startsWith('speaker:') || t.startsWith('topic:')));
     const tagSets = entityTags.map((tags) => new Set(tags));
-    // Every tag indexed, not a prefix: a repeated tag counts twice in `shared`, so the prefix-filter bound would not hold.
+    // Every tag indexed, not a prefix: a repeated tag counts twice in `shared`, so the prefix-filter bound would not
+    // hold.
     const partnersOf = overlapPartners(tagSets, () => 1);
     const assigned = new Set();
     const clusters = [];
@@ -45,12 +44,12 @@ export function clusterFacts(facts) {
     }
     return clusters;
 }
-// Partition before clustering so one LLM summary never mixes tenants; Map keeps insertion order, so a single-tenant store iterates as before.
-// buildEntityProfiles partitions its L2s with this same key.
+// Partition before clustering so one LLM summary never mixes tenants; Map keeps insertion order, so a single-tenant
+// store iterates as before. buildEntityProfiles partitions its L2s with this same key.
 function partitionFactsByTenant(unparented) {
     const unparentedByTenant = new Map();
     for (const fact of unparented) {
-        const key = derivationPartitionKey(fact.tenantId, fact.scope, fact.origin_project);
+        const key = derivationPartitionKey(fact.tenant_id, fact.scope, fact.origin_project);
         const bucket = unparentedByTenant.get(key);
         if (bucket)
             bucket.push(fact);
@@ -62,12 +61,13 @@ function partitionFactsByTenant(unparented) {
 /** The L2 summary entry for one cluster, landing in the facts' own tenant and scope. */
 function createClusterSummaryEntry(summary, cluster, home) {
     const memberCreatedAts = cluster.members.map((m) => m.created).sort();
-    // Every cluster member shares home.tenantId (tenant partition above), so the summary lands in the facts' tenant, not 'default'.
+    // Every cluster member shares home.tenantId (tenant partition above), so the summary lands in the facts' tenant,
+    // not 'default'.
     const summaryEntry = createMemory(summary, {
         layer: Layer.Semantic,
         tags: [...cluster.entityTags, ...neverAutoShareTags(cluster.members), 'dag-summary'],
         confidence: 'inferred',
-        dag_level: 2,
+        dagLevel: 2,
         tenantId: home.tenantId,
         scope: home.scope,
         baseHalfLifeDays: home.baseHalfLifeDays,
@@ -81,7 +81,7 @@ function createClusterSummaryEntry(summary, cluster, home) {
     return summaryEntry;
 }
 /** Summarize one eligible cluster, write the summary, then re-parent its members under it. */
-async function summarizeCluster(hippoRoot, cluster, home, opts, result) {
+async function summarizeCluster(store, cluster, home, opts, result) {
     const summary = await generateDagSummary(cluster.label, cluster.members.map((m) => m.content), opts);
     if (!summary)
         return;
@@ -89,29 +89,29 @@ async function summarizeCluster(hippoRoot, cluster, home, opts, result) {
     // A refused summary skips only this cluster. writeEntry's guard reads tenantId off the entry
     // (home.tenantId), so it already checks this tenant's tombstones: no separate check here.
     try {
-        writeEntry(hippoRoot, summaryEntry);
+        store.writeEntry(summaryEntry);
     }
     catch (err) {
         if (err instanceof RejectedValueError) {
             result.rejected++;
-            log.warn(`buildDag: cluster "${cluster.label}" skipped: summary matches a rejected value`);
+            log.warn(`buildDag: cluster "${cluster.label}" skipped: summary matches a rejected value`, errorFields(err));
             return;
         }
         throw err;
     }
     result.summariesCreated++;
-    result.factsLinked += writeEntriesTogether(hippoRoot, cluster.members.map((member) => ({ ...member, dag_parent_id: summaryEntry.id })));
+    result.factsLinked += store.writeTogether(cluster.members.map((member) => ({ ...member, dag_parent_id: summaryEntry.id })));
     // Member writes just marked this fresh summary dirty; clear it, or the same sleep cycle's
     // rebuild pass would re-rebuild every new summary at twice the LLM cost.
-    clearSummaryDirtyAfterBuild(hippoRoot, summaryEntry.id, summaryEntry.tenantId, 'buildDag');
+    store.clearSummaryDirty(summaryEntry.id, summaryEntry.tenant_id, 'buildDag');
 }
-export async function buildDag(hippoRoot, facts, opts) {
+export async function buildDag(local, facts, opts) {
     const result = { candidateClusters: 0, summariesCreated: 0, factsLinked: 0, rejected: 0 };
-    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    const baseHalfLifeDays = loadConfig(local.hippoRoot).defaultHalfLifeDays;
     const unparented = facts.filter((f) => f.dag_level === 1 && !f.dag_parent_id && f.tags.includes('extracted'));
     for (const [, tenantFacts] of partitionFactsByTenant(unparented)) {
         const home = {
-            tenantId: tenantFacts[0].tenantId,
+            tenantId: tenantFacts[0].tenant_id,
             scope: derivationScope(tenantFacts[0].scope),
             originProject: tenantFacts[0].origin_project,
             baseHalfLifeDays,
@@ -120,16 +120,19 @@ export async function buildDag(hippoRoot, facts, opts) {
         const eligibleClusters = clusters.filter((c) => c.members.length >= 3);
         result.candidateClusters += eligibleClusters.length;
         for (const cluster of eligibleClusters) {
-            await summarizeCluster(hippoRoot, cluster, home, opts, result);
+            await summarizeCluster(local.consolidation, cluster, home, opts, result);
         }
     }
     return result;
 }
 /** Regenerate one dirty summary from its children and tally the outcome; throws reach the caller's isolation. */
-async function rebuildOneSummary(hippoRoot, summary, opts, result) {
-    const children = loadChildrenOfSummary(hippoRoot, summary.id, summary.tenantId);
+async function rebuildOneSummary(store, summary, opts, result, preloaded, queuedIds) {
+    // A queued child may have been rebuilt earlier in this drain, so its preloaded content is stale: reread then.
+    const children = preloaded.some((c) => queuedIds.has(c.id))
+        ? store.childrenOfSummary(summary.id, summary.tenant_id)
+        : preloaded;
     if (children.length === 0) {
-        clearZeroChildSummary(hippoRoot, summary, result);
+        clearZeroChildSummary(store, summary, result);
         return;
     }
     const newContent = await generateDagSummary(summaryLabel(summary), children.map((c) => c.content), opts);
@@ -139,7 +142,7 @@ async function rebuildOneSummary(hippoRoot, summary, opts, result) {
         return;
     }
     const childCreatedAts = children.map((c) => c.created).sort();
-    const { changed, refused } = applyRebuildResult(hippoRoot, summary, {
+    const { changed, refused } = store.applyRebuild(summary, {
         content: newContent,
         descendant_count: children.length,
         earliest_at: childCreatedAts[0],
@@ -158,8 +161,8 @@ async function rebuildOneSummary(hippoRoot, summary, opts, result) {
     // success, silently skip
 }
 /** Zero-child case: clear dirty + zero counts, no LLM call, no rebuild_count bump. */
-function clearZeroChildSummary(hippoRoot, summary, result) {
-    const { changed } = applyRebuildResult(hippoRoot, summary, {
+function clearZeroChildSummary(store, summary, result) {
+    const { changed } = store.applyRebuild(summary, {
         content: summary.content,
         descendant_count: 0,
         earliest_at: null,
@@ -180,12 +183,13 @@ function summaryLabel(summary) {
         ? entityTags.map((t) => t.split(':')[1]).join(': ')
         : summary.content.slice(0, SUMMARY_FALLBACK_CHARS);
 }
-/** Sleep-cycle phase draining the dirty L2 summary queue; one throwing rebuild does not abort the rest.
- * A concurrent sleep's second writer gets changed=false (UPDATE requires summary_dirty=1) and is skipped silently; a tombstone hit counts as `refused`. */
-export async function rebuildDirtySummaries(hippoRoot, opts) {
+/** Sleep-cycle phase draining the dirty L2 summary queue; one throwing rebuild does not abort the rest. A concurrent
+ * sleep's second writer gets changed=false (UPDATE requires summary_dirty=1) and is skipped silently; a tombstone hit
+ * counts as `refused`. */
+export async function rebuildDirtySummaries(store, opts) {
     const cap = opts.cap ?? DEFAULT_REBUILD_CAP;
     // One past the cap tells whether more were waiting without reading the rest.
-    const dirty = loadAllDirtySummaries(hippoRoot, cap + 1);
+    const dirty = store.dirtySummaries(cap + 1);
     const capped = dirty.length > cap;
     const queue = dirty.slice(0, cap);
     const result = {
@@ -196,6 +200,8 @@ export async function rebuildDirtySummaries(hippoRoot, opts) {
         failed: 0,
         capped,
     };
+    const childrenOf = store.childrenOfSummaries(queue);
+    const queuedIds = new Set(queue.map((s) => s.id));
     for (const [index, summary] of queue.entries()) {
         // Yield the macrotask queue every 25 summaries: each iteration is synchronous SQLite, so a batch of up to 1000
         // would starve timers and IPC (server keep-alives, Vitest's birpc heartbeat).
@@ -203,13 +209,13 @@ export async function rebuildDirtySummaries(hippoRoot, opts) {
             await new Promise((resolve) => setImmediate(resolve));
         }
         try {
-            await rebuildOneSummary(hippoRoot, summary, opts, result);
+            await rebuildOneSummary(store, summary, opts, result, childrenOf(summary), queuedIds);
         }
         catch (err) {
             // One throw doesn't abort the queue; log enough to triage an exotic
             // failure (SQLite I/O, prepare), since audit() already catches its own.
             result.failed++;
-            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenantId}) failed: ${errorMessage(err)}`, errorFields(err));
+            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenant_id}) failed: ${errorMessage(err)}`, errorFields(err));
         }
     }
     return result;
@@ -222,7 +228,7 @@ function createProfileEntry(summary, cluster, home) {
         layer: Layer.Semantic,
         tags: [...cluster.entityTags, ...neverAutoShareTags(cluster.members), 'dag-entity-profile'],
         confidence: 'inferred',
-        dag_level: 3,
+        dagLevel: 3,
         tenantId: home.tenantId,
         scope: home.scope,
         baseHalfLifeDays: home.baseHalfLifeDays,
@@ -235,7 +241,7 @@ function createProfileEntry(summary, cluster, home) {
     return profileEntry;
 }
 /** Profile one eligible cluster of L2s, write it, then re-link the L2s under it. */
-async function profileCluster(hippoRoot, cluster, home, opts, result) {
+async function profileCluster(store, cluster, home, opts, result) {
     const summary = await generateDagSummary(cluster.label, cluster.members.map((m) => m.content), opts);
     if (!summary) {
         result.failed++;
@@ -244,25 +250,25 @@ async function profileCluster(hippoRoot, cluster, home, opts, result) {
     const profileEntry = createProfileEntry(summary, cluster, home);
     // A refused profile skips only this cluster; the re-linking below never runs for it.
     try {
-        writeEntry(hippoRoot, profileEntry);
+        store.writeEntry(profileEntry);
     }
     catch (err) {
         if (err instanceof RejectedValueError) {
             result.rejected++;
-            log.warn(`buildEntityProfiles: cluster "${cluster.label}" skipped: profile matches a rejected value`);
+            log.warn(`buildEntityProfiles: cluster "${cluster.label}" skipped: profile matches a rejected value`, errorFields(err));
             return;
         }
         throw err;
     }
     result.profilesCreated++;
-    result.l2sLinked += writeEntriesTogether(hippoRoot, cluster.members.map((member) => ({ ...member, dag_parent_id: profileEntry.id })));
+    result.l2sLinked += store.writeTogether(cluster.members.map((member) => ({ ...member, dag_parent_id: profileEntry.id })));
     // Re-linking just marked the fresh L3 dirty; clear it so this cycle's rebuild skips it.
     // The distinct source tags the audit row.
-    clearSummaryDirtyAfterBuild(hippoRoot, profileEntry.id, home.tenantId, 'buildEntityProfiles', 'buildEntityProfiles-clean');
+    store.clearSummaryDirty(profileEntry.id, home.tenantId, 'buildEntityProfiles', 'buildEntityProfiles-clean');
 }
 /** Build L3 entity profiles by clustering L2 summaries sharing entity tags (2+ L2s per entity).
  * Each L2 link write marks the new L3 dirty, so clear it or the same cycle re-rebuilds it. */
-export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
+export async function buildEntityProfiles(local, l2Summaries, opts) {
     const result = {
         candidateClusters: 0,
         profilesCreated: 0,
@@ -270,12 +276,12 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
         failed: 0,
         rejected: 0,
     };
-    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    const baseHalfLifeDays = loadConfig(local.hippoRoot).defaultHalfLifeDays;
     // Only L2 with no L3 parent yet (avoid re-clustering already-profiled L2s).
     const unparented = l2Summaries.filter((s) => s.dag_level === 2 && !s.dag_parent_id);
     for (const [, tenantL2s] of partitionFactsByTenant(unparented)) {
         const home = {
-            tenantId: tenantL2s[0].tenantId,
+            tenantId: tenantL2s[0].tenant_id,
             scope: derivationScope(tenantL2s[0].scope),
             originProject: tenantL2s[0].origin_project,
             baseHalfLifeDays,
@@ -284,7 +290,7 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
         const eligible = clusters.filter((c) => c.members.length >= 2);
         result.candidateClusters += eligible.length;
         for (const cluster of eligible) {
-            await profileCluster(hippoRoot, cluster, home, opts, result);
+            await profileCluster(local.consolidation, cluster, home, opts, result);
         }
     }
     return result;

package/dist/consolidate/decay.js

@@ -4,7 +4,8 @@ import { rescueSet, rankNonPinnedByTenant, validateWeights } from './memory-valu
 import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from './memory-value-weights.js';
 const STRENGTH_DECIMALS = 4;
 export const DECAY_THRESHOLD = 0.05;
-// Leaving active memory: a raw receipt stays (the append-only trigger aborts DELETE for the whole batch; stored strength refreshed) but sits out this cycle;
+// Leaving active memory: a raw receipt stays (the append-only trigger aborts DELETE for the whole batch; stored
+// strength refreshed) but sits out this cycle;
 // others go dormant when config.dormant is on, else are deleted. Only called for rows `retirable` allows.
 function retireFaded(run, entry, strength) {
     const { result } = run;
@@ -14,7 +15,12 @@ function retireFaded(run, entry, strength) {
     if (run.config.dormant.enabled && !detectSecret(entry).flagged) {
         result.dormant++;
         result.details.push(`  💤 dormant ${entry.id} ${why}`);
-        run.pendingDormant.push({ entry: { ...entry, strength }, strength, reason: 'decay', dormantAt: run.now.toISOString() });
+        run.pendingDormant.push({
+            entry: { ...entry, strength },
+            strength,
+            reason: 'decay',
+            dormantAt: run.now.toISOString(),
+        });
         return;
     }
     result.removed++;
@@ -31,7 +37,8 @@ function keepSurvivor(run, entry, strength) {
     run.result.decayed++;
     return updated;
 }
-// 1. Decay pass. Memory-value flag OFF runs the single-phase loop below; ON classifies every entry with zero commits, runs rescueSet per tenant, then commits.
+// 1. Decay pass. Memory-value flag OFF runs the single-phase loop below; ON classifies every entry with zero commits,
+// runs rescueSet per tenant, then commits.
 // Rescued entries stay full survivors for this cycle's later passes.
 export function decayPass(run) {
     if (run.config.memoryValue.enabled)
@@ -85,14 +92,19 @@ function decayWithMemoryValue(run) {
     let rescuedIds = new Set();
     let rankById = new Map();
     const { strengthById, condemnedIds } = classifyByStrength(run);
-    // Phase 2a: rescue decision (pure compute); runs under --dry-run too (only the pendingDeletes flush and the logRun audit write are !dryRun-gated).
+    // Phase 2a: rescue decision (pure compute); runs under --dry-run too (only the pendingDeletes flush and the logRun
+    // audit write are !dryRun-gated).
     // Fail-loud must not depend on condemnation traffic: validate the frozen weights even when nothing is condemned.
     validateWeights();
     if (condemnedIds.size > 0) {
         // Rank per tenant ONCE: rankById feeds both rescueSet (via precomputedRanks) and the detail/audit
         // context below, so the whole-store ranking runs once per sleep and only when something is condemned.
         rankById = rankNonPinnedByTenant(all, now);
-        rescuedIds = rescueSet(all, condemnedIds, now, { weights: MEMORY_VALUE_WEIGHTS, digest: SOURCE_ARTIFACT_SHA256, precomputedRanks: rankById });
+        rescuedIds = rescueSet(all, condemnedIds, now, {
+            weights: MEMORY_VALUE_WEIGHTS,
+            digest: SOURCE_ARTIFACT_SHA256,
+            precomputedRanks: rankById,
+        });
         reportNonFiniteScores(result, rankById);
     }
     // --- Phase 2b: commit, one pass over `all` in ITS ORIGINAL ORDER ---
@@ -101,7 +113,8 @@ function decayWithMemoryValue(run) {
         const strength = strengthById.get(entry.id);
         if (run.retirable(entry) && strength < DECAY_THRESHOLD) {
             if (rescuedIds.has(entry.id)) {
-                // Rescued: standard survivor stored-strength refresh. Confidence is left alone: it is an epistemic tier, not a cached
+                // Rescued: standard survivor stored-strength refresh. Confidence is left alone: it is an epistemic tier, not a
+                // cached
                 // computation, so resolveConfidence derives it on read.
                 rescuedEntries.push(keepSurvivor(run, entry, strength));
                 reportRescue(result, entry, strength, rankById.get(entry.id));

package/dist/consolidate/dedupe.d.ts

@@ -1,5 +1,10 @@
-/** Store-level dedup: same text apart from spacing, keeping the stronger copy; split out so `api.sleep` can dedupe without cli -> api imports.
- * Survivor order is total and tenant-scoped: strength bucket, retrieval_count, then compareEntryIdentity; raw and superseded rows are not candidates. */
+/**
+ * Store-level dedup: same text apart from spacing, keeping the stronger copy; split out so `api.sleep` can dedupe
+ * without cli -> api imports.
+ * Survivor order is total and tenant-scoped: strength bucket, retrieval_count, then compareEntryIdentity; raw and
+ * superseded rows are not candidates.
+ */
+import type { Consolidation } from '../store/port.js';
 import { type MemoryEntry } from '../core/memory.js';
 export interface DedupPair {
     kept: string;
@@ -17,7 +22,9 @@ export interface DedupResult {
     removed: number;
     pairs: DedupPair[];
 }
-/** Quantize strength to an integer bucket so ties are a true equivalence relation (equal iff same multiple of `STRENGTH_TIE_EPSILON`).
+/**
+ * Quantize strength to an integer bucket so ties are a true equivalence relation (equal iff same multiple of
+ * `STRENGTH_TIE_EPSILON`).
  * Non-finite input maps to 0: a NaN bucket would make the comparator return NaN and break the total order. */
 export declare function strengthBucket(strength: number | null | undefined): number;
 /** Every row of the store, read once by a caller that also needs them, with the ids of rows backing an object. */
@@ -25,9 +32,11 @@ export interface LoadedStore {
     readonly entries: readonly MemoryEntry[];
     readonly backing: ReadonlySet<string>;
 }
-/** Remove the weaker copy of same-text (apart from spacing) memories within one tenant; cross-tenant pairs are never duplicates (isolation boundary).
+/**
+ * Remove the weaker copy of same-text (apart from spacing) memories within one tenant; cross-tenant pairs are never
+ * duplicates (isolation boundary).
  * Higher strength wins, then more retrievals; `threshold` is accepted for old callers and ignored. */
-export declare function deduplicateStore(hippoRoot: string, options?: {
+export declare function deduplicateStore(store: Consolidation, options?: {
     threshold?: number;
     dryRun?: boolean;
     actor?: string;

package/dist/consolidate/dedupe.js

@@ -1,15 +1,22 @@
-/** Store-level dedup: same text apart from spacing, keeping the stronger copy; split out so `api.sleep` can dedupe without cli -> api imports.
- * Survivor order is total and tenant-scoped: strength bucket, retrieval_count, then compareEntryIdentity; raw and superseded rows are not candidates. */
+/**
+ * Store-level dedup: same text apart from spacing, keeping the stronger copy; split out so `api.sleep` can dedupe
+ * without cli -> api imports.
+ * Survivor order is total and tenant-scoped: strength bucket, retrieval_count, then compareEntryIdentity; raw and
+ * superseded rows are not candidates.
+ */
 import { textOverlap } from '../util/tokenize.js';
-import { loadCurrentDistilledEntries } from '../store/entry-reads.js';
-import { deleteEntriesOneByOne, memoriesBackingObjects } from '../store/delete-and-batch.js';
 import { compareEntryIdentity } from '../core/compare.js';
 import { canAutoDelete } from '../core/memory.js';
 import { derivationPartitionKey } from '../core/recall-scope.js';
 import { duplicateKey } from '../util/same-text.js';
-/** Quantization step for strength-tie comparisons: the 0.01 epsilon applied by rounding instead of an abs-diff threshold, so the tiebreak is transitive. */
+/**
+ * Quantization step for strength-tie comparisons: the 0.01 epsilon applied by rounding instead of an abs-diff
+ * threshold, so the tiebreak is transitive.
+ */
 const STRENGTH_TIE_EPSILON = 0.01;
-/** Quantize strength to an integer bucket so ties are a true equivalence relation (equal iff same multiple of `STRENGTH_TIE_EPSILON`).
+/**
+ * Quantize strength to an integer bucket so ties are a true equivalence relation (equal iff same multiple of
+ * `STRENGTH_TIE_EPSILON`).
  * Non-finite input maps to 0: a NaN bucket would make the comparator return NaN and break the total order. */
 export function strengthBucket(strength) {
     const s = strength ?? 0;
@@ -28,13 +35,14 @@ function survivorOrder(a, b) {
         return retrievalDiff;
     return compareEntryIdentity(a, b);
 }
-// Tenant partition: group by tenantId before sorting so a duplicate pair never forms across tenants; Map keeps insertion order,
+// Tenant partition: group by tenantId before sorting so a duplicate pair never forms across tenants; Map keeps
+// insertion order,
 // so a single-tenant store gets one group and the same result as a global pass.
 function entriesByPartition(entries) {
     const entriesByTenant = new Map();
     for (const entry of entries) {
         // EI2: also split by restricted scope, else a private copy can delete the readable one.
-        const key = derivationPartitionKey(entry.tenantId, entry.scope, entry.origin_project);
+        const key = derivationPartitionKey(entry.tenant_id, entry.scope, entry.origin_project);
         const bucket = entriesByTenant.get(key);
         if (bucket)
             bucket.push(entry);
@@ -73,33 +81,36 @@ function partitionPairs(tenantEntries, removed, backing) {
     }
     return [...groups.values()].flatMap((group) => group.pairs);
 }
-/** The rows loadCurrentDistilledEntries selects, picked from a whole-store read. */
+/** The rows currentDistilledEntries selects, picked from a whole-store read. */
 const isCurrentDistilled = (e) => (e.kind ?? 'distilled') === 'distilled' && !e.superseded_by;
-/** Remove the weaker copy of same-text (apart from spacing) memories within one tenant; cross-tenant pairs are never duplicates (isolation boundary).
+/**
+ * Remove the weaker copy of same-text (apart from spacing) memories within one tenant; cross-tenant pairs are never
+ * duplicates (isolation boundary).
  * Higher strength wins, then more retrievals; `threshold` is accepted for old callers and ignored. */
-export function deduplicateStore(hippoRoot, options = {}) {
+export function deduplicateStore(store, options = {}) {
     const dryRun = options.dryRun ?? false;
     // Only current distilled rows compete: raw rows are append-only (the delete
     // trigger would abort sleep mid-loop) and superseded rows are history.
-    const entries = options.loaded?.entries.filter(isCurrentDistilled) ?? loadCurrentDistilledEntries(hippoRoot);
+    const entries = options.loaded?.entries.filter(isCurrentDistilled) ?? store.currentDistilledEntries();
     const entriesByTenant = entriesByPartition(entries);
-    // Shared across tenant groups: ids are globally unique UUIDs, so `removed` cannot collide across tenants and deleteEntry deletes by primary key alone.
+    // Shared across tenant groups: ids are globally unique UUIDs, so `removed` cannot collide across tenants and
+    // deleteEntry deletes by primary key alone.
     const removed = new Set();
     const pairs = [];
-    const backing = options.loaded?.backing ?? memoriesBackingObjects(hippoRoot);
+    const backing = options.loaded?.backing ?? store.objectBackedIds();
     for (const tenantEntries of entriesByTenant.values()) {
         // The survivor total order (see the file-level docstring), scoped per
         // tenant group: the total order holds within a tenant only, matching the partition above.
         tenantEntries.sort(survivorOrder);
         pairs.push(...partitionPairs(tenantEntries, removed, backing));
     }
-    const done = dryRun ? pairs : deletePairs(hippoRoot, pairs, options.actor);
+    const done = dryRun ? pairs : deletePairs(store, pairs, options.actor);
     return { removed: done.length, pairs: done };
 }
 /** The pairs whose loser was deleted; one store handle, one transaction per delete. */
-function deletePairs(hippoRoot, pairs, actor) {
+function deletePairs(store, pairs, actor) {
     const targets = pairs.map((p) => ({ id: p.removed, reason: `dedup: duplicate of ${p.kept}` }));
-    const gone = deleteEntriesOneByOne(hippoRoot, targets, { actor, automatic: true });
+    const gone = store.deleteOneByOne(targets, { actor, automatic: true });
     return pairs.filter((_, i) => gone[i]);
 }
 //# sourceMappingURL=dedupe.js.map

package/dist/consolidate/flush-units.d.ts

@@ -3,6 +3,9 @@ import type { DormantMove } from '../store/dormant.js';
 import type { FlushComponent, LoadedRows } from '../store/delete-and-batch.js';
 /** Components that share no id, ordered by each one's first op across writes, then deletes, then dormant moves. */
 export declare function groupFlush(writes: readonly MemoryEntry[], deletes: readonly string[], dormant: readonly DormantMove[], units: readonly (readonly string[])[]): FlushComponent[];
-/** [child, parent] per queued op on a child whose DAG parent the run removes: the parent-dirty mark otherwise lands after the parent is gone. */
+/**
+ * [child, parent] per queued op on a child whose DAG parent the run removes: the parent-dirty mark otherwise lands
+ * after the parent is gone.
+ */
 export declare function familyUnits(writes: readonly MemoryEntry[], deletes: readonly string[], dormant: readonly DormantMove[], snapshot: LoadedRows): string[][];
 //# sourceMappingURL=flush-units.d.ts.map

package/dist/consolidate/flush-units.js

@@ -42,7 +42,10 @@ function unionFind(units) {
     }
     return find;
 }
-/** [child, parent] per queued op on a child whose DAG parent the run removes: the parent-dirty mark otherwise lands after the parent is gone. */
+/**
+ * [child, parent] per queued op on a child whose DAG parent the run removes: the parent-dirty mark otherwise lands
+ * after the parent is gone.
+ */
 // SHORTCUT: a removed parent and all its changed children commit as one component, so
 // one hold can pass holdMs by a family's size; split by child if a family grows large.
 export function familyUnits(writes, deletes, dormant, snapshot) {