hippo-memory 1.69.0 → 1.71.0

package/dist/{merged-row.d.ts → consolidate/merged-row.d.ts}

@@ -1,4 +1,4 @@
-import { type MemoryEntry } from './memory.js';
+import { type MemoryEntry } from '../core/memory.js';
 /** The row that replaces a merged row once its retired texts leave: undefined when it holds none, null when nothing else is left. */
 export declare function mergedSuccessor(row: MemoryEntry, retired: (text: string) => boolean, retiredIds: ReadonlySet<string>): MemoryEntry | null | undefined;
 /** Sleep's check on a merged row: drops texts whose source was superseded since the merge, or that a rejection now covers. */

package/dist/{merged-row.js → consolidate/merged-row.js}

@@ -1,7 +1,8 @@
 // A sleep-merged row copies its sources' texts, so retiring a text (reject, or superseding its source) must reach the row too.
-// SHORTCUT: reject rewrites merged rows at once, live and dormant; supersede and `resolve --reject-loser` wait for the next sleep's check, which sees a dormant row only once restored.
-import { generateId } from './memory.js';
-import { duplicateKey, heldTexts, mergedText } from './same-text.js';
+// SHORTCUT: reject rewrites merged rows at once, live and dormant; supersede and `resolve
+// --reject-loser` wait for the next sleep's check, which sees a dormant row only once restored.
+import { generateId } from '../core/memory.js';
+import { duplicateKey, heldTexts, mergedText } from '../util/same-text.js';
 /** The row that replaces a merged row once its retired texts leave: undefined when it holds none, null when nothing else is left. */
 export function mergedSuccessor(row, retired, retiredIds) {
     const texts = heldTexts(row);

package/dist/consolidate/physics-pass.js

@@ -1,60 +1,58 @@
-import { openHippoDb, closeHippoDb } from '../db.js';
-import { loadPhysicsState, savePhysicsState, refreshParticleProperties } from '../physics-state.js';
-import { simulate } from '../physics.js';
-// -------------------------------------------------------------------------
+import { refreshParticleProperties } from '../db/physics-state.js';
+import { loadStoredParticles, saveStoredParticles } from '../store/vector-index.js';
+import { simulate } from '../core/physics.js';
+import { errorMessage } from '../util/log.js';
+const STATS_DECIMALS = 4;
 // 2. Physics simulation pass
-// -------------------------------------------------------------------------
 export function physicsPass(run) {
     if (run.dryRun)
         return;
-    const { config, result, survivors } = run;
+    const { config, result } = run;
     try {
         const physicsEnabled = config.physics.enabled === true
             || (config.physics.enabled === 'auto');
-        if (physicsEnabled) {
-            const db = openHippoDb(run.hippoRoot);
-            try {
-                const physicsMap = loadPhysicsState(db);
-                const particles = Array.from(physicsMap.values());
-                if (particles.length > 0) {
-                    // Build entry lookup for property refresh
-                    const entryMap = new Map(survivors.map(e => [e.id, e]));
-                    refreshParticleProperties(particles, entryMap, run.now);
-                    // Build conflict pairs from survivors
-                    const conflictPairs = new Map();
-                    for (const entry of survivors) {
-                        if (entry.conflicts_with.length > 0) {
-                            const set = conflictPairs.get(entry.id) ?? new Set();
-                            for (const cid of entry.conflicts_with)
-                                set.add(cid);
-                            conflictPairs.set(entry.id, set);
-                        }
-                    }
-                    // Build half-life lookup
-                    const halfLives = new Map();
-                    for (const entry of survivors) {
-                        halfLives.set(entry.id, entry.half_life_days);
-                    }
-                    const ctx = {
-                        conflictPairs,
-                        halfLives,
-                        config: config.physics,
-                    };
-                    const stats = simulate(particles, ctx);
-                    savePhysicsState(db, particles);
-                    result.physicsSimulated = stats.particleCount;
-                    result.details.push(`  ⚛️  physics: ${stats.particleCount} particles, ` +
-                        `avg vel ${stats.avgVelocityMagnitude.toFixed(4)}, ` +
-                        `energy ${stats.energy.total.toFixed(4)}`);
-                }
-            }
-            finally {
-                closeHippoDb(db);
-            }
-        }
+        if (physicsEnabled)
+            simulateStoredParticles(run);
     }
     catch (error) {
-        result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
+        result.details.push(`  ⚠️ physics simulation skipped: ${errorMessage(error)}`);
+    }
+}
+function simulateStoredParticles(run) {
+    const { result, survivors } = run;
+    const particles = loadStoredParticles(run.hippoRoot);
+    if (particles.length === 0)
+        return;
+    // Build entry lookup for property refresh
+    const entryMap = new Map(survivors.map(e => [e.id, e]));
+    refreshParticleProperties(particles, entryMap, run.now);
+    const stats = simulate(particles, survivorForces(run));
+    saveStoredParticles(run.hippoRoot, particles);
+    result.physicsSimulated = stats.particleCount;
+    result.details.push(`  ⚛️  physics: ${stats.particleCount} particles, ` +
+        `avg vel ${stats.avgVelocityMagnitude.toFixed(STATS_DECIMALS)}, ` +
+        `energy ${stats.energy.total.toFixed(STATS_DECIMALS)}`);
+}
+function survivorForces(run) {
+    // Build conflict pairs from survivors
+    const conflictPairs = new Map();
+    for (const entry of run.survivors) {
+        if (entry.conflicts_with.length > 0) {
+            const set = conflictPairs.get(entry.id) ?? new Set();
+            for (const cid of entry.conflicts_with)
+                set.add(cid);
+            conflictPairs.set(entry.id, set);
+        }
+    }
+    // Build half-life lookup
+    const halfLives = new Map();
+    for (const entry of run.survivors) {
+        halfLives.set(entry.id, entry.half_life_days);
     }
+    return {
+        conflictPairs,
+        halfLives,
+        config: run.config.physics,
+    };
 }
 //# sourceMappingURL=physics-pass.js.map

package/dist/consolidate/replay.d.ts

@@ -0,0 +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. */
+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. */
+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. */
+export declare function sampleForReplay(survivors: MemoryEntry[], count: number, now: Date, seed?: number): MemoryEntry[];
+//# sourceMappingURL=replay.d.ts.map

package/dist/consolidate/replay.js

@@ -0,0 +1,84 @@
+/** 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 { isOutcomeSlowAblated } from '../core/ablation.js';
+import { resolveConfidence } from '../core/memory.js';
+const VALENCE_WEIGHT = {
+    neutral: 1.0,
+    positive: 1.3,
+    negative: 1.5,
+    critical: 2.0,
+};
+/** 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).
+    // 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
+        : Math.max(0.1, 1 + pos * 0.5 + (pos - neg) * 0.25);
+    const valence = VALENCE_WEIGHT[entry.emotional_valence] ?? 1.0;
+    // Under-rehearsed memories benefit most from replay.
+    const underRehearsed = 1 / (1 + (entry.retrieval_count ?? 0));
+    // Idle-time boost: memories that haven't been touched recently need rehearsal more.
+    const lastRetrieved = new Date(entry.last_retrieved);
+    const deltaMs = now.getTime() - lastRetrieved.getTime();
+    const ageHours = Number.isFinite(deltaMs) ? Math.max(0, deltaMs / 3_600_000) : 0;
+    const idleBoost = 1 + Math.log1p(ageHours) * 0.1;
+    // Weight by current strength so dead-and-decaying memories don't waste replay slots.
+    const rawStrength = Number.isFinite(entry.strength) ? entry.strength : 0;
+    const strengthFloor = Math.max(0.1, 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. */
+function mulberry32(seed) {
+    let s = seed >>> 0;
+    return () => {
+        let t = (s += 0x6D2B79F5);
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** 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. */
+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
+    // the stored value (it no longer carries the age-out case).
+    const eligible = survivors.filter((e) => resolveConfidence(e, now) !== 'stale');
+    if (eligible.length === 0)
+        return [];
+    const outcomeAblated = isOutcomeSlowAblated();
+    const pool = eligible.map((entry, idx) => ({
+        entry,
+        idx,
+        weight: replayPriority(entry, now, outcomeAblated),
+    }));
+    const want = Math.min(count, pool.length);
+    const chosen = [];
+    const taken = new Set();
+    for (let k = 0; k < want; k++) {
+        let totalW = 0;
+        for (const p of pool)
+            if (!taken.has(p.idx))
+                totalW += p.weight;
+        if (totalW <= 0)
+            break;
+        let r = rng() * totalW;
+        for (const p of pool) {
+            if (taken.has(p.idx))
+                continue;
+            r -= p.weight;
+            if (r <= 0) {
+                chosen.push(p.entry);
+                taken.add(p.idx);
+                break;
+            }
+        }
+    }
+    return chosen;
+}
+//# sourceMappingURL=replay.js.map

package/dist/consolidate/run.d.ts

@@ -1,12 +1,12 @@
-import { MemoryEntry, type DecayOptions } from '../memory.js';
-import { type DatabaseSyncLike } from '../db.js';
-import { type DormantMove } from '../dormant.js';
-import { loadConfig } from '../config.js';
+import { MemoryEntry, type DecayOptions } from '../core/memory.js';
+import { type DormantMove } from '../store/dormant.js';
+import { type TombstoneChecks } from '../store/tombstone-checks.js';
+import { loadConfig } from '../core/config.js';
 export interface ConsolidationResult {
     decayed: number;
     removed: number;
     /** Faded memories moved to the dormant store instead of deleted (config
-     *  `dormant.enabled`; src/dormant.ts). Always 0 when that is off. */
+     *  `dormant.enabled`; src/store/dormant.ts). Always 0 when that is off. */
     dormant: number;
     /** Dormant memories deleted for good this sleep because they outlived
      *  `dormant.retentionDays` without a restore. */
@@ -35,12 +35,6 @@ export interface ConsolidationResult {
 }
 export declare const REPLAY_COUNT_DEFAULT = 5;
 export declare function keptAsWritten(entry: MemoryEntry): boolean;
-/** The sleep's one tombstone-check handle: opened on first use, never under dryRun, closed once. */
-interface LazyDb {
-    get: () => DatabaseSyncLike | null;
-    close: () => void;
-}
-export declare function lazyConsolidateDb(hippoRoot: string, dryRun: boolean): LazyDb;
 /** 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. */
@@ -53,7 +47,8 @@ export interface SleepRun {
     result: ConsolidationResult;
     all: MemoryEntry[];
     retirable: (entry: MemoryEntry) => boolean;
-    getConsolidateDb: () => DatabaseSyncLike | null;
+    /** 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[];
     pendingDeletes: string[];
@@ -61,5 +56,4 @@ export interface SleepRun {
     units: string[][];
 }
 export declare function newConsolidationResult(dryRun: boolean): ConsolidationResult;
-export {};
 //# sourceMappingURL=run.d.ts.map

package/dist/consolidate/run.js

@@ -1,46 +1,15 @@
-import { openHippoDb, closeHippoDb, ftsRowCounts, isFtsAvailable, repairFtsDrift } from '../db.js';
-import { NO_MERGE_TAGS } from '../shared.js';
+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));
 }
-// Auto-promote (1.4) and merge (3) write deterministic content through the guard's bypass, so both
-// need this tombstone check. Lazy so a sleep reaching neither never opens it; call it IMMEDIATELY
-// before the try whose finally closes it, so a throw in any phase cannot leak the handle.
-export function lazyConsolidateDb(hippoRoot, dryRun) {
-    let consolidateDbHandle = null;
-    let consolidateDbOpened = false;
-    const get = () => {
-        if (dryRun)
-            return null;
-        if (!consolidateDbOpened) {
-            consolidateDbHandle = openHippoDb(hippoRoot);
-            consolidateDbOpened = true;
-        }
-        return consolidateDbHandle;
-    };
-    const close = () => {
-        if (consolidateDbHandle)
-            closeHippoDb(consolidateDbHandle);
-    };
-    return { get, close };
-}
 /** 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 db = openHippoDb(hippoRoot);
-    try {
-        if (!isFtsAvailable(db))
-            return;
-        const counts = ftsRowCounts(db);
-        if (counts === null || counts.memories === counts.fts)
-            return;
-        if (!dryRun)
-            repairFtsDrift(db);
-        result.details.push(`  🔎 ${dryRun ? 'would re-sync' : 're-synced'} the full-text index (${counts.fts} indexed rows for ${counts.memories} memories)`);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const counts = ftsDrift(hippoRoot, !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)`);
 }
 export function newConsolidationResult(dryRun) {
     return {

package/dist/consolidate/sleep.d.ts

@@ -1,12 +1,5 @@
-/**
- * Consolidation engine ("Sleep") for Hippo.
- *
- * Steps:
- * 1. Decay pass  - remove entries below strength threshold
- * 2. Merge pass  - find episodic entries with high text overlap, create semantic summaries
- * 3. Stats tracking
- */
-import { type WriteBudget } from '../write-budget.js';
+/** 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.

package/dist/consolidate/sleep.js

@@ -1,33 +1,27 @@
-/**
- * Consolidation engine ("Sleep") for Hippo.
- *
- * Steps:
- * 1. Decay pass  - remove entries below strength threshold
- * 2. Merge pass  - find episodic entries with high text overlap, create semantic summaries
- * 3. Stats tracking
- */
-import { evalNow } from '../ablation.js';
-import { canAutoDelete } from '../memory.js';
-import { loadAllEntries } from '../store/entry-reads.js';
-import { batchWriteAndDeleteOn, memoriesBackingObjects, noteFailedUnit } from '../store/delete-and-batch.js';
-import { openStore } from '../store/open.js';
+/** Consolidation engine ("Sleep"): decay pass (drop entries below the strength threshold), merge pass (semantic summaries of overlapping episodics), stats. */
+import { evalNow } 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 { openHippoDb, closeHippoDb, SLEEP_DB_WAIT_MS } from '../db.js';
-import { deleteExpiredDormantRow, expiredDormantKeys } from '../dormant.js';
-import { loadConfig } from '../config.js';
-import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
-import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from '../half-life-migration.js';
-import { log } from '../log.js';
-import { WRITE_BUDGET } from '../write-budget.js';
+import { SLEEP_DB_WAIT_MS } from '../db/index.js';
+import { expireDormantBefore } from '../store/dormant.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 { errorMessage, log } from '../util/log.js';
+import { WRITE_BUDGET } from '../util/write-budget.js';
 import { decayPass } from './decay.js';
 import { familyUnits, groupFlush } from './flush-units.js';
 import { retireHeldTexts, mergePass } from './merge.js';
 import { detectConflicts } from './conflicts.js';
-import { lazyConsolidateDb, newConsolidationResult, syncFtsIndex } from './run.js';
+import { newConsolidationResult, syncFtsIndex } from './run.js';
 import { promoteSessionTraces, replayPass } from './traces.js';
 import { llmPasses } from './llm-passes.js';
 import { physicsPass } from './physics-pass.js';
+import { DAY_MS } from '../util/time.js';
 /**
  * Run a full consolidation pass.
  */
@@ -39,26 +33,18 @@ export async function consolidate(hippoRoot, options = {}) {
     syncFtsIndex(hippoRoot, 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 all = loadAllEntries(hippoRoot);
+    const { entries: all, base: snapshot } = loadAllEntriesWithBase(hippoRoot);
     if (dryRun)
         for (const e of all)
             e.half_life_days = halfLife.halfLives.get(e.id) ?? e.half_life_days;
     const backingObjects = memoriesBackingObjects(hippoRoot);
     // 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 snapshot = new Map(structuredClone(all).map((e) => [e.id, e]));
-    // Load decay options from config + session context
     const config = loadConfig(hippoRoot);
-    const sessionCtx = loadSessionDecayContext(hippoRoot);
-    const decayOpts = {
-        decayBasis: config.decayBasis,
-        avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
-        sleepCount: sessionCtx.sleepCount,
-    };
-    const consolidateDb = lazyConsolidateDb(hippoRoot, dryRun);
+    const decayOpts = sessionDecayOptions(hippoRoot, config);
     const run = {
         hippoRoot, now, dryRun, config, decayOpts, result, all, retirable,
-        getConsolidateDb: consolidateDb.get,
+        tombstones: lazyTombstoneChecks(hippoRoot, dryRun),
         survivors: [],
         // Collect all writes/deletes and batch them at the end
         pendingWrites: [],
@@ -67,30 +53,43 @@ export async function consolidate(hippoRoot, options = {}) {
         units: [],
     };
     const decay = decayPass(run);
+    await runPassesAfterDecay(run, options.fetcher);
+    const budget = options.budget ?? WRITE_BUDGET;
+    await flushPending(run, snapshot, budget);
+    await expireDormant(run, budget);
+    if (!dryRun)
+        logRun(run, decay);
+    return result;
+}
+// Load decay options from config + session context
+function sessionDecayOptions(hippoRoot, config) {
+    const sessionCtx = loadSessionDecayContext(hippoRoot);
+    return {
+        decayBasis: config.decayBasis,
+        avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
+        sleepCount: sessionCtx.sleepCount,
+    };
+}
+/** Every pass between decay and the flush; the tombstone-check handle closes whichever of them throws. */
+async function runPassesAfterDecay(run, fetcher) {
     let mergesSkippedRejected = 0;
     try {
         promoteSessionTraces(run);
         replayPass(run);
-        await llmPasses(run, options.fetcher);
+        await llmPasses(run, fetcher);
         physicsPass(run);
         retireHeldTexts(run);
         mergesSkippedRejected = mergePass(run);
     }
     finally {
-        consolidateDb.close();
+        run.tombstones.close();
     }
     if (mergesSkippedRejected > 0) {
         log.warn(`consolidate: skipped ${mergesSkippedRejected} merge(s) whose content matches a rejected value`);
     }
-    const budget = options.budget ?? WRITE_BUDGET;
-    await flushPending(run, snapshot, budget);
-    await expireDormant(run, budget);
-    if (!dryRun)
-        logRun(run, decay);
-    return result;
 }
 // A changed default half-life moves memories still on the old base first,
-// so this pass decays them at the new one (src/half-life-migration.ts).
+// 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 });
     if (halfLife.rescaled > 0) {
@@ -108,7 +107,8 @@ async function flushPending(run, snapshot, budget) {
         return;
     const units = [...run.units, ...familyUnits(pendingWrites, pendingDeletes, pendingDormant, snapshot)];
     const components = groupFlush(pendingWrites, pendingDeletes, pendingDormant, units);
-    const left = new Set(await commitInChunks(run.hippoRoot, components, snapshot, budget));
+    // 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 }));
     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`);
@@ -117,92 +117,19 @@ async function flushPending(run, snapshot, budget) {
     result.removed = result.removedIds.length;
     result.dormant = pendingDormant.filter((m) => left.has(m.entry.id)).length;
 }
-/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids that left `memories`.
- *  The snapshot keeps what the DAG passes and other writers changed while sleep ran. */
-async function commitInChunks(hippoRoot, components, snapshot, budget) {
-    if (components.length === 0)
-        return [];
-    const removed = [];
-    // Its own wait, not a server request's 250 ms, and an option rather than a PRAGMA so a shared hook handle keeps its own.
-    const db = openStore(hippoRoot, { busyWaitMs: SLEEP_DB_WAIT_MS });
-    let next = 0;
-    try {
-        let committedAt = 0;
-        while (next < components.length) {
-            if (next > 0)
-                await budget.pause(committedAt);
-            const chunk = batchWriteAndDeleteOn(db, hippoRoot, components, next, { snapshot, holdMs: budget.holdMs, clock: budget.clock });
-            committedAt = budget.clock();
-            next = chunk.next;
-            for (const id of chunk.removedIds)
-                removed.push(id);
-        }
-    }
-    catch (err) {
-        // A unit that threw is already tagged; a throw outside one (a pause, BEGIN or COMMIT) names the chunk's first unit.
-        if (err instanceof Error)
-            noteFailedUnit(err, components[next]);
-        throw err;
-    }
-    finally {
-        closeHippoDb(db);
-    }
-    return removed;
-}
-/** Deletes `keys` in transactions of about `budget.holdMs`, letting other writers in between; returns how many went. */
-async function expireInChunks(db, keys, cutoff, budget) {
-    let gone = 0;
-    let next = 0;
-    let committedAt = 0;
-    while (next < keys.length) {
-        if (next > 0)
-            await budget.pause(committedAt);
-        db.exec('BEGIN IMMEDIATE');
-        const begunAt = budget.clock();
-        try {
-            do
-                gone += deleteExpiredDormantRow(db, keys[next++], cutoff);
-            while (next < keys.length && budget.clock() - begunAt < budget.holdMs);
-            db.exec('COMMIT');
-        }
-        catch (err) {
-            if (db.isTransaction !== false) {
-                try {
-                    db.exec('ROLLBACK');
-                }
-                catch { /* preserve the original throw */ }
-            }
-            throw err;
-        }
-        committedAt = budget.clock();
-    }
-    return gone;
-}
-// Dormant retention: a dormant memory nobody restored within
-// dormant.retentionDays is deleted for good (0 keeps them forever). Runs
-// even when dormant.enabled is off, so turning it off still ages out what
-// earlier sleeps kept.
+// 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 * 24 * 60 * 60 * 1000).toISOString();
-    const db = openHippoDb(run.hippoRoot, { busyWaitMs: SLEEP_DB_WAIT_MS });
-    try {
-        // The keys come from a read, so a sleep with nothing to expire never takes the write lock; one DELETE scanned every stored entry under it.
-        const keys = expiredDormantKeys(db, cutoff);
-        result.dormantExpired = dryRun ? keys.length : await expireInChunks(db, keys, cutoff, budget);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    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 });
     if (result.dormantExpired > 0) {
         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 detectedConflicts = detectConflicts(run.survivors, now, run.decayOpts, decay.rescuedIds);
@@ -223,41 +150,32 @@ function logRun(run, decay) {
 // 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,
+            actor: 'sleep',
+            op: 'mv_rescue',
+            targetId: entry.id,
+            metadata: rank
+                ? { rank: rank.rank, totalNonPinned: rank.totalNonPinned, keepN: rank.keepN, score: rank.score }
+                : {},
+        };
+    };
     try {
-        const auditDb = openHippoDb(run.hippoRoot);
-        try {
-            // Per-row try/catch: one failed appendAuditEvent must not silently drop every remaining row.
-            let auditFailures = 0;
-            for (const entry of rescuedEntries) {
-                try {
-                    const rank = rankById.get(entry.id);
-                    appendAuditEvent(auditDb, {
-                        tenantId: entry.tenantId,
-                        actor: 'sleep',
-                        op: 'mv_rescue',
-                        targetId: entry.id,
-                        metadata: rank
-                            ? { rank: rank.rank, totalNonPinned: rank.totalNonPinned, keepN: rank.keepN, score: rank.score }
-                            : {},
-                    });
-                }
-                catch (error) {
-                    auditFailures++;
-                    reportAuditWriteFailure('mv_rescue', String(error), entry.id);
-                }
-            }
-            if (auditFailures > 0) {
-                result.details.push(`  ⚠️ memory-value: ${auditFailures} mv_rescue audit row${auditFailures === 1 ? '' : 's'} ` +
-                    `failed to write (the rescue itself still landed)`);
-            }
-        }
-        finally {
-            closeHippoDb(auditDb);
+        // 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;
+        if (auditFailures > 0) {
+            result.details.push(`  ⚠️ memory-value: ${auditFailures} mv_rescue audit row${auditFailures === 1 ? '' : 's'} ` +
+                `failed to write (the rescue itself still landed)`);
         }
     }
-    catch {
-        // openHippoDb/closeHippoDb-level failure: audit must never crash a
-        // mutation (mirrors store.ts's audit() posture).
+    catch (err) {
+        // An audit store that will not open must never crash the mutation it records.
+        log.debug(`mv_rescue audit unavailable: ${errorMessage(err)}`);
         result.details.push(`  ⚠️ memory-value: mv_rescue audit unavailable this cycle ` +
             `(${rescuedEntries.length} rescue${rescuedEntries.length === 1 ? '' : 's'} not audited)`);
     }