hippo-memory 1.71.0 → 2.0.0

package/dist/consolidate/dag.js

@@ -1,18 +1,24 @@
 import { createMemory, Layer } from '../core/memory.js';
 import { writeEntry, writeEntriesTogether } from '../store/entry-writes.js';
-import { loadAllDirtySummaries, loadChildrenOfSummary, applyRebuildResult, clearSummaryDirtyAfterBuild, } from '../store/summaries.js';
-import { RejectedValueError } from '../store/rejection.js';
+import { loadAllDirtySummaries, loadChildrenOfSummary, loadChildrenOfSummaries, childrenKey, applyRebuildResult, clearSummaryDirtyAfterBuild, } from '../store/summaries.js';
+import { RejectedValueError } from '../core/api-errors.js';
 import { generateDagSummary } from './dag-summary.js';
-import { derivationScope, derivationPartitionKey } from '../store/recall-scope.js';
+import { overlapPartners } from './overlap-index.js';
+import { derivationScope, derivationPartitionKey } from '../core/recall-scope.js';
 import { loadConfig } from '../core/config.js';
 import { neverAutoShareTags } from '../sharing/share.js';
 import { errorFields, errorMessage, log } from '../util/log.js';
 const SUMMARY_FALLBACK_CHARS = 40;
 const DEFAULT_REBUILD_CAP = 20;
+// Facts join a cluster when their tag sets overlap at least this much.
+const CLUSTER_JACCARD_MIN = 0.5;
 export function clusterFacts(facts) {
     if (facts.length === 0)
         return [];
     const entityTags = facts.map((f) => f.tags.filter((t) => t.startsWith('speaker:') || t.startsWith('topic:')));
+    const tagSets = entityTags.map((tags) => new Set(tags));
+    // Every tag indexed, not a prefix: a repeated tag counts twice in `shared`, so the prefix-filter bound would not hold.
+    const partnersOf = overlapPartners(tagSets, () => 1);
     const assigned = new Set();
     const clusters = [];
     for (let i = 0; i < facts.length; i++) {
@@ -20,19 +26,18 @@ export function clusterFacts(facts) {
             continue;
         const cluster = [i];
         assigned.add(i);
-        for (let j = i + 1; j < facts.length; j++) {
+        for (const j of partnersOf(i)) {
             if (assigned.has(j))
                 continue;
-            const shared = entityTags[i].filter((t) => entityTags[j].includes(t));
-            const union = new Set([...entityTags[i], ...entityTags[j]]);
-            const jaccard = union.size > 0 ? shared.length / union.size : 0;
-            if (jaccard >= 0.5) {
+            const shared = entityTags[i].filter((t) => tagSets[j].has(t)).length;
+            const inBoth = [...tagSets[i]].filter((t) => tagSets[j].has(t)).length;
+            if (shared / (tagSets[i].size + tagSets[j].size - inBoth) >= CLUSTER_JACCARD_MIN) {
                 cluster.push(j);
                 assigned.add(j);
             }
         }
         const members = cluster.map((idx) => facts[idx]);
-        const sharedTags = entityTags[cluster[0]].filter((t) => cluster.every((idx) => entityTags[idx].includes(t)));
+        const sharedTags = entityTags[cluster[0]].filter((t) => cluster.every((idx) => tagSets[idx].has(t)));
         const label = sharedTags
             .map((t) => t.split(':')[1])
             .join(': ') || members[0].content.slice(0, SUMMARY_FALLBACK_CHARS);
@@ -45,7 +50,7 @@ export function clusterFacts(facts) {
 function partitionFactsByTenant(unparented) {
     const unparentedByTenant = new Map();
     for (const fact of unparented) {
-        const key = derivationPartitionKey(fact.tenantId, fact.scope, fact.origin_project);
+        const key = derivationPartitionKey(fact.tenant_id, fact.scope, fact.origin_project);
         const bucket = unparentedByTenant.get(key);
         if (bucket)
             bucket.push(fact);
@@ -98,7 +103,7 @@ async function summarizeCluster(hippoRoot, cluster, home, opts, result) {
     result.factsLinked += writeEntriesTogether(hippoRoot, cluster.members.map((member) => ({ ...member, dag_parent_id: summaryEntry.id })));
     // Member writes just marked this fresh summary dirty; clear it, or the same sleep cycle's
     // rebuild pass would re-rebuild every new summary at twice the LLM cost.
-    clearSummaryDirtyAfterBuild(hippoRoot, summaryEntry.id, summaryEntry.tenantId, 'buildDag');
+    clearSummaryDirtyAfterBuild(hippoRoot, summaryEntry.id, summaryEntry.tenant_id, 'buildDag');
 }
 export async function buildDag(hippoRoot, facts, opts) {
     const result = { candidateClusters: 0, summariesCreated: 0, factsLinked: 0, rejected: 0 };
@@ -106,7 +111,7 @@ export async function buildDag(hippoRoot, facts, opts) {
     const unparented = facts.filter((f) => f.dag_level === 1 && !f.dag_parent_id && f.tags.includes('extracted'));
     for (const [, tenantFacts] of partitionFactsByTenant(unparented)) {
         const home = {
-            tenantId: tenantFacts[0].tenantId,
+            tenantId: tenantFacts[0].tenant_id,
             scope: derivationScope(tenantFacts[0].scope),
             originProject: tenantFacts[0].origin_project,
             baseHalfLifeDays,
@@ -121,8 +126,11 @@ export async function buildDag(hippoRoot, facts, opts) {
     return result;
 }
 /** Regenerate one dirty summary from its children and tally the outcome; throws reach the caller's isolation. */
-async function rebuildOneSummary(hippoRoot, summary, opts, result) {
-    const children = loadChildrenOfSummary(hippoRoot, summary.id, summary.tenantId);
+async function rebuildOneSummary(hippoRoot, summary, opts, result, preloaded, queuedIds) {
+    // A queued child may have been rebuilt earlier in this drain, so its preloaded content is stale: reread then.
+    const children = preloaded.some((c) => queuedIds.has(c.id))
+        ? loadChildrenOfSummary(hippoRoot, summary.id, summary.tenant_id)
+        : preloaded;
     if (children.length === 0) {
         clearZeroChildSummary(hippoRoot, summary, result);
         return;
@@ -179,7 +187,8 @@ function summaryLabel(summary) {
  * A concurrent sleep's second writer gets changed=false (UPDATE requires summary_dirty=1) and is skipped silently; a tombstone hit counts as `refused`. */
 export async function rebuildDirtySummaries(hippoRoot, opts) {
     const cap = opts.cap ?? DEFAULT_REBUILD_CAP;
-    const dirty = loadAllDirtySummaries(hippoRoot);
+    // One past the cap tells whether more were waiting without reading the rest.
+    const dirty = loadAllDirtySummaries(hippoRoot, cap + 1);
     const capped = dirty.length > cap;
     const queue = dirty.slice(0, cap);
     const result = {
@@ -190,6 +199,8 @@ export async function rebuildDirtySummaries(hippoRoot, opts) {
         failed: 0,
         capped,
     };
+    const childrenByParent = loadChildrenOfSummaries(hippoRoot, queue);
+    const queuedIds = new Set(queue.map((s) => s.id));
     for (const [index, summary] of queue.entries()) {
         // Yield the macrotask queue every 25 summaries: each iteration is synchronous SQLite, so a batch of up to 1000
         // would starve timers and IPC (server keep-alives, Vitest's birpc heartbeat).
@@ -197,13 +208,13 @@ export async function rebuildDirtySummaries(hippoRoot, opts) {
             await new Promise((resolve) => setImmediate(resolve));
         }
         try {
-            await rebuildOneSummary(hippoRoot, summary, opts, result);
+            await rebuildOneSummary(hippoRoot, summary, opts, result, childrenByParent.get(childrenKey(summary.tenant_id, summary.id)) ?? [], queuedIds);
         }
         catch (err) {
             // One throw doesn't abort the queue; log enough to triage an exotic
             // failure (SQLite I/O, prepare), since audit() already catches its own.
             result.failed++;
-            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenantId}) failed: ${errorMessage(err)}`, errorFields(err));
+            log.error(`rebuildDirtySummaries: summary ${summary.id} (tenant ${summary.tenant_id}) failed: ${errorMessage(err)}`, errorFields(err));
         }
     }
     return result;
@@ -269,7 +280,7 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
     const unparented = l2Summaries.filter((s) => s.dag_level === 2 && !s.dag_parent_id);
     for (const [, tenantL2s] of partitionFactsByTenant(unparented)) {
         const home = {
-            tenantId: tenantL2s[0].tenantId,
+            tenantId: tenantL2s[0].tenant_id,
             scope: derivationScope(tenantL2s[0].scope),
             originProject: tenantL2s[0].origin_project,
             baseHalfLifeDays,

package/dist/consolidate/dedupe.d.ts

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

package/dist/consolidate/dedupe.js

@@ -5,7 +5,7 @@ import { loadCurrentDistilledEntries } from '../store/entry-reads.js';
 import { deleteEntriesOneByOne, memoriesBackingObjects } from '../store/delete-and-batch.js';
 import { compareEntryIdentity } from '../core/compare.js';
 import { canAutoDelete } from '../core/memory.js';
-import { derivationPartitionKey } from '../store/recall-scope.js';
+import { derivationPartitionKey } from '../core/recall-scope.js';
 import { duplicateKey } from '../util/same-text.js';
 /** Quantization step for strength-tie comparisons: the 0.01 epsilon applied by rounding instead of an abs-diff threshold, so the tiebreak is transitive. */
 const STRENGTH_TIE_EPSILON = 0.01;
@@ -34,7 +34,7 @@ function entriesByPartition(entries) {
     const entriesByTenant = new Map();
     for (const entry of entries) {
         // EI2: also split by restricted scope, else a private copy can delete the readable one.
-        const key = derivationPartitionKey(entry.tenantId, entry.scope, entry.origin_project);
+        const key = derivationPartitionKey(entry.tenant_id, entry.scope, entry.origin_project);
         const bucket = entriesByTenant.get(key);
         if (bucket)
             bucket.push(entry);
@@ -73,18 +73,20 @@ function partitionPairs(tenantEntries, removed, backing) {
     }
     return [...groups.values()].flatMap((group) => group.pairs);
 }
+/** The rows loadCurrentDistilledEntries selects, picked from a whole-store read. */
+const isCurrentDistilled = (e) => (e.kind ?? 'distilled') === 'distilled' && !e.superseded_by;
 /** Remove the weaker copy of same-text (apart from spacing) memories within one tenant; cross-tenant pairs are never duplicates (isolation boundary).
  * Higher strength wins, then more retrievals; `threshold` is accepted for old callers and ignored. */
 export function deduplicateStore(hippoRoot, options = {}) {
     const dryRun = options.dryRun ?? false;
     // Only current distilled rows compete: raw rows are append-only (the delete
     // trigger would abort sleep mid-loop) and superseded rows are history.
-    const entries = loadCurrentDistilledEntries(hippoRoot);
+    const entries = options.loaded?.entries.filter(isCurrentDistilled) ?? loadCurrentDistilledEntries(hippoRoot);
     const entriesByTenant = entriesByPartition(entries);
     // Shared across tenant groups: ids are globally unique UUIDs, so `removed` cannot collide across tenants and deleteEntry deletes by primary key alone.
     const removed = new Set();
     const pairs = [];
-    const backing = memoriesBackingObjects(hippoRoot);
+    const backing = options.loaded?.backing ?? memoriesBackingObjects(hippoRoot);
     for (const tenantEntries of entriesByTenant.values()) {
         // The survivor total order (see the file-level docstring), scoped per
         // tenant group: the total order holds within a tenant only, matching the partition above.

package/dist/consolidate/llm-passes.js

@@ -1,8 +1,11 @@
 import { envAnthropicApiKey, envDagRebuildCap } from '../util/env.js';
 import { Layer } from '../core/memory.js';
-import { log } from '../util/log.js';
+import { errorFields, errorMessage, log } from '../util/log.js';
 import { keptAsWritten } from './run.js';
 import { isReusable } from '../core/memory-quality.js';
+import { isPermanentFailure } from '../util/anthropic-messages.js';
+// Bounds the LLM calls one sleep spends on extraction.
+const EXTRACTION_BATCH_LIMIT = 20;
 /** The key, model options and once-per-line error reporter every LLM phase shares. */
 function sleepLlm(run, fetcher) {
     const { config, result } = run;
@@ -28,21 +31,10 @@ export async function llmPasses(run, fetcher) {
     run.result.extractionCandidates = extractionCandidates.length;
     const llm = sleepLlm(run, fetcher);
     if (llm.apiKey && extractionCandidates.length > 0 && !run.dryRun) {
-        const { extractFacts, storeExtractedFacts } = await import('../learn/extract.js');
-        const batchLimit = 20;
-        let extractedCount = 0;
-        for (const candidate of extractionCandidates.slice(0, batchLimit)) {
-            try {
-                const facts = await extractFacts(candidate.content, { ...llm.llmOpts, onError: llm.llmError('extraction') });
-                if (facts.length > 0) {
-                    extractedCount += storeExtractedFacts(run.hippoRoot, candidate, facts).length;
-                }
-            }
-            catch (err) {
-                llm.llmError('extraction')(String(err));
-            }
-        }
-        run.result.extracted = extractedCount;
+        const stopped = await extractionPass(run, llm, extractionCandidates.slice(0, EXTRACTION_BATCH_LIMIT));
+        // The DAG passes call the same API with the same key and model, so they would fail the same way.
+        if (stopped)
+            return;
     }
     await dagBuildPass(run, llm);
     if (llm.apiKey && !run.dryRun) {
@@ -50,6 +42,37 @@ export async function llmPasses(run, fetcher) {
         await entityProfilePass(run, llm);
     }
 }
+/** Extracts facts from each candidate; true when it stopped on a failure every later call would repeat (bad key, no credit, unknown model). */
+async function extractionPass(run, llm, batch) {
+    const { extractFacts, storeExtractedFacts } = await import('../learn/extract.js');
+    const report = llm.llmError('extraction');
+    let extractedCount = 0;
+    let stopped = false;
+    const onError = (msg, failure) => {
+        report(msg);
+        if (failure && isPermanentFailure(failure))
+            stopped = true;
+    };
+    for (const [index, candidate] of batch.entries()) {
+        try {
+            const facts = await extractFacts(candidate.content, { ...llm.llmOpts, onError });
+            if (facts.length > 0) {
+                extractedCount += storeExtractedFacts(run.hippoRoot, candidate, facts).length;
+            }
+        }
+        catch (err) {
+            report(errorMessage(err));
+            log.warn('consolidate extraction threw', errorFields(err));
+        }
+        if (stopped) {
+            const skipped = batch.length - index - 1;
+            report(`stopped after a failure that will not clear on retry; ${skipped} of ${batch.length} candidates skipped, and the DAG passes with them`);
+            break;
+        }
+    }
+    run.result.extracted = extractedCount;
+    return stopped;
+}
 // 1.7. DAG summarization — cluster extracted facts and generate summaries
 async function dagBuildPass(run, { apiKey, llmError, llmOpts }) {
     const extractedFacts = run.survivors.filter((e) => e.tags.includes('extracted') && e.dag_level === 1 && !e.superseded_by && isReusable(e));
@@ -65,7 +88,8 @@ async function dagBuildPass(run, { apiKey, llmError, llmOpts }) {
         }
     }
     catch (err) {
-        llmError('dag')(String(err));
+        llmError('dag')(errorMessage(err));
+        log.warn('consolidate dag threw', errorFields(err));
     }
 }
 // 1.8. DAG summary rebuild: drain the summary_dirty queue set by child-write hooks; same apiKey/dryRun gate as buildDag.
@@ -99,7 +123,8 @@ async function dagRebuildPass(run, { llmError, llmOpts }) {
         }
     }
     catch (err) {
-        llmError('dag rebuild')(String(err));
+        llmError('dag rebuild')(errorMessage(err));
+        log.warn('consolidate dag rebuild threw', errorFields(err));
     }
 }
 // 1.9. DAG entity profiles: cluster L2 summaries into per-entity L3 profiles; runs even when 1.7 was skipped (re-clusters existing L2s every sleep).
@@ -118,7 +143,8 @@ async function entityProfilePass(run, { llmError, llmOpts }) {
         }
     }
     catch (err) {
-        llmError('dag profiles')(String(err));
+        llmError('dag profiles')(errorMessage(err));
+        log.warn('consolidate dag profiles threw', errorFields(err));
     }
 }
 //# sourceMappingURL=llm-passes.js.map

package/dist/consolidate/memory-value.js

@@ -1,6 +1,7 @@
 /** Learned memory-value scorer, a rescue-only veto in the sleep decay pass (it can only shrink the condemned set); mirrors benchmarks/memory-value/*.mjs.
  * rescueSet rescues a condemned entry iff it ranks in the top 30% (RESCUE_BUDGET) of its tenant's non-pinned set; memory-value-wiring.test.ts guards parity. */
 import { DEFAULT_TENANT_ID } from '../util/env.js';
+import { strengthAblation } from '../core/ablation.js';
 import { calculateStrength } from '../core/memory.js';
 import { compareEntryIdentity } from '../core/compare.js';
 import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from './memory-value-weights.js';
@@ -31,7 +32,7 @@ export function computeMvFeatures(entry, now) {
     return {
         age_days: ageDays,
         half_life_days: entry.half_life_days,
-        strength: calculateStrength(entry, now), // clock-basis, never decayOpts — see doc comment above
+        strength: calculateStrength(entry, now, { ablation: strengthAblation() }), // clock-basis, never the production decay basis — see doc comment above
         retrieval_count: entry.retrieval_count,
         outcome_positive: pos,
         outcome_negative: neg,
@@ -113,7 +114,7 @@ export function rankNonPinnedByTenant(entries, now, weights = MEMORY_VALUE_WEIGH
             continue; // pinned entries never compete for rescue (never condemned)
         // Default an undefined tenantId as dag.ts:341 does: a raw/legacy row can carry one at runtime,
         // and keying it "undefined" would split it into its own singleton tenant.
-        const tenantId = e.tenantId ?? DEFAULT_TENANT_ID;
+        const tenantId = e.tenant_id ?? DEFAULT_TENANT_ID;
         const list = byTenant.get(tenantId);
         if (list)
             list.push(e);

package/dist/consolidate/merge.js

@@ -3,10 +3,10 @@ import { tokenize } from '../util/tokenize.js';
 import { jaccardMinShared, overlapPartners } from './overlap-index.js';
 import { compareEntryIdentity } from '../core/compare.js';
 import { duplicateKey, mergedText } from '../util/same-text.js';
-import { successorAfterRetirement } from './merged-row.js';
+import { successorAfterRetirement } from '../core/merged-row.js';
 import { rejectionDigest } from '../store/rejection.js';
 import { reportAuditWriteFailure } from '../store/audit.js';
-import { derivationScope, derivationPartitionKey } from '../store/recall-scope.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';
@@ -23,7 +23,7 @@ export function retireHeldTexts(run) {
     const rejectedIn = (tenantId) => (text) => run.tombstones.find(tenantId, rejectionDigest(text)) !== null;
     for (let i = survivors.length - 1; i >= 0; i--) {
         const row = survivors[i];
-        const successor = run.retirable(row) ? successorAfterRetirement(row, byId, rejectedIn(row.tenantId)) : undefined;
+        const successor = run.retirable(row) ? successorAfterRetirement(row, byId, rejectedIn(row.tenant_id)) : undefined;
         if (successor === undefined)
             continue;
         run.result.details.push(`  ✂️  ${row.id} held a retired text${successor ? `, ${successor.id} holds the rest` : ''}`);
@@ -51,7 +51,7 @@ function partitionMergeCandidates(survivors) {
     // Map keeps insertion order, so a single-tenant store gets one partition in the original order.
     const mergeCandidatesByTenant = new Map();
     for (const entry of mergeCandidates) {
-        const key = derivationPartitionKey(entry.tenantId, entry.scope, entry.origin_project);
+        const key = derivationPartitionKey(entry.tenant_id, entry.scope, entry.origin_project);
         const bucket = mergeCandidatesByTenant.get(key);
         if (bucket)
             bucket.push(entry);
@@ -70,7 +70,7 @@ export function mergePass(run) {
     let mergesSkippedRejected = 0;
     for (const [, tenantCandidates] of mergeCandidatesByTenant) {
         const partition = {
-            tenantId: tenantCandidates[0].tenantId,
+            tenantId: tenantCandidates[0].tenant_id,
             scope: derivationScope(tenantCandidates[0].scope),
             origin: tenantCandidates[0].origin_project,
         };
@@ -156,8 +156,8 @@ 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
-    const newHit = tombstones.find(semantic.tenantId, newDigest);
-    const tombstone = newHit ?? tombstones.find(semantic.tenantId, oldDigest);
+    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;
@@ -167,7 +167,7 @@ function mergeRejected(run, semantic, cluster, related, used) {
         used.add(e.id);
     try {
         tombstones.audit({
-            tenantId: semantic.tenantId,
+            tenantId: semantic.tenant_id,
             actor: 'sleep',
             op: 'reject_refusal',
             metadata: {

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

@@ -1,3 +1,8 @@
+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): void;
+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),
+ * 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

@@ -3,8 +3,10 @@ import { loadStoredParticles, saveStoredParticles } from '../store/vector-index.
 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.
+const SLEEP_PHYSICS_MAX_PARTICLES = 1000;
 // 2. Physics simulation pass
-export function physicsPass(run) {
+export function physicsPass(run, maxParticles = SLEEP_PHYSICS_MAX_PARTICLES) {
     if (run.dryRun)
         return;
     const { config, result } = run;
@@ -12,27 +14,45 @@ export function physicsPass(run) {
         const physicsEnabled = config.physics.enabled === true
             || (config.physics.enabled === 'auto');
         if (physicsEnabled)
-            simulateStoredParticles(run);
+            simulateStoredParticles(run, maxParticles);
     }
     catch (error) {
         result.details.push(`  ⚠️ physics simulation skipped: ${errorMessage(error)}`);
     }
 }
-function simulateStoredParticles(run) {
+function simulateStoredParticles(run, maxParticles) {
     const { result, survivors } = run;
-    const particles = loadStoredParticles(run.hippoRoot);
-    if (particles.length === 0)
+    const stored = loadStoredParticles(run.hippoRoot);
+    if (stored.length === 0)
         return;
     // Build entry lookup for property refresh
     const entryMap = new Map(survivors.map(e => [e.id, e]));
+    const particles = particlesToSimulate(stored, entryMap, maxParticles);
     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, ` +
+    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),
+ * then particles with no survivor. */
+export function particlesToSimulate(stored, entries, max = SLEEP_PHYSICS_MAX_PARTICLES) {
+    if (stored.length <= max)
+        return stored;
+    const recalled = (p) => entries.get(p.memoryId)?.last_retrieved ?? '';
+    const ranked = [...stored].sort((a, b) => {
+        const [ra, rb] = [recalled(a), recalled(b)];
+        if (ra !== rb)
+            return ra < rb ? 1 : -1;
+        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.
+    return stored.filter((p) => kept.has(p));
+}
 function survivorForces(run) {
     // Build conflict pairs from survivors
     const conflictPairs = new Map();

package/dist/consolidate/replay.js

@@ -1,5 +1,6 @@
 /** 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';
 const VALENCE_WEIGHT = {
@@ -8,6 +9,12 @@ const VALENCE_WEIGHT = {
     negative: 1.5,
     critical: 2.0,
 };
+// Floor keeps every weight positive for sampleForReplay; the rest scale reward and idle boosts.
+const REWARD_FLOOR = 0.1;
+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. */
 export function replayPriority(entry, now, outcomeAblated) {
     const pos = entry.outcome_positive ?? 0;
@@ -16,18 +23,18 @@ export function replayPriority(entry, now, outcomeAblated) {
     // 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);
+        : Math.max(REWARD_FLOOR, 1 + pos * REWARD_POSITIVE_GAIN + (pos - neg) * REWARD_NET_GAIN);
     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;
+    const ageHours = Number.isFinite(deltaMs) ? Math.max(0, deltaMs / HOUR_MS) : 0;
+    const idleBoost = 1 + Math.log1p(ageHours) * IDLE_BOOST_GAIN;
     // 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);
+    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. */

package/dist/consolidate/sleep.js

@@ -1,5 +1,5 @@
 /** 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 { 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';
@@ -11,7 +11,7 @@ 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 { errorFields, 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';
@@ -68,6 +68,7 @@ function sessionDecayOptions(hippoRoot, config) {
         decayBasis: config.decayBasis,
         avgSessionIntervalDays: sessionCtx.avgSessionIntervalDays,
         sleepCount: sessionCtx.sleepCount,
+        ablation: strengthAblation(),
     };
 }
 /** Every pass between decay and the flush; the tombstone-check handle closes whichever of them throws. */
@@ -96,7 +97,8 @@ function migrateHalfLives(hippoRoot, dryRun, result) {
         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 from the ${LEGACY_TYPED_HALF_LIFE}-day to the ${halfLife.to}-day half-life`);
+        result.details.push(`  ⏳ ${dryRun ? 'would move' : 'moved'} ${halfLife.typed} memories of decisions, incidents and other objects ` +
+            `from the ${LEGACY_TYPED_HALF_LIFE}-day to the ${halfLife.to}-day half-life`);
     }
     return halfLife;
 }
@@ -126,7 +128,8 @@ async function expireDormant(run, budget) {
     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`);
+        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
@@ -153,7 +156,7 @@ function auditRescues(run, { rescuedEntries, rankById }) {
     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,
@@ -175,7 +178,7 @@ function auditRescues(run, { rescuedEntries, rankById }) {
     }
     catch (err) {
         // An audit store that will not open must never crash the mutation it records.
-        log.debug(`mv_rescue audit unavailable: ${errorMessage(err)}`);
+        log.warn(`mv_rescue audit unavailable: ${errorMessage(err)}`, { errorClass: errorFields(err).errorClass });
         result.details.push(`  ⚠️ memory-value: mv_rescue audit unavailable this cycle ` +
             `(${rescuedEntries.length} rescue${rescuedEntries.length === 1 ? '' : 's'} not audited)`);
     }

package/dist/consolidate/traces.js

@@ -1,4 +1,4 @@
-import { isRecallBoostAblated } from '../core/ablation.js';
+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';
@@ -6,7 +6,7 @@ import { sampleForReplay } from './replay.js';
 import { renderTraceContent } from './trace.js';
 import { resolveTenantId } from '../store/tenant.js';
 import { reportAuditWriteFailure } from '../store/audit.js';
-import { commonDerivationScope } from '../store/recall-scope.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';
@@ -103,12 +103,12 @@ 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,
+            tenantId: trace.tenant_id,
             actor: 'sleep',
             op: 'reject_refusal',
             metadata: {
@@ -136,7 +136,7 @@ export function replayPass(run) {
     const picked = sampleForReplay(survivors, replayCount, now, seed);
     if (picked.length === 0)
         return;
-    const rehearsed = markRetrieved(picked, now);
+    const rehearsed = markRetrieved(picked, now, { ablation: strengthAblation() });
     const rehearsedById = new Map(rehearsed.map((e) => [e.id, e]));
     // Update survivors in place so downstream passes see rehearsed state.
     for (let i = 0; i < survivors.length; i++) {

package/dist/core/ablation.d.ts

@@ -1,6 +1,16 @@
 /** 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 {
+    readonly decay: boolean;
+    readonly recallBoost: boolean;
+    readonly outcomeSlow: boolean;
+}
+/** Production scoring: nothing ablated. Core falls back to this, so it never reads the environment. */
+export declare const NO_STRENGTH_ABLATION: StrengthAblation;
+/** The frozen strength switches for this process; entry-layer callers pass them as `DecayOptions.ablation`. */
+export declare function strengthAblation(): StrengthAblation;
 export declare function isDecayAblated(): boolean;
 export declare function isRecallBoostAblated(): boolean;
 export declare function isOutcomeSlowAblated(): boolean;