hippo-memory 2.0.0 → 2.1.0

package/dist/consolidate/merge.js

@@ -4,19 +4,22 @@ import { jaccardMinShared, overlapPartners } from './overlap-index.js';
 import { compareEntryIdentity } from '../core/compare.js';
 import { duplicateKey, mergedText } from '../util/same-text.js';
 import { successorAfterRetirement } from '../core/merged-row.js';
-import { rejectionDigest } from '../store/rejection.js';
-import { reportAuditWriteFailure } from '../store/audit.js';
+import { rejectionDigest } from '../core/rejection-digest.js';
 import { derivationScope, derivationPartitionKey } from '../core/recall-scope.js';
 import { jaccardSets } from './conflicts.js';
 import { keptAsWritten } from './run.js';
 import { isReusable } from '../core/memory-quality.js';
 const MERGE_OVERLAP_THRESHOLD = 0.35; // Jaccard similarity for "related"
 const MERGE_MIN_CLUSTER = 2; // minimum cluster size to merge
-const MERGE_MAX_SOURCES = 5; // with MERGE_MAX_CHARS, keeps a merged row near 500 tokens, a third of the 1,500-token context budget
+// with MERGE_MAX_CHARS, keeps a merged row near 500 tokens, a third of the 1,500-token context budget
+const MERGE_MAX_SOURCES = 5;
 const MERGE_MAX_CHARS = 2000; // total source text; sources past either cap stay unmerged and keep their half-life
-// Half-life scale for merged source episodics. Demote via half_life_days: calculateStrength() recomputes live strength and never reads the stored field,
+// Half-life scale for merged source episodics. Demote via half_life_days: calculateStrength() recomputes live strength
+// and never reads the stored field,
 // so a stored-strength write is inert for ranking and overwritten by the next decay pass.
 const MERGE_SOURCE_HALF_LIFE_FACTOR = 0.3;
+// deriveHalfLife grants its high-fit bonus only above 0.7, so a rollup at 0.7 gets none.
+const MERGED_SCHEMA_FIT = 0.7;
 export function retireHeldTexts(run) {
     const { survivors } = run;
     const byId = new Map(run.all.map((e) => [e.id, e]));
@@ -118,8 +121,10 @@ function mergeCluster(run, partition, cluster, related, used) {
         run.pendingWrites.push(semantic);
         run.units.push([semantic.id, ...cluster.map((e) => e.id)]);
         result.semanticCreated++;
-        // Scale half_life_days so merged sources decay sooner but stay recoverable; ranking is unchanged on purpose (demoting children regresses QA).
-        // Mutate in place: `cluster` shares references with `survivors`, and the later detectConflicts(survivors) must see the post-demotion half-life.
+        // Scale half_life_days so merged sources decay sooner but stay recoverable; ranking is unchanged on purpose
+        // (demoting children regresses QA).
+        // Mutate in place: `cluster` shares references with `survivors`, and the later detectConflicts(survivors) must see
+        // the post-demotion half-life.
         demoteMergedSources(run, cluster);
     }
     return true;
@@ -131,8 +136,8 @@ function semanticSummary(mergedContent, cluster, partition, baseHalfLifeDays) {
         ...createMemory(mergedContent, {
             layer: Layer.Semantic,
             tags: allTags,
-            emotional_valence: maxValence,
-            schema_fit: 0.7,
+            emotionalValence: maxValence,
+            schemaFit: MERGED_SCHEMA_FIT,
             source: 'consolidation',
             confidence: 'inferred',
             tenantId: partition.tenantId,
@@ -150,43 +155,45 @@ function demoteMergedSources(run, cluster) {
         run.pendingWrites.push(e);
     }
 }
-// mergeContents is deterministic, so a rollup a human already rejected would regenerate each cycle and batchWriteAndDelete's guard bypass would re-assert it;
-// this producer-side check makes that bypass safe. A hit skips the whole cluster (no demote, no delete) so a later sleep can retry.
+// mergeContents is deterministic, so a rollup a human already rejected would regenerate each cycle and
+// batchWriteAndDelete's guard bypass would re-assert it;
+// this producer-side check makes that bypass safe. A hit skips the whole cluster (no demote, no delete) so a later
+// sleep can retry.
 function mergeRejected(run, semantic, cluster, related, used) {
     const { tombstones } = run;
     const newDigest = rejectionDigest(semantic.content);
-    const oldDigest = rejectionDigest(legacyMergeContents(related)); // tombstones from older releases hold this format's digest
+    // tombstones from older releases hold this format's digest
+    const oldDigest = rejectionDigest(legacyMergeContents(related));
     const newHit = tombstones.find(semantic.tenant_id, newDigest);
     const tombstone = newHit ?? tombstones.find(semantic.tenant_id, oldDigest);
     const mergeDigest = newHit ? newDigest : oldDigest;
     if (!tombstone)
         return false;
-    // Still mark used: these members are not re-tried against a different cluster in this pass; the next sleep re-clusters them fresh.
-    const rejected = newHit ? cluster : related; // the old format digested the uncapped list, so rows past the cap were rejected too
+    // Still mark used: these members are not re-tried against a different cluster in this pass; the next sleep
+    // re-clusters them fresh.
+    // the old format digested the uncapped list, so rows past the cap were rejected too
+    const rejected = newHit ? cluster : related;
     for (const e of rejected)
         used.add(e.id);
-    try {
-        tombstones.audit({
-            tenantId: semantic.tenant_id,
-            actor: 'sleep',
-            op: 'reject_refusal',
-            metadata: {
-                digest: mergeDigest,
-                reason: tombstone.reason,
-                sourceIds: rejected.map((e) => e.id),
-            },
-        });
-    }
-    catch (error) {
-        reportAuditWriteFailure('reject_refusal', String(error));
-    }
+    tombstones.auditOrCount({
+        tenantId: semantic.tenant_id,
+        actor: 'sleep',
+        op: 'reject_refusal',
+        metadata: {
+            digest: mergeDigest,
+            reason: tombstone.reason,
+            sourceIds: rejected.map((e) => e.id),
+        },
+    });
     return true;
 }
 // Helpers
 function mergeContents(entries) {
-    // Each distinct text goes in once and in full (the merge demotes every source), one bullet with its lines indented, so heldTextKeys can read it back.
-    // Newest first says which version is current; compareEntryIdentity settles ties, so the row and its rejection digest depend only on the sources.
-    const sorted = [...entries].sort((a, b) => (Date.parse(b.created) - Date.parse(a.created)) || compareEntryIdentity(a, b));
+    // Each distinct text goes in once and in full (the merge demotes every source), one bullet with its lines indented,
+    // so heldTextKeys can read it back.
+    // Newest first says which version is current; compareEntryIdentity settles ties, so the row and its rejection digest
+    // depend only on the sources.
+    const sorted = [...entries].sort((a, b) => Date.parse(b.created) - Date.parse(a.created) || compareEntryIdentity(a, b));
     const texts = new Map();
     for (const e of sorted) {
         if (!texts.has(duplicateKey(e.content)))
@@ -213,7 +220,10 @@ function pickStrongestValence(entries) {
     }
     return 'neutral';
 }
-/** Maps i to each j > i, ascending, whose text overlap with i reaches the merge threshold; every text needs at least one token. */
+/**
+ * Maps i to each j > i, ascending, whose text overlap with i reaches the merge threshold; every text needs at least one
+ * token.
+ */
 export function mergePartners(contents) {
     const sets = contents.map((text) => new Set(tokenize(text)));
     const candidatesOf = overlapPartners(sets, jaccardMinShared(MERGE_OVERLAP_THRESHOLD));

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,38 +122,41 @@ 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) => {
@@ -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}`);