hippo-memory 1.72.0 → 2.1.0

package/dist/consolidate/overlap-index.d.ts

@@ -1,7 +1,13 @@
 /** Smallest number of shared tokens any qualifying pair can have, given either side's token count. */
 export type MinShared = (size: number) => number;
-/** Shared >= threshold * union >= threshold * size; one token of slack covers float rounding in the caller's Jaccard check. */
+/**
+ * Shared >= threshold * union >= threshold * size; one token of slack covers float rounding in the caller's Jaccard
+ * check.
+ */
 export declare function jaccardMinShared(threshold: number, atLeast?: number): MinShared;
-/** Maps i to each j > i, ascending, that may share `minShared` tokens with set i; a superset the caller checks exactly, never a pair sharing no token. */
+/**
+ * Maps i to each j > i, ascending, that may share `minShared` tokens with set i; a superset the caller checks exactly,
+ * never a pair sharing no token.
+ */
 export declare function overlapPartners(sets: readonly ReadonlySet<string>[], minShared: MinShared): (i: number) => number[];
 //# sourceMappingURL=overlap-index.d.ts.map

package/dist/consolidate/overlap-index.js

@@ -1,15 +1,22 @@
-// All-pairs overlap join through an inverted index over rare-first token prefixes (prefix filtering, Chaudhuri et al. 2006).
-/** Shared >= threshold * union >= threshold * size; one token of slack covers float rounding in the caller's Jaccard check. */
+// All-pairs overlap join through an inverted index over rare-first token prefixes (prefix filtering, Chaudhuri et al.
+// 2006).
+/**
+ * Shared >= threshold * union >= threshold * size; one token of slack covers float rounding in the caller's Jaccard
+ * check.
+ */
 export function jaccardMinShared(threshold, atLeast = 1) {
     return (size) => Math.max(atLeast, Math.ceil(threshold * size) - 1);
 }
-/** Maps i to each j > i, ascending, that may share `minShared` tokens with set i; a superset the caller checks exactly, never a pair sharing no token. */
+/**
+ * Maps i to each j > i, ascending, that may share `minShared` tokens with set i; a superset the caller checks exactly,
+ * never a pair sharing no token.
+ */
 export function overlapPartners(sets, minShared) {
     const docFreq = new Map();
     for (const set of sets)
         for (const t of set)
             docFreq.set(t, (docFreq.get(t) ?? 0) + 1);
-    const rareFirst = (a, b) => ((docFreq.get(a) ?? 0) - (docFreq.get(b) ?? 0)) || (a < b ? -1 : a > b ? 1 : 0);
+    const rareFirst = (a, b) => (docFreq.get(a) ?? 0) - (docFreq.get(b) ?? 0) || (a < b ? -1 : a > b ? 1 : 0);
     // Under one total order the first token two sets share lies in both sets' first size - minShared + 1 tokens.
     const prefixes = sets.map((set) => {
         const keep = set.size - Math.max(1, minShared(set.size)) + 1;

package/dist/consolidate/physics-pass.d.ts

@@ -2,7 +2,9 @@ import { type PhysicsParticle } from '../core/physics.js';
 import type { MemoryEntry } from '../core/memory.js';
 import type { SleepRun } from './run.js';
 export declare function physicsPass(run: SleepRun, maxParticles?: number): void;
-/** Every stored particle in load order up to the cap; past it, the most recently recalled survivors (memory id breaks ties),
+/**
+ * Every stored particle in load order up to the cap; past it, the most recently recalled survivors (memory id breaks
+ * ties),
  * then particles with no survivor. */
 export declare function particlesToSimulate(stored: PhysicsParticle[], entries: ReadonlyMap<string, MemoryEntry>, max?: number): PhysicsParticle[];
 //# sourceMappingURL=physics-pass.d.ts.map

package/dist/consolidate/physics-pass.js

@@ -1,9 +1,9 @@
-import { refreshParticleProperties } from '../db/physics-state.js';
-import { loadStoredParticles, saveStoredParticles } from '../store/vector-index.js';
+import { refreshParticleProperties } from '../core/particle-refresh.js';
 import { simulate } from '../core/physics.js';
 import { errorMessage } from '../util/log.js';
 const STATS_DECIMALS = 4;
-// Every substep is all-pairs, so one sleep moves at most this many particles; the rest keep their stored state until they are recalled.
+// Every substep is all-pairs, so one sleep moves at most this many particles; the rest keep their stored state until
+// they are recalled.
 const SLEEP_PHYSICS_MAX_PARTICLES = 1000;
 // 2. Physics simulation pass
 export function physicsPass(run, maxParticles = SLEEP_PHYSICS_MAX_PARTICLES) {
@@ -22,7 +22,7 @@ export function physicsPass(run, maxParticles = SLEEP_PHYSICS_MAX_PARTICLES) {
 }
 function simulateStoredParticles(run, maxParticles) {
     const { result, survivors } = run;
-    const stored = loadStoredParticles(run.hippoRoot);
+    const stored = run.store.storedParticles();
     if (stored.length === 0)
         return;
     // Build entry lookup for property refresh
@@ -30,14 +30,16 @@ function simulateStoredParticles(run, maxParticles) {
     const particles = particlesToSimulate(stored, entryMap, maxParticles);
     refreshParticleProperties(particles, entryMap, run.now);
     const stats = simulate(particles, survivorForces(run));
-    saveStoredParticles(run.hippoRoot, particles);
+    run.store.saveParticles(particles);
     result.physicsSimulated = stats.particleCount;
     const capped = particles.length < stored.length ? ` (the ${particles.length} most recently recalled of ${stored.length})` : '';
     result.details.push(`  ⚛️  physics: ${stats.particleCount} particles${capped}, ` +
         `avg vel ${stats.avgVelocityMagnitude.toFixed(STATS_DECIMALS)}, ` +
         `energy ${stats.energy.total.toFixed(STATS_DECIMALS)}`);
 }
-/** Every stored particle in load order up to the cap; past it, the most recently recalled survivors (memory id breaks ties),
+/**
+ * Every stored particle in load order up to the cap; past it, the most recently recalled survivors (memory id breaks
+ * ties),
  * then particles with no survivor. */
 export function particlesToSimulate(stored, entries, max = SLEEP_PHYSICS_MAX_PARTICLES) {
     if (stored.length <= max)
@@ -50,7 +52,8 @@ export function particlesToSimulate(stored, entries, max = SLEEP_PHYSICS_MAX_PAR
         return a.memoryId < b.memoryId ? -1 : a.memoryId > b.memoryId ? 1 : 0;
     });
     const kept = new Set(ranked.slice(0, max));
-    // Load order, not rank order: the force sums run in this order, so a capped run matches an uncapped one over the same set.
+    // Load order, not rank order: the force sums run in this order, so a capped run matches an uncapped one over the same
+    // set.
     return stored.filter((p) => kept.has(p));
 }
 function survivorForces(run) {

package/dist/consolidate/replay.d.ts

@@ -1,9 +1,16 @@
-/** Replay: during `hippo sleep`, sample N survivors weighted by reward, valence, under-rehearsal and age, then apply the `markRetrieved` strengthening.
- * A lightweight deterministic analog of hippocampal replay, so important memories stay strong without being queried; distinct from decay, physics and merge. */
+/**
+ * Replay: during `hippo sleep`, sample N survivors weighted by reward, valence, under-rehearsal and age, then apply the
+ * `markRetrieved` strengthening.
+ * A lightweight deterministic analog of hippocampal replay, so important memories stay strong without being queried;
+ * distinct from decay, physics and merge.
+ */
 import { type MemoryEntry } from '../core/memory.js';
-/** Priority score for ranking survivors for replay (higher = more likely sampled); pure in the entry and current time. */
+/**
+ * Priority score for ranking survivors for replay (higher = more likely sampled); pure in the entry and current time.
+ */
 export declare function replayPriority(entry: MemoryEntry, now: Date, outcomeAblated: boolean): number;
 /** Pick `count` memories for replay, weighted by `replayPriority`, without replacement; deterministic for a seed.
- * Weighted but not greedy: always taking the top-N overfits, so a stochastic element keeps adjacent survivors in play. */
+ * Weighted but not greedy: always taking the top-N overfits, so a stochastic element keeps adjacent survivors in play.
+ */
 export declare function sampleForReplay(survivors: MemoryEntry[], count: number, now: Date, seed?: number): MemoryEntry[];
 //# sourceMappingURL=replay.d.ts.map

package/dist/consolidate/replay.js

@@ -1,5 +1,9 @@
-/** Replay: during `hippo sleep`, sample N survivors weighted by reward, valence, under-rehearsal and age, then apply the `markRetrieved` strengthening.
- * A lightweight deterministic analog of hippocampal replay, so important memories stay strong without being queried; distinct from decay, physics and merge. */
+/**
+ * Replay: during `hippo sleep`, sample N survivors weighted by reward, valence, under-rehearsal and age, then apply the
+ * `markRetrieved` strengthening.
+ * A lightweight deterministic analog of hippocampal replay, so important memories stay strong without being queried;
+ * distinct from decay, physics and merge.
+ */
 import { HOUR_MS } from '../util/time.js';
 import { isOutcomeSlowAblated } from '../core/ablation.js';
 import { resolveConfidence } from '../core/memory.js';
@@ -15,11 +19,14 @@ const REWARD_POSITIVE_GAIN = 0.5;
 const REWARD_NET_GAIN = 0.25;
 const IDLE_BOOST_GAIN = 0.1;
 const STRENGTH_FLOOR = 0.1;
-/** Priority score for ranking survivors for replay (higher = more likely sampled); pure in the entry and current time. */
+/**
+ * Priority score for ranking survivors for replay (higher = more likely sampled); pure in the entry and current time.
+ */
 export function replayPriority(entry, now, outcomeAblated) {
     const pos = entry.outcome_positive ?? 0;
     const neg = entry.outcome_negative ?? 0;
-    // Reward signal: neutral = 1, strongly rewarded > 1, negative-dominated floors at 0.1 (still eligible, just unlikely).
+    // Reward signal: neutral = 1, strongly rewarded > 1, negative-dominated floors at 0.1 (still eligible, just
+    // unlikely).
     // The clamp is required because sampleForReplay needs all weights positive.
     const rewardSignal = outcomeAblated
         ? 1.0 // EVAL-ONLY ablation (see ablation.ts): outcome-off also silences replay's reward bias
@@ -37,7 +44,10 @@ export function replayPriority(entry, now, outcomeAblated) {
     const strengthFloor = Math.max(STRENGTH_FLOOR, rawStrength);
     return rewardSignal * valence * underRehearsed * idleBoost * strengthFloor;
 }
-/** Deterministic 32-bit RNG (Mulberry32): same seed, same sequence, so replay is reproducible without a random-number dependency. */
+/**
+ * Deterministic 32-bit RNG (Mulberry32): same seed, same sequence, so replay is reproducible without a random-number
+ * dependency.
+ */
 function mulberry32(seed) {
     let s = seed >>> 0;
     return () => {
@@ -48,12 +58,14 @@ function mulberry32(seed) {
     };
 }
 /** Pick `count` memories for replay, weighted by `replayPriority`, without replacement; deterministic for a seed.
- * Weighted but not greedy: always taking the top-N overfits, so a stochastic element keeps adjacent survivors in play. */
+ * Weighted but not greedy: always taking the top-N overfits, so a stochastic element keeps adjacent survivors in play.
+ */
 export function sampleForReplay(survivors, count, now, seed = Date.now() >>> 0) {
     if (count <= 0 || survivors.length === 0)
         return [];
     const rng = mulberry32(seed);
-    // Deliberately-marked and aged-out memories are both untrusted and rehearsing them defeats staleness, so derive rather than trust
+    // Deliberately-marked and aged-out memories are both untrusted and rehearsing them defeats staleness, so derive
+    // rather than trust
     // the stored value (it no longer carries the age-out case).
     const eligible = survivors.filter((e) => resolveConfidence(e, now) !== 'stale');
     if (eligible.length === 0)

package/dist/consolidate/run.d.ts

@@ -1,6 +1,7 @@
 import { MemoryEntry, type DecayOptions } from '../core/memory.js';
-import { type DormantMove } from '../store/dormant.js';
-import { type TombstoneChecks } from '../store/tombstone-checks.js';
+import type { DormantMove } from '../store/dormant.js';
+import type { Consolidation } from '../store/port.js';
+import type { TombstoneChecks } from '../store/tombstone-checks.js';
 import { loadConfig } from '../core/config.js';
 export interface ConsolidationResult {
     decayed: number;
@@ -36,10 +37,14 @@ export interface ConsolidationResult {
 export declare const REPLAY_COUNT_DEFAULT = 5;
 export declare function keptAsWritten(entry: MemoryEntry): boolean;
 /** Re-syncs the full-text index with `memories`; a store open that is already current no longer counts the two. */
-export declare function syncFtsIndex(hippoRoot: string, dryRun: boolean, result: ConsolidationResult): void;
-/** State every sleep stage reads or appends to; the pending lists are flushed at the end, each of `units` whole in one transaction. */
+export declare function syncFtsIndex(store: Consolidation, dryRun: boolean, result: ConsolidationResult): void;
+/**
+ * State every sleep stage reads or appends to; the pending lists are flushed at the end, each of `units` whole in one
+ * transaction.
+ */
 export interface SleepRun {
     hippoRoot: string;
+    store: Consolidation;
     now: Date;
     dryRun: boolean;
     config: ReturnType<typeof loadConfig>;
@@ -47,7 +52,10 @@ export interface SleepRun {
     result: ConsolidationResult;
     all: MemoryEntry[];
     retirable: (entry: MemoryEntry) => boolean;
-    /** Auto-promote (1.4) and merge (3) write deterministic content through the guard's bypass, so both check tombstones here first. */
+    /**
+     * Auto-promote (1.4) and merge (3) write deterministic content through the guard's bypass, so both check tombstones
+     * here first.
+     */
     tombstones: TombstoneChecks;
     survivors: MemoryEntry[];
     pendingWrites: MemoryEntry[];

package/dist/consolidate/run.js

@@ -1,15 +1,15 @@
-import { ftsDrift } from '../store/entry-row.js';
 import { NO_MERGE_TAGS } from '../sharing/share.js';
 export const REPLAY_COUNT_DEFAULT = 5;
 export function keptAsWritten(entry) {
     return entry.tags.some((tag) => NO_MERGE_TAGS.has(tag));
 }
 /** Re-syncs the full-text index with `memories`; a store open that is already current no longer counts the two. */
-export function syncFtsIndex(hippoRoot, dryRun, result) {
-    const counts = ftsDrift(hippoRoot, !dryRun);
+export function syncFtsIndex(store, dryRun, result) {
+    const counts = store.ftsDrift(!dryRun);
     if (counts === null)
         return;
-    result.details.push(`  🔎 ${dryRun ? 'would re-sync' : 're-synced'} the full-text index (${counts.fts} indexed rows for ${counts.memories} memories)`);
+    result.details.push(`  🔎 ${dryRun ? 'would re-sync' : 're-synced'} the full-text index (${counts.fts} indexed rows for ` +
+        `${counts.memories} memories)`);
 }
 export function newConsolidationResult(dryRun) {
     return {

package/dist/consolidate/sleep.d.ts

@@ -1,13 +1,21 @@
-/** Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic summaries of overlapping episodics), stats. */
-import { type WriteBudget } from '../util/write-budget.js';
-import { type ConsolidationResult } from './run.js';
 /**
- * Run a full consolidation pass.
+ * Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic
+ * summaries of overlapping episodics), stats.
  */
-export declare function consolidate(hippoRoot: string, options?: {
+import type { LocalFiles } from '../store/port.js';
+import { type WriteBudget } from '../util/write-budget.js';
+import { type ConsolidationResult } from './run.js';
+type ConsolidateOptions = {
     dryRun?: boolean;
     now?: Date;
     fetcher?: typeof fetch;
     budget?: WriteBudget;
-}): Promise<ConsolidationResult>;
+};
+/**
+ * Run a full consolidation pass on the hippo.db under `hippoRoot`.
+ */
+export declare function consolidate(hippoRoot: string, options?: ConsolidateOptions): Promise<ConsolidationResult>;
+/** A full consolidation pass whose store work goes through `local.consolidation`. */
+export declare function runConsolidation(local: LocalFiles, options?: ConsolidateOptions): Promise<ConsolidationResult>;
+export {};
 //# sourceMappingURL=sleep.d.ts.map

package/dist/consolidate/sleep.js

@@ -1,16 +1,12 @@
-/** Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic summaries of overlapping episodics), stats. */
+/**
+ * Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic
+ * summaries of overlapping episodics), stats.
+ */
 import { evalNow, strengthAblation } from '../core/ablation.js';
-import { canAutoDelete } from '../core/memory.js';
-import { loadAllEntriesWithBase } from '../store/entry-reads.js';
-import { commitInChunks, memoriesBackingObjects } from '../store/delete-and-batch.js';
-import { appendConsolidationRun, loadSessionDecayContext, incrementSleepCount } from '../store/index-and-stats.js';
-import { replaceDetectedConflicts } from '../store/conflicts.js';
-import { SLEEP_DB_WAIT_MS } from '../db/index.js';
-import { expireDormantBefore } from '../store/dormant.js';
+import { canAutoDelete, LEGACY_TYPED_HALF_LIFE } from '../core/memory.js';
+import { sqliteSyncStore } from '../store/sqlite/store.js';
 import { loadConfig } from '../core/config.js';
-import { recordAuditEventsRowByRow, reportAuditWriteFailure } from '../store/audit.js';
-import { lazyTombstoneChecks } from '../store/tombstone-checks.js';
-import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from './half-life-migration.js';
+import { migrateDefaultHalfLife } from './half-life-migration.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
 import { WRITE_BUDGET } from '../util/write-budget.js';
 import { decayPass } from './decay.js';
@@ -23,28 +19,33 @@ import { llmPasses } from './llm-passes.js';
 import { physicsPass } from './physics-pass.js';
 import { DAY_MS } from '../util/time.js';
 /**
- * Run a full consolidation pass.
+ * Run a full consolidation pass on the hippo.db under `hippoRoot`.
  */
 export async function consolidate(hippoRoot, options = {}) {
+    return runConsolidation(sqliteSyncStore(hippoRoot).localFiles, options);
+}
+/** A full consolidation pass whose store work goes through `local.consolidation`. */
+export async function runConsolidation(local, options = {}) {
+    const { hippoRoot, consolidation: store } = local;
     const now = options.now ?? evalNow(); // honors HIPPO_FAKE_NOW (eval-only; see ablation.ts)
     const dryRun = options.dryRun ?? false;
     const result = newConsolidationResult(dryRun);
-    const halfLife = migrateHalfLives(hippoRoot, dryRun, result);
-    syncFtsIndex(hippoRoot, dryRun, result);
+    const halfLife = migrateHalfLives(local, dryRun, result);
+    syncFtsIndex(store, dryRun, result);
     // Host-wide by design: per-tenant filtering would mean N runs per host and no cross-tenant dedup.
     // The api.sleep audit row tags this with the admin synthetic actor.
-    const { entries: all, base: snapshot } = loadAllEntriesWithBase(hippoRoot);
+    const { entries: all, base: snapshot } = store.entriesWithBase();
     if (dryRun)
         for (const e of all)
             e.half_life_days = halfLife.halfLives.get(e.id) ?? e.half_life_days;
-    const backingObjects = memoriesBackingObjects(hippoRoot);
+    const backingObjects = store.objectBackedIds();
     // Retirable: auto-deletable (never pinned, raw or kept for good) and not backing a first-class object.
     const retirable = (entry) => canAutoDelete(entry) && !backingObjects.has(entry.id);
     const config = loadConfig(hippoRoot);
-    const decayOpts = sessionDecayOptions(hippoRoot, config);
+    const decayOpts = sessionDecayOptions(store, config);
     const run = {
-        hippoRoot, now, dryRun, config, decayOpts, result, all, retirable,
-        tombstones: lazyTombstoneChecks(hippoRoot, dryRun),
+        hippoRoot, store, now, dryRun, config, decayOpts, result, all, retirable,
+        tombstones: store.tombstoneChecks(dryRun),
         survivors: [],
         // Collect all writes/deletes and batch them at the end
         pendingWrites: [],
@@ -62,8 +63,8 @@ export async function consolidate(hippoRoot, options = {}) {
     return result;
 }
 // Load decay options from config + session context
-function sessionDecayOptions(hippoRoot, config) {
-    const sessionCtx = loadSessionDecayContext(hippoRoot);
+function sessionDecayOptions(store, config) {
+    const sessionCtx = store.sessionDecayContext();
     return {
         decayBasis: config.decayBasis,
         avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
@@ -91,10 +92,12 @@ async function runPassesAfterDecay(run, fetcher) {
 }
 // A changed default half-life moves memories still on the old base first,
 // so this pass decays them at the new one (src/consolidate/half-life-migration.ts).
-function migrateHalfLives(hippoRoot, dryRun, result) {
-    const halfLife = migrateDefaultHalfLife(hippoRoot, loadConfig(hippoRoot).defaultHalfLifeDays, { dryRun });
+function migrateHalfLives(local, dryRun, result) {
+    const to = loadConfig(local.hippoRoot).defaultHalfLifeDays;
+    const halfLife = migrateDefaultHalfLife(local.consolidation, to, { dryRun });
     if (halfLife.rescaled > 0) {
-        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.rescaled} memories from the ${halfLife.from}-day to the ${halfLife.to}-day half-life`);
+        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.rescaled} memories from the ${halfLife.from}-day to the ` +
+            `${halfLife.to}-day half-life`);
     }
     if (halfLife.typed > 0) {
         result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.typed} memories of decisions, incidents and other objects ` +
@@ -109,8 +112,8 @@ async function flushPending(run, snapshot, budget) {
         return;
     const units = [...run.units, ...familyUnits(pendingWrites, pendingDeletes, pendingDormant, snapshot)];
     const components = groupFlush(pendingWrites, pendingDeletes, pendingDormant, units);
-    // The snapshot keeps what the DAG passes and other writers changed while sleep ran; the wait is sleep's own, not a server request's 250 ms.
-    const left = new Set(await commitInChunks(run.hippoRoot, components, { snapshot, budget, busyWaitMs: SLEEP_DB_WAIT_MS }));
+    // The snapshot keeps what the DAG passes and other writers changed while sleep ran.
+    const left = new Set(await run.store.commitFlush(components, { snapshot, budget }));
     for (const id of [...pendingDeletes, ...pendingDormant.map((m) => m.entry.id)]) {
         if (!left.has(id))
             result.details.push(`  ↩  ${id} not removed: pinned or already gone before sleep saved`);
@@ -119,44 +122,47 @@ async function flushPending(run, snapshot, budget) {
     result.removed = result.removedIds.length;
     result.dormant = pendingDormant.filter((m) => left.has(m.entry.id)).length;
 }
-// Dormant retention: a dormant memory nobody restored within dormant.retentionDays is deleted for good (0 keeps forever);
+// Dormant retention: a dormant memory nobody restored within dormant.retentionDays is deleted for good (0 keeps
+// forever);
 // runs even when dormant.enabled is off, so turning it off still ages out what earlier sleeps kept.
 async function expireDormant(run, budget) {
     const { config, result, dryRun } = run;
     if (!(config.dormant.retentionDays > 0))
         return;
     const cutoff = new Date(run.now.getTime() - config.dormant.retentionDays * DAY_MS).toISOString();
-    result.dormantExpired = await expireDormantBefore(run.hippoRoot, cutoff, { dryRun, budget, busyWaitMs: SLEEP_DB_WAIT_MS });
+    result.dormantExpired = await run.store.expireDormant(cutoff, { dryRun, budget });
     if (result.dormantExpired > 0) {
-        result.details.push(`  ⌛ ${dryRun ? 'would expire' : 'expired'} ${result.dormantExpired} dormant memor${result.dormantExpired === 1 ? 'y' : 'ies'} ` +
+        result.details.push(`  ⌛ ${dryRun ? 'would expire' : 'expired'} ${result.dormantExpired} dormant ` +
+            `memor${result.dormantExpired === 1 ? 'y' : 'ies'} ` +
             `older than ${config.dormant.retentionDays} days`);
     }
 }
 // 4. Log run
 function logRun(run, decay) {
-    const { hippoRoot, now, result } = run;
+    const { store, now, result } = run;
     const detectedConflicts = detectConflicts(run.survivors, now, run.decayOpts, decay.rescuedIds);
-    replaceDetectedConflicts(hippoRoot, detectedConflicts, now.toISOString());
+    store.replaceConflicts(detectedConflicts, now.toISOString());
     if (detectedConflicts.length > 0) {
         result.details.push(`  ⚠️ detected ${detectedConflicts.length} memory conflict${detectedConflicts.length === 1 ? '' : 's'}`);
     }
-    appendConsolidationRun(hippoRoot, {
+    store.recordRun({
         timestamp: now.toISOString(),
         decayed: result.decayed,
         merged: result.merged,
         removed: result.removed,
     });
-    incrementSleepCount(hippoRoot);
+    store.countSleep();
     if (decay.rescuedEntries.length > 0)
         auditRescues(run, decay);
 }
-// One audit row per rescue, written only after the last flush chunk commits, so a run stopped mid-flush asserts no rescue.
+// One audit row per rescue, written only after the last flush chunk commits, so a run stopped mid-flush asserts no
+// rescue.
 function auditRescues(run, { rescuedEntries, rankById }) {
     const { result } = run;
     const rescueEvent = (entry) => {
         const rank = rankById.get(entry.id);
         return {
-            tenantId: entry.tenantId,
+            tenantId: entry.tenant_id,
             actor: 'sleep',
             op: 'mv_rescue',
             targetId: entry.id,
@@ -167,10 +173,7 @@ function auditRescues(run, { rescuedEntries, rankById }) {
     };
     try {
         // Row by row: one failed audit write must not silently drop every remaining row.
-        const failed = recordAuditEventsRowByRow(run.hippoRoot, rescuedEntries.map(rescueEvent));
-        for (const { event, error } of failed)
-            reportAuditWriteFailure('mv_rescue', String(error), event.targetId);
-        const auditFailures = failed.length;
+        const auditFailures = run.store.auditEachRow(rescuedEntries.map(rescueEvent));
         if (auditFailures > 0) {
             result.details.push(`  ⚠️ memory-value: ${auditFailures} mv_rescue audit row${auditFailures === 1 ? '' : 's'} ` +
                 `failed to write (the rescue itself still landed)`);

package/dist/consolidate/trace.d.ts

@@ -1,4 +1,6 @@
-/** Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome, stored as markdown in `content`
+/**
+ * Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome,
+ * stored as markdown in `content`
  * (`renderTraceContent` formats it). */
 export interface TraceStep {
     action: string;
@@ -10,7 +12,10 @@ export interface TraceRecord {
     steps: TraceStep[];
     outcome: 'success' | 'failure' | 'partial';
 }
-/** Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation on an arrow line (omitted if empty). */
+/**
+ * Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation
+ * on an arrow line (omitted if empty).
+ */
 export declare function renderTraceContent(rec: TraceRecord): string;
 /**
  * Parse a JSON string into an array of TraceStep. Throws on invalid shape.

package/dist/consolidate/trace.js

@@ -1,8 +1,13 @@
-/** Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome, stored as markdown in `content`
+/**
+ * Trace-layer helpers. A trace is a `MemoryEntry` with `layer === 'trace'`: ordered agent actions and their outcome,
+ * stored as markdown in `content`
  * (`renderTraceContent` formats it). */
 import { isJsonString, isJsonObject } from '../util/json.js';
 import { errorMessage } from '../util/log.js';
-/** Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation on an arrow line (omitted if empty). */
+/**
+ * Render a trace record as agent-readable markdown: `Task:`, `Outcome:`, then numbered `Steps:` with each observation
+ * on an arrow line (omitted if empty).
+ */
 export function renderTraceContent(rec) {
     const lines = [];
     lines.push(`Task: ${rec.task}`);

package/dist/consolidate/traces.js

@@ -1,17 +1,16 @@
 import { isRecallBoostAblated, strengthAblation } from '../core/ablation.js';
 import { Layer, createMemory, markRetrieved } from '../core/memory.js';
-import { findPromotableSessions, traceExistsForSession, listSessionEvents } from '../store/sessions.js';
-import { rejectionDigest } from '../store/rejection.js';
+import { rejectionDigest } from '../core/rejection-digest.js';
 import { sampleForReplay } from './replay.js';
 import { renderTraceContent } from './trace.js';
-import { resolveTenantId } from '../store/tenant.js';
-import { reportAuditWriteFailure } from '../store/audit.js';
+import { envTenant } from '../util/env.js';
 import { commonDerivationScope } from '../core/recall-scope.js';
 import { log } from '../util/log.js';
 import { REPLAY_COUNT_DEFAULT } from './run.js';
 import { isJsonString } from '../util/json.js';
 import { DAY_MS } from '../util/time.js';
-// 1.4. Auto-promote complete sessions to traces: each session in the window with a `session_complete` event and no trace (idempotent via source_session_id)
+// 1.4. Auto-promote complete sessions to traces: each session in the window with a `session_complete` event and no
+// trace (idempotent via source_session_id)
 // is rendered as markdown and persisted as a Layer.Trace memory, which inherits decay, search, replay and physics.
 export function promoteSessionTraces(run) {
     const { result } = run;
@@ -22,8 +21,8 @@ export function promoteSessionTraces(run) {
     const sinceMs = run.now.getTime() - windowDays * DAY_MS;
     // Auto-trace runs single-tenant (the env-resolved tenant); consolidating
     // every tenant needs a per-tenant loop layered on top of this.
-    const consolidationTenant = resolveTenantId({});
-    const promotable = findPromotableSessions(run.hippoRoot, consolidationTenant, sinceMs);
+    const consolidationTenant = envTenant();
+    const promotable = run.store.promotableSessions(consolidationTenant, sinceMs);
     for (const session of promotable) {
         const built = sessionTrace(run, consolidationTenant, session.session_id);
         if (!built)
@@ -39,7 +38,8 @@ export function promoteSessionTraces(run) {
         result.details.push(`  🧬 promoted trace ${trace.id} from session ${session.session_id} (${outcome})`);
     }
     if (result.promotedTraces > 0) {
-        result.details.push(`  🧬 promoted ${result.promotedTraces} trace${result.promotedTraces === 1 ? '' : 's'} from completed session${result.promotedTraces === 1 ? '' : 's'}`);
+        result.details.push(`  🧬 promoted ${result.promotedTraces} trace${result.promotedTraces === 1 ? '' : 's'} from completed ` +
+            `session${result.promotedTraces === 1 ? '' : 's'}`);
     }
     if (tracesSkippedRejected > 0) {
         log.warn(`consolidate: skipped ${tracesSkippedRejected} auto-promoted trace(s) whose content matches a rejected value`);
@@ -48,9 +48,9 @@ export function promoteSessionTraces(run) {
 /** The trace a completed session renders to, or null when it already has one or cannot be promoted. */
 function sessionTrace(run, consolidationTenant, sessionId) {
     // Idempotency: skip if a trace for this session already exists.
-    if (traceExistsForSession(run.hippoRoot, consolidationTenant, sessionId))
+    if (run.store.traceExists(consolidationTenant, sessionId))
         return null;
-    const events = listSessionEvents(run.hippoRoot, consolidationTenant, {
+    const events = run.store.sessionEvents(consolidationTenant, {
         session_id: sessionId,
         limit: 1000,
     });
@@ -70,8 +70,8 @@ function sessionTrace(run, consolidationTenant, sessionId) {
         .map((e) => ({ action: e.content, observation: '' }));
     const trace = createMemory(renderTraceContent({ task: summary, steps, outcome }), {
         layer: Layer.Trace,
-        trace_outcome: outcome,
-        source_session_id: sessionId,
+        traceOutcome: outcome,
+        sourceSessionId: sessionId,
         tags: ['auto-promoted'],
         source: 'auto-promote',
         scope: sessionScope.scope,
@@ -103,32 +103,29 @@ function sessionEnding(events) {
 // sleep; check the tombstone under the entry's own stamped tenantId, never a guessed one.
 function traceRejected(run, trace, sessionId) {
     const traceDigest = rejectionDigest(trace.content);
-    const tombstone = run.tombstones.find(trace.tenantId, traceDigest);
+    const tombstone = run.tombstones.find(trace.tenant_id, traceDigest);
     if (!tombstone)
         return false;
-    try {
-        run.tombstones.audit({
-            tenantId: trace.tenantId,
-            actor: 'sleep',
-            op: 'reject_refusal',
-            metadata: {
-                digest: traceDigest,
-                reason: tombstone.reason,
-                sourceSessionId: sessionId,
-            },
-        });
-    }
-    catch (error) {
-        reportAuditWriteFailure('reject_refusal', String(error));
-    }
+    run.tombstones.auditOrCount({
+        tenantId: trace.tenant_id,
+        actor: 'sleep',
+        op: 'reject_refusal',
+        metadata: {
+            digest: traceDigest,
+            reason: tombstone.reason,
+            sourceSessionId: sessionId,
+        },
+    });
     return true;
 }
-// 1.5. Replay pass: rehearse high-value survivors by sampling N memories weighted by outcome, valence, under-rehearsal and idle time,
+// 1.5. Replay pass: rehearse high-value survivors by sampling N memories weighted by outcome, valence, under-rehearsal
+// and idle time,
 // then applying the `markRetrieved` strengthening, so important memories don't fade.
 export function replayPass(run) {
     const { survivors, now } = run;
     const replayCount = run.config.replay?.count ?? REPLAY_COUNT_DEFAULT;
-    // EVAL-ONLY ablation (see ablation.ts): replay rehearsal is recall strengthening, so the strengthen-off arm silences the whole pass;
+    // EVAL-ONLY ablation (see ablation.ts): replay rehearsal is recall strengthening, so the strengthen-off arm silences
+    // the whole pass;
     // persisting unmutated entries anyway would still refresh updated_at and mirrors.
     if (!(replayCount > 0 && survivors.length > 0 && !isRecallBoostAblated()))
         return;

package/dist/core/ablation.d.ts

@@ -1,5 +1,8 @@
-/** EVAL-ONLY ablation switches (HIPPO_ABLATE_*, HIPPO_EVAL_RECENCY_DAYS, HIPPO_FAKE_NOW): each cuts ONE mechanism (outcome also replayPriority bias).
- * Not a production surface. Env is read once per process; tests that mutate these vars MUST call _resetAblationCacheForTests() in beforeEach AND afterEach. See
+/**
+ * EVAL-ONLY ablation switches (HIPPO_ABLATE_*, HIPPO_EVAL_RECENCY_DAYS, HIPPO_FAKE_NOW): each cuts ONE mechanism
+ * (outcome also replayPriority bias).
+ * Not a production surface. Env is read once per process; tests that mutate these vars MUST call
+ * _resetAblationCacheForTests() in beforeEach AND afterEach. See
  * docs/ARCHITECTURE.md#srccoreablationts. */
 /** The three switches strength scoring honours, resolved by the entry layer and handed to core in DecayOptions. */
 export interface StrengthAblation {
@@ -18,7 +21,10 @@ export declare function isOutcomeFastAblated(): boolean;
 export declare function isRecencyAblated(): boolean;
 /** HIPPO_EVAL_RECENCY_DAYS when it is a positive number, else null (callers keep their default). */
 export declare function evalRecencyScaleDays(): number | null;
-/** The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and parseable, else the real clock; an explicit `now` parameter always wins. */
+/**
+ * The default `now` for lifecycle computations: HIPPO_FAKE_NOW when set and parseable, else the real clock; an explicit
+ * `now` parameter always wins.
+ */
 export declare function evalNow(): Date;
 /** Test-only. See module JSDoc: call in BOTH beforeEach AND afterEach. */
 export declare function _resetAblationCacheForTests(): void;