hippo-memory 1.60.0 → 1.61.0

package/dist/consolidate/decay.js

@@ -0,0 +1,145 @@
+import { calculateStrength } from '../memory.js';
+import { detectSecret } from '../secret-detect.js';
+import { rescueSet, rankNonPinnedByTenant, validateWeights } from '../memory-value.js';
+import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from '../memory-value-weights.js';
+export const DECAY_THRESHOLD = 0.05;
+// A faded, unpinned, unrescued memory leaves active memory one of three
+// ways. A raw receipt is append-only: trg_memories_raw_append_only aborts
+// a DELETE, and with it this whole cycle's batch and every later sleep,
+// so it stays where it is (stored strength refreshed) but sits out the
+// rest of this cycle the way a deleted row would. Anything else goes
+// dormant when config.dormant is on, and is deleted otherwise.
+// Only called for rows `retirable` allows (never pinned, raw, kept for good or backing a first-class object).
+function retireFaded(run, entry, strength) {
+    const { result } = run;
+    const why = `(strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`;
+    // A faded secret is deleted, never kept dormant: keeping it would hold a
+    // credential on disk that the user reasonably expects forgetting removed.
+    if (run.config.dormant.enabled && !detectSecret(entry).flagged) {
+        result.dormant++;
+        result.details.push(`  💤 dormant ${entry.id} ${why}`);
+        run.pendingDormant.push({ entry: { ...entry, strength }, strength, reason: 'decay', dormantAt: run.now.toISOString() });
+        return;
+    }
+    result.removed++;
+    result.details.push(`  🗑  removed ${entry.id} ${why}`);
+    run.pendingDeletes.push(entry.id);
+}
+/** Keeps an entry with its live strength cached; only strength is a cached computation, confidence stays as stored. */
+function keepSurvivor(run, entry, strength) {
+    const updated = { ...entry, strength };
+    run.survivors.push(updated);
+    if (!run.dryRun && strength !== entry.strength) {
+        run.pendingWrites.push(updated);
+    }
+    run.result.decayed++;
+    return updated;
+}
+// -------------------------------------------------------------------------
+// 1. Decay pass
+// -------------------------------------------------------------------------
+// LC2-E3 (opt-in, default off; docs/plans/2026-08-10-lc2-e3-mv-wiring.md):
+// flag OFF keeps the single-phase loop below byte-identical to pre-E3
+// behavior (pre-registered gate G2). Flag ON restructures into two phases:
+// phase 1 classifies every entry (condemned vs survivor) with ZERO
+// commits; phase 2 runs rescueSet over the per-tenant candidate groups,
+// then commits — rescued entries get the standard survivor bookkeeping
+// refresh (stored strength + effective confidence; no half-life edits, no
+// rank-derived writes) and are pushed to survivors so they fully
+// participate in this cycle's merge/physics/conflict passes; non-rescued
+// condemned entries follow the existing pendingDeletes/result.removed/
+// details path.
+export function decayPass(run) {
+    if (run.config.memoryValue.enabled)
+        return decayWithMemoryValue(run);
+    for (const entry of run.all) {
+        const strength = calculateStrength(entry, run.now, run.decayOpts);
+        if (run.retirable(entry) && strength < DECAY_THRESHOLD) {
+            retireFaded(run, entry, strength);
+        }
+        else {
+            keepSurvivor(run, entry, strength);
+        }
+    }
+    return { rescuedIds: new Set(), rescuedEntries: [], rankById: new Map() };
+}
+// A non-finite feature (e.g. a malformed `created`) scores -Infinity and can never be
+// rescued, so name those entries in one warning rather than leave it a silent NaN detail.
+function reportNonFiniteScores(result, rankById) {
+    const nonFiniteIds = [...rankById.entries()]
+        .filter(([, info]) => !Number.isFinite(info.score))
+        .map(([id]) => id);
+    if (nonFiniteIds.length > 0) {
+        result.details.push(`  ⚠️ memory-value: skipped ${nonFiniteIds.length} entr${nonFiniteIds.length === 1 ? 'y' : 'ies'} ` +
+            `with non-finite computed features (never rescued): ${nonFiniteIds.join(', ')}`);
+    }
+}
+function decayWithMemoryValue(run) {
+    const { all, now, result } = run;
+    // Carried forward to logRun, where the mv_rescue audit rows are actually
+    // written (code-review fix: writing them here, before batchWriteAndDelete,
+    // would assert rescues for a cycle whose effects might never land if a
+    // later phase throws).
+    const rescuedEntries = [];
+    let rescuedIds = new Set();
+    let rankById = new Map();
+    // --- Phase 1: classify (zero commits) ---
+    const condemned = [];
+    const strengthById = new Map();
+    for (const entry of all) {
+        const strength = calculateStrength(entry, now, run.decayOpts);
+        strengthById.set(entry.id, strength);
+        if (run.retirable(entry) && strength < DECAY_THRESHOLD) {
+            condemned.push(entry);
+        }
+    }
+    // --- Phase 2a: rescue decision (pure compute) ---
+    // Runs under --dry-run too (only the pendingDeletes flush and the audit write in
+    // logRun stay !dryRun-gated), so the preview matches what a
+    // real run would decide.
+    const condemnedIds = new Set(condemned.map((e) => e.id));
+    // Fail-loud must not depend on condemnation traffic (round-2 code-review
+    // P2-2): validate the frozen weights constant unconditionally, even on a
+    // sleep with nothing condemned.
+    validateWeights();
+    if (condemnedIds.size > 0) {
+        // Compute the per-tenant ranking ONCE (round-2 code-review P2-2):
+        // rankById feeds both rescueSet's decision (via precomputedRanks,
+        // skipping its own internal rankNonPinnedByTenant call) and the
+        // detail/audit rank context below, so the whole-store ranking pass
+        // runs a single time per sleep instead of twice, and only when there
+        // is actually something condemned to rank against.
+        rankById = rankNonPinnedByTenant(all, now);
+        rescuedIds = rescueSet(all, condemnedIds, now, MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256, rankById);
+        reportNonFiniteScores(result, rankById);
+    }
+    // --- Phase 2b: commit, one pass over `all` in ITS ORIGINAL ORDER ---
+    // (review-round F4: rescued entries used to be appended at the tail of
+    // survivors, systematically starving them in downstream order-sensitive
+    // passes like extraction's slice(0,20) — a single pass over `all`
+    // preserves flag-off's ordering semantics exactly.)
+    for (const entry of all) {
+        const strength = strengthById.get(entry.id);
+        if (run.retirable(entry) && strength < DECAY_THRESHOLD) {
+            if (rescuedIds.has(entry.id)) {
+                // Rescued (D1): standard survivor stored-strength refresh (P2-1).
+                // Confidence is left alone here: it is an epistemic tier, not a
+                // cached computation, so resolveConfidence derives it on read.
+                rescuedEntries.push(keepSurvivor(run, entry, strength));
+                const rank = rankById.get(entry.id);
+                const rankNote = rank
+                    ? ` - rescued (rank ${rank.rank}/${rank.totalNonPinned} in tenant ${rank.tenantId}, top ${rank.keepN})`
+                    : ' - rescued';
+                result.details.push(`  🛟 ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})${rankNote}`);
+            }
+            else {
+                retireFaded(run, entry, strength);
+            }
+        }
+        else {
+            keepSurvivor(run, entry, strength);
+        }
+    }
+    return { rescuedIds, rescuedEntries, rankById };
+}
+//# sourceMappingURL=decay.js.map

package/dist/consolidate/llm-passes.d.ts

@@ -0,0 +1,3 @@
+import { type SleepRun } from './run.js';
+export declare function llmPasses(run: SleepRun, fetcher: typeof fetch | undefined): Promise<void>;
+//# sourceMappingURL=llm-passes.d.ts.map

package/dist/consolidate/llm-passes.js

@@ -0,0 +1,141 @@
+import { envAnthropicApiKey, envDagRebuildCap } from '../env.js';
+import { Layer } from '../memory.js';
+import { log } from '../log.js';
+import { keptAsWritten } from './run.js';
+/** The key, model options and once-per-line error reporter every LLM phase shares. */
+function sleepLlm(run, fetcher) {
+    const { config, result } = run;
+    // extraction.enabled=false is the opt-out for every LLM phase below, key or no key.
+    const apiKey = config.extraction.enabled !== false ? (envAnthropicApiKey() ?? '') : '';
+    const llmErrorsSeen = new Set();
+    const llmError = (phase) => (msg) => {
+        const line = `  ⚠️ ${phase}: ${msg}`;
+        if (llmErrorsSeen.has(line))
+            return;
+        llmErrorsSeen.add(line);
+        result.details.push(line);
+        log.warn(`consolidate ${phase}: ${msg}`);
+    };
+    const llmOpts = { apiKey, model: config.extraction.model, fetcher };
+    return { apiKey, llmError, llmOpts };
+}
+export async function llmPasses(run, fetcher) {
+    // -------------------------------------------------------------------------
+    // 1.6. Batch extraction — extract facts from episodic memories missing them
+    // -------------------------------------------------------------------------
+    const extractedFromIds = new Set(run.survivors.filter((e) => e.extracted_from).map((e) => e.extracted_from));
+    const extractionCandidates = run.survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !extractedFromIds.has(e.id) && !keptAsWritten(e));
+    run.result.extractionCandidates = extractionCandidates.length;
+    const llm = sleepLlm(run, fetcher);
+    if (llm.apiKey && extractionCandidates.length > 0 && !run.dryRun) {
+        const { extractFacts, storeExtractedFacts } = await import('../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) {
+                    storeExtractedFacts(run.hippoRoot, candidate, facts);
+                    extractedCount += facts.length;
+                }
+            }
+            catch (err) {
+                llm.llmError('extraction')(String(err));
+            }
+        }
+        run.result.extracted = extractedCount;
+    }
+    await dagBuildPass(run, llm);
+    if (llm.apiKey && !run.dryRun) {
+        await dagRebuildPass(run, llm);
+        await entityProfilePass(run, llm);
+    }
+}
+// -------------------------------------------------------------------------
+// 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);
+    if (!(apiKey && extractedFacts.length >= 3 && !run.dryRun))
+        return;
+    try {
+        const { buildDag } = await import('../dag.js');
+        const dagResult = await buildDag(run.hippoRoot, extractedFacts, { ...llmOpts, onError: llmError('dag') });
+        run.result.dagCandidateClusters = dagResult.candidateClusters;
+        run.result.dagSummariesCreated = dagResult.summariesCreated;
+        if (dagResult.summariesCreated > 0) {
+            run.result.details.push(`  🌳 DAG: ${dagResult.summariesCreated} summaries created, ${dagResult.factsLinked} facts linked`);
+        }
+    }
+    catch (err) {
+        llmError('dag')(String(err));
+    }
+}
+// -------------------------------------------------------------------------
+// 1.8. DAG summary rebuild — drain dirty queue from E2's child-write hooks
+// -------------------------------------------------------------------------
+// Consumer of E2's summary_dirty flag. Walks dirty L2 summaries, regenerates
+// each via generateDagSummary, atomically refreshes content + 6 metadata
+// columns + clears summary_dirty (with FTS sync). Same apiKey/dryRun gate
+// as buildDag above. Cap HIPPO_DAG_REBUILD_CAP (default 20, hard ceiling
+// 1000) prevents runaway LLM cost.
+async function dagRebuildPass(run, { llmError, llmOpts }) {
+    const { result } = run;
+    try {
+        const { rebuildDirtySummaries } = await import('../dag.js');
+        const rawCap = envDagRebuildCap();
+        // R1 MED must-fix: hard ceiling so misconfigured env can't burn
+        // unbounded LLM cost.
+        const cap = rawCap !== undefined ? Math.min(rawCap, 1000) : 20;
+        const rebuildResult = await rebuildDirtySummaries(run.hippoRoot, { ...llmOpts, onError: llmError('dag rebuild'), cap });
+        result.summariesRebuilt = rebuildResult.rebuilt;
+        result.summariesRebuildFailed = rebuildResult.failed;
+        result.summariesZeroChildSkipped = rebuildResult.zeroChildSkipped;
+        result.summariesRebuildRefused = rebuildResult.refused;
+        result.summariesRebuildCapped = rebuildResult.capped;
+        if (rebuildResult.rebuilt > 0 || rebuildResult.zeroChildSkipped > 0 || rebuildResult.failed > 0 || rebuildResult.refused > 0) {
+            const parts = [];
+            if (rebuildResult.rebuilt > 0)
+                parts.push(`${rebuildResult.rebuilt} rebuilt`);
+            if (rebuildResult.refused > 0)
+                parts.push(`${rebuildResult.refused} refused`);
+            if (rebuildResult.zeroChildSkipped > 0)
+                parts.push(`${rebuildResult.zeroChildSkipped} zero-child-skipped`);
+            if (rebuildResult.failed > 0)
+                parts.push(`${rebuildResult.failed} failed`);
+            if (rebuildResult.capped)
+                parts.push(`CAPPED@${cap}`);
+            result.details.push(`  🌳 DAG rebuild: ${parts.join(', ')}`);
+        }
+    }
+    catch (err) {
+        llmError('dag rebuild')(String(err));
+    }
+}
+// -------------------------------------------------------------------------
+// 1.9. DAG entity profiles — cluster L2 topic summaries into L3 profiles
+// -------------------------------------------------------------------------
+// E5 phase: aggregate per-entity L2 summaries (e.g. all the speaker:Alice
+// topic summaries) into a single L3 entity profile. Runs even when phase
+// 1.7 buildDag was skipped (re-clusters existing L2s every sleep).
+//
+// Uses loadAllL2Summaries (not `survivors`) because phase 1.7 wrote new
+// L2s directly via writeEntry without pushing back into survivors.
+async function entityProfilePass(run, { llmError, llmOpts }) {
+    try {
+        const { buildEntityProfiles } = await import('../dag.js');
+        const { loadAllL2Summaries } = await import('../store/summaries.js');
+        const l2Summaries = loadAllL2Summaries(run.hippoRoot);
+        if (l2Summaries.length >= 2) {
+            const profileResult = await buildEntityProfiles(run.hippoRoot, l2Summaries, { ...llmOpts, onError: llmError('dag profiles') });
+            run.result.entityProfilesCreated = profileResult.profilesCreated;
+            if (profileResult.profilesCreated > 0) {
+                run.result.details.push(`  🌲 DAG L3: ${profileResult.profilesCreated} entity profiles, ${profileResult.l2sLinked} L2s linked`);
+            }
+        }
+    }
+    catch (err) {
+        llmError('dag profiles')(String(err));
+    }
+}
+//# sourceMappingURL=llm-passes.js.map

package/dist/consolidate/merge.d.ts

@@ -0,0 +1,7 @@
+import { type SleepRun } from './run.js';
+export declare function retireHeldTexts(run: SleepRun): void;
+/** Returns how many clusters were skipped because their merged text matches a rejected value. */
+export declare function mergePass(run: SleepRun): number;
+/** Maps i to each j > i, ascending, whose text overlap with i reaches the merge threshold; every text needs at least one token. */
+export declare function mergePartners(contents: readonly string[]): (i: number) => number[];
+//# sourceMappingURL=merge.d.ts.map

package/dist/consolidate/merge.js

@@ -0,0 +1,251 @@
+import { Layer, calculateStrength, createMemory } from '../memory.js';
+import { tokenize } from '../tokenize.js';
+import { jaccardMinShared, overlapPartners } from '../overlap-index.js';
+import { compareEntryIdentity } from '../compare.js';
+import { duplicateKey, mergedText } from '../same-text.js';
+import { successorAfterRetirement } from '../merged-row.js';
+import { rejectionDigest, findRejectedValue } from '../rejection.js';
+import { appendAuditEvent, reportAuditWriteFailure } from '../audit.js';
+import { derivationScope, derivationPartitionKey } from '../recall-scope.js';
+import { jaccardSets } from './conflicts.js';
+import { keptAsWritten } from './run.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
+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. Demotion must go through
+// half_life_days: calculateStrength() recomputes live strength from
+// last_retrieved/half_life and never reads the stored strength field, so a
+// stored-strength write is inert for ranking and gets overwritten by the
+// next sleep's decay pass anyway.
+const MERGE_SOURCE_HALF_LIFE_FACTOR = 0.3;
+export function retireHeldTexts(run) {
+    const { survivors } = run;
+    const byId = new Map(run.all.map((e) => [e.id, e]));
+    const rejectedIn = (tenantId) => (text) => {
+        const db = run.getConsolidateDb();
+        return db !== null && findRejectedValue(db, 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;
+        if (successor === undefined)
+            continue;
+        run.result.details.push(`  ✂️  ${row.id} held a retired text${successor ? `, ${successor.id} holds the rest` : ''}`);
+        if (run.dryRun)
+            continue;
+        run.pendingDeletes.push(row.id);
+        if (successor) {
+            run.pendingWrites.push(successor);
+            survivors[i] = successor;
+        }
+        else {
+            survivors.splice(i, 1);
+        }
+    }
+}
+// -------------------------------------------------------------------------
+// 3. Merge pass  - episodic entries only
+// -------------------------------------------------------------------------
+/** Returns how many clusters were skipped because their merged text matches a rejected value. */
+export function mergePass(run) {
+    const alreadyMergedIds = new Set(run.survivors.flatMap((e) => e.parents));
+    const mergeCandidates = run.survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !keptAsWritten(e) && !alreadyMergedIds.has(e.id)
+        && !e.pinned // a pin merged with a look-alike would read as one of two values
+        && tokenize(e.content).length > 0);
+    const used = new Set();
+    // T1 fix (2026-08-15 hardening pass): partition by tenantId BEFORE the
+    // overlap loop so a cluster can never span tenants. Previously textOverlap
+    // clustered across the whole host-wide `survivors` list with no tenant
+    // boundary, and mergeContents concatenated cross-tenant content into one
+    // row. Map preserves insertion order, so single-tenant stores (every row
+    // 'default') get exactly one partition and iterate in the same order as
+    // before this fix — byte-identical behavior there.
+    const mergeCandidatesByTenant = new Map();
+    for (const entry of mergeCandidates) {
+        const key = derivationPartitionKey(entry.tenantId, entry.scope, entry.origin_project);
+        const bucket = mergeCandidatesByTenant.get(key);
+        if (bucket)
+            bucket.push(entry);
+        else
+            mergeCandidatesByTenant.set(key, [entry]);
+    }
+    // AT1 consolidation-loop fix (docs/plans/2026-08-15-at1-rejected-value-tombstone.md):
+    // reuses the single consolidateDb handle opened lazily in consolidate()
+    // for the whole non-dry-run consolidate — see that
+    // declaration's comment. Only needed for real writes — a dry-run preview
+    // never reaches batchWriteAndDelete's guard bypass, so there is nothing
+    // here for it to protect against.
+    let mergesSkippedRejected = 0;
+    for (const [, tenantCandidates] of mergeCandidatesByTenant) {
+        const partition = {
+            tenantId: tenantCandidates[0].tenantId,
+            scope: derivationScope(tenantCandidates[0].scope),
+            origin: tenantCandidates[0].origin_project,
+        };
+        const partnersOf = mergePartners(tenantCandidates.map((e) => e.content));
+        for (let i = 0; i < tenantCandidates.length; i++) {
+            if (used.has(tenantCandidates[i].id) || tenantCandidates[i].content.length > MERGE_MAX_CHARS)
+                continue;
+            const related = [tenantCandidates[i]];
+            for (const j of partnersOf(i)) {
+                if (!used.has(tenantCandidates[j].id))
+                    related.push(tenantCandidates[j]);
+            }
+            const cluster = [];
+            let clusterChars = 0;
+            for (const e of related) {
+                if (cluster.length === MERGE_MAX_SOURCES || clusterChars + e.content.length > MERGE_MAX_CHARS)
+                    continue;
+                cluster.push(e);
+                clusterChars += e.content.length;
+            }
+            if (cluster.length < MERGE_MIN_CLUSTER)
+                continue;
+            if (!mergeCluster(run, partition, cluster, related, used))
+                mergesSkippedRejected++;
+        }
+    }
+    return mergesSkippedRejected;
+}
+/** Merges one cluster into a semantic row; returns false when a tombstone refuses the merged text. */
+function mergeCluster(run, partition, cluster, related, used) {
+    const { result, dryRun } = run;
+    // Create a semantic summary
+    const mergedContent = mergeContents(cluster);
+    const allTags = Array.from(new Set(cluster.flatMap((e) => e.tags))).sort();
+    const maxValence = pickStrongestValence(cluster);
+    // AT1 P2 fix: build the semantic entry FIRST — createMemory is cheap
+    // and pure — so the tombstone check below runs under the tenant the
+    // row will ACTUALLY land in.
+    // T1 fix: createMemory now receives tenantId: mergeTenant (the
+    // partition's tenant — every member of `cluster` shares it by
+    // construction), so the row lands in its source tenant instead of
+    // always 'default'.
+    let semantic = null;
+    if (!dryRun) {
+        semantic = {
+            ...createMemory(mergedContent, {
+                layer: Layer.Semantic,
+                tags: allTags,
+                emotional_valence: maxValence,
+                schema_fit: 0.7,
+                source: 'consolidation',
+                confidence: 'inferred',
+                tenantId: partition.tenantId,
+                scope: partition.scope,
+                baseHalfLifeDays: run.config.defaultHalfLifeDays,
+            }),
+            origin_project: partition.origin,
+            parents: cluster.map((e) => e.id),
+        };
+    }
+    if (semantic && mergeRejected(run, semantic, cluster, related, used))
+        return false;
+    // Mark cluster members as used
+    for (const e of cluster)
+        used.add(e.id);
+    result.merged += cluster.length;
+    result.details.push(`  🔀 merged ${cluster.length} episodic entries into semantic: "${mergedContent.slice(0, 60)}..."`);
+    if (!dryRun && semantic) {
+        run.pendingWrites.push(semantic);
+        result.semanticCreated++;
+        // Demote source episodics (they've been compressed into neocortex):
+        // scale half_life_days so they decay sooner while staying recoverable.
+        // Immediate ranking is deliberately unchanged: the 2026-06-10 DAG
+        // slice-1 eval measured that dropping children below a worse-retrieving
+        // summary regresses budget-bounded QA (docs/evals/). The stored
+        // strength is refreshed to the live value so inspect, replay sampling,
+        // and strength-sorted assembly see the truth instead of a fake 0.3.
+        // Mutate in place (not a copy): `cluster` holds the same object
+        // references as `survivors`, and the later detectConflicts(survivors)
+        // pass in this same run must see the post-demotion half-life, or it
+        // can persist conflicts for entries the just-written state excludes.
+        for (const e of cluster) {
+            e.half_life_days = Math.max(1, Math.floor(e.half_life_days * MERGE_SOURCE_HALF_LIFE_FACTOR));
+            e.strength = calculateStrength(e, run.now, run.decayOpts);
+            run.pendingWrites.push(e);
+        }
+    }
+    return true;
+}
+// mergeContents is DETERMINISTIC CONCATENATION (not an LLM paraphrase)
+// — if a human rejected exactly this byte-identical rollup before, an
+// unguarded sleep would regenerate it every cycle and
+// batchWriteAndDelete's guard bypass (store.ts) would silently
+// re-assert it forever. This producer-side check is what makes that
+// bypass safe. A hit skips the WHOLE cluster: sources stay unmerged —
+// not demoted, not deleted — so a later sleep gets another chance if
+// the tombstone is lifted.
+function mergeRejected(run, semantic, cluster, related, used) {
+    const consolidateDb = run.getConsolidateDb();
+    if (!consolidateDb)
+        return false;
+    const newDigest = rejectionDigest(semantic.content);
+    const oldDigest = rejectionDigest(legacyMergeContents(related)); // tombstones from older releases hold this format's digest
+    const newHit = findRejectedValue(consolidateDb, semantic.tenantId, newDigest);
+    const tombstone = newHit ?? findRejectedValue(consolidateDb, semantic.tenantId, oldDigest);
+    const mergeDigest = newHit ? newDigest : oldDigest;
+    if (!tombstone)
+        return false;
+    // Still mark used — these members are not re-tried against a
+    // DIFFERENT cluster within this same pass; 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
+    for (const e of rejected)
+        used.add(e.id);
+    try {
+        appendAuditEvent(consolidateDb, {
+            tenantId: semantic.tenantId,
+            actor: 'sleep',
+            op: 'reject_refusal',
+            metadata: {
+                digest: mergeDigest,
+                reason: tombstone.reason,
+                sourceIds: rejected.map((e) => e.id),
+            },
+        });
+    }
+    catch (error) {
+        reportAuditWriteFailure('reject_refusal', String(error));
+    }
+    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));
+    const texts = new Map();
+    for (const e of sorted) {
+        if (!texts.has(duplicateKey(e.content)))
+            texts.set(duplicateKey(e.content), e.content);
+    }
+    const header = entries.length === 2 ? '[Consolidated from 2 related memories, newest first]' : `[Consolidated pattern from ${entries.length} related memories, newest first]`;
+    return mergedText(header, [...texts.values()]);
+}
+function legacyMergeContents(entries) {
+    // The old format dropped text, so it is only ever digested to match rejections recorded against it, never written.
+    const sorted = [...entries].sort((a, b) => (b.content.length - a.content.length) || compareEntryIdentity(a, b));
+    if (entries.length === 2)
+        return `[Consolidated from ${entries.length} related memories]\n\n${sorted[0].content}`;
+    const bullets = sorted.map((e) => `- ${e.content.split('\n')[0].slice(0, 120)}`).join('\n');
+    return `[Consolidated pattern from ${entries.length} related memories]\n\n${bullets}`;
+}
+function pickStrongestValence(entries) {
+    const order = ['critical', 'negative', 'positive', 'neutral'];
+    for (const v of order) {
+        if (entries.some((e) => e.emotional_valence === v))
+            return v;
+    }
+    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. */
+export function mergePartners(contents) {
+    const sets = contents.map((text) => new Set(tokenize(text)));
+    const candidatesOf = overlapPartners(sets, jaccardMinShared(MERGE_OVERLAP_THRESHOLD));
+    return (i) => candidatesOf(i).filter((j) => jaccardSets(sets[i], sets[j]) >= MERGE_OVERLAP_THRESHOLD);
+}
+//# sourceMappingURL=merge.js.map

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

@@ -0,0 +1,3 @@
+import type { SleepRun } from './run.js';
+export declare function physicsPass(run: SleepRun): void;
+//# sourceMappingURL=physics-pass.d.ts.map

package/dist/consolidate/physics-pass.js

@@ -0,0 +1,60 @@
+import { openHippoDb, closeHippoDb } from '../db.js';
+import { loadPhysicsState, savePhysicsState, refreshParticleProperties } from '../physics-state.js';
+import { simulate } from '../physics.js';
+// -------------------------------------------------------------------------
+// 2. Physics simulation pass
+// -------------------------------------------------------------------------
+export function physicsPass(run) {
+    if (run.dryRun)
+        return;
+    const { config, result, survivors } = 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);
+            }
+        }
+    }
+    catch (error) {
+        result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
+    }
+}
+//# sourceMappingURL=physics-pass.js.map