hippo-memory 1.29.0 → 1.31.0

package/dist/consolidate.js

@@ -12,12 +12,16 @@ import { loadAllEntries, batchWriteAndDelete, appendConsolidationRun, replaceDet
 import { textOverlap, markRetrieved } from './search.js';
 import { compareEntryIdentity } from './compare.js';
 import { openHippoDb, closeHippoDb } from './db.js';
+import { rejectionDigest, findRejectedValue } from './rejection.js';
 import { loadPhysicsState, savePhysicsState, refreshParticleProperties } from './physics-state.js';
 import { simulate } from './physics.js';
 import { loadConfig } from './config.js';
 import { sampleForReplay } from './replay.js';
 import { renderTraceContent } from './trace.js';
 import { resolveTenantId } from './tenant.js';
+import { rescueSet, rankNonPinnedByTenant, validateWeights } from './memory-value.js';
+import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from './memory-value-weights.js';
+import { appendAuditEvent } from './audit.js';
 const DECAY_THRESHOLD = 0.05;
 const MERGE_OVERLAP_THRESHOLD = 0.35; // Jaccard similarity for "related"
 const MERGE_MIN_CLUSTER = 2; // minimum cluster size to merge
@@ -97,356 +101,604 @@ export async function consolidate(hippoRoot, options = {}) {
     // -------------------------------------------------------------------------
     // 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.
     const survivors = [];
-    for (const entry of all) {
-        const strength = calculateStrength(entry, now, decayOpts);
-        if (!entry.pinned && strength < DECAY_THRESHOLD) {
-            result.removed++;
-            result.details.push(`  🗑  removed ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`);
-            if (!dryRun) {
-                pendingDeletes.push(entry.id);
+    let rescuedIds = new Set();
+    // Carried forward to the post-flush "4. Log run" section below, 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).
+    let rescuedEntries = [];
+    let rankById = new Map();
+    if (config.memoryValue.enabled) {
+        // --- Phase 1: classify (zero commits) ---
+        const condemned = [];
+        const strengthById = new Map();
+        for (const entry of all) {
+            const strength = calculateStrength(entry, now, decayOpts);
+            strengthById.set(entry.id, strength);
+            if (!entry.pinned && strength < DECAY_THRESHOLD) {
+                condemned.push(entry);
             }
         }
-        else {
-            // Update the stored strength value and persist stale confidence when applicable.
-            const effectiveConfidence = resolveConfidence(entry, now);
-            const updated = {
-                ...entry,
-                strength,
-                confidence: effectiveConfidence,
-            };
-            survivors.push(updated);
-            if (!dryRun && (strength !== entry.strength || effectiveConfidence !== entry.confidence)) {
-                pendingWrites.push(updated);
+        // --- Phase 2a: rescue decision (pure compute) ---
+        // Runs under --dry-run too (only pendingDeletes/the audit write in
+        // "4. Log run" below 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);
+            // Review-round F2: entries with a non-finite computed feature (e.g. a
+            // malformed `created` string -> Date.parse NaN) score -Infinity in
+            // rankById and rescueSet's explicit finite-score guard means they can
+            // never be rescued. Surfaced here as one details warning line naming
+            // them, rather than leaving it a silent NaN-driven scoring detail.
+            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(', ')}`);
             }
-            result.decayed++;
         }
-    }
-    // -------------------------------------------------------------------------
-    // 1.4. Auto-promote complete sessions to traces
-    // -------------------------------------------------------------------------
-    //
-    // For each session within the configured window that has a `session_complete`
-    // event and no existing trace (idempotency via the source_session_id column),
-    // render the action sequence as markdown and persist a Layer.Trace memory.
-    // Traces inherit decay, search, replay, and physics from the base MemoryEntry.
-    if (!dryRun && config.autoTraceCapture !== false) {
-        const windowDays = config.autoTraceWindowDays ?? 7;
-        const sinceMs = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
-        // Auto-trace currently runs in a single-tenant context (the env-resolved
-        // tenant for this process). Multi-tenant deployments that want
-        // consolidation across all tenants need a per-tenant loop layered on top
-        // of this — tracked in docs/plans/2026-05-02-continuity-tables-tenant-scope.md.
-        const consolidationTenant = resolveTenantId({});
-        const promotable = findPromotableSessions(hippoRoot, consolidationTenant, sinceMs);
-        for (const session of promotable) {
-            // Idempotency: skip if a trace for this session already exists.
-            if (traceExistsForSession(hippoRoot, consolidationTenant, session.session_id))
-                continue;
-            const events = listSessionEvents(hippoRoot, consolidationTenant, {
-                session_id: session.session_id,
-                limit: 1000,
-            });
-            const completeEvent = events.find((e) => e.event_type === 'session_complete');
-            if (!completeEvent)
-                continue; // defence-in-depth; findPromotableSessions filters already.
-            const outcomeRaw = completeEvent.content;
-            if (outcomeRaw !== 'success' && outcomeRaw !== 'failure' && outcomeRaw !== 'partial') {
-                // Malformed terminal event — skip rather than crash the whole sleep.
-                continue;
+        // --- 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 (!entry.pinned && strength < DECAY_THRESHOLD) {
+                if (rescuedIds.has(entry.id)) {
+                    // Rescued (D1): standard survivor bookkeeping refresh — same
+                    // stored-strength + effective-confidence update every other
+                    // survivor gets (round-2 code-review P2-1). D1's "kept as-is"
+                    // protects against half-life edits and rank-derived writes, not
+                    // against the ordinary decay-pass refresh every survivor
+                    // receives; leaving a rescued entry's stale strength (e.g. 1.0)
+                    // on disk would mislead downstream replay/admission reads.
+                    const effectiveConfidence = resolveConfidence(entry, now);
+                    const updated = { ...entry, strength, confidence: effectiveConfidence };
+                    survivors.push(updated);
+                    if (!dryRun && (strength !== entry.strength || effectiveConfidence !== entry.confidence)) {
+                        pendingWrites.push(updated);
+                    }
+                    result.decayed++;
+                    rescuedEntries.push(updated);
+                    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 {
+                    result.removed++;
+                    result.details.push(`  🗑  removed ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`);
+                    if (!dryRun) {
+                        pendingDeletes.push(entry.id);
+                    }
+                }
+            }
+            else {
+                const effectiveConfidence = resolveConfidence(entry, now);
+                const updated = { ...entry, strength, confidence: effectiveConfidence };
+                survivors.push(updated);
+                if (!dryRun && (strength !== entry.strength || effectiveConfidence !== entry.confidence)) {
+                    pendingWrites.push(updated);
+                }
+                result.decayed++;
             }
-            const outcome = outcomeRaw;
-            const steps = events
-                .filter((e) => e.event_type !== 'session_complete')
-                .map((e) => ({ action: e.content, observation: '' }));
-            const summary = typeof completeEvent.metadata.summary === 'string'
-                ? completeEvent.metadata.summary
-                : '(untitled)';
-            const trace = createMemory(renderTraceContent({ task: summary, steps, outcome }), {
-                layer: Layer.Trace,
-                trace_outcome: outcome,
-                source_session_id: session.session_id,
-                tags: ['auto-promoted'],
-                source: 'auto-promote',
-            });
-            pendingWrites.push(trace);
-            survivors.push(trace);
-            result.promotedTraces++;
-            result.details.push(`  🧬 promoted trace ${trace.id} from session ${session.session_id} (${outcome})`);
-        }
-        if (result.promotedTraces > 0) {
-            result.details.push(`  🧬 promoted ${result.promotedTraces} trace${result.promotedTraces === 1 ? '' : 's'} from completed session${result.promotedTraces === 1 ? '' : 's'}`);
         }
     }
-    // -------------------------------------------------------------------------
-    // 1.5. Replay pass — rehearse high-value survivors
-    // -------------------------------------------------------------------------
-    //
-    // Biologically-inspired counterpart to hippocampal replay during slow-wave
-    // sleep: sample N memories weighted by outcome + valence + under-rehearsal
-    // + idle time, then apply the same retrieval-strengthening `markRetrieved`
-    // applies to real queries. Distinct from decay (removal), physics (motion),
-    // and merge (compression) — this is the "rehearse the important stuff so
-    // it doesn't fade" pass.
-    {
-        const replayCount = config.replay?.count ?? REPLAY_COUNT_DEFAULT;
-        // EVAL-ONLY ablation (see ablation.ts): replay rehearsal IS recall
-        // strengthening (same markRetrieved dynamics), so the strengthen-off arm
-        // silences the whole pass - markRetrieved would return unmutated entries
-        // and persisting them anyway would still refresh updated_at / mirrors.
-        if (replayCount > 0 && survivors.length > 0 && !isRecallBoostAblated()) {
-            const seed = Math.floor(now.getTime() / 1000) & 0xffffffff;
-            const picked = sampleForReplay(survivors, replayCount, now, seed);
-            if (picked.length > 0) {
-                const rehearsed = markRetrieved(picked, now);
-                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++) {
-                    const replacement = rehearsedById.get(survivors[i].id);
-                    if (replacement)
-                        survivors[i] = replacement;
-                }
-                result.replayed = rehearsed.length;
-                result.details.push(`  💭 replayed ${rehearsed.length} memor${rehearsed.length === 1 ? 'y' : 'ies'}: ` +
-                    rehearsed.map((e) => e.id).join(', '));
+    else {
+        for (const entry of all) {
+            const strength = calculateStrength(entry, now, decayOpts);
+            if (!entry.pinned && strength < DECAY_THRESHOLD) {
+                result.removed++;
+                result.details.push(`  🗑  removed ${entry.id} (strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`);
                 if (!dryRun) {
-                    for (const r of rehearsed)
-                        pendingWrites.push(r);
+                    pendingDeletes.push(entry.id);
+                }
+            }
+            else {
+                // Update the stored strength value and persist stale confidence when applicable.
+                const effectiveConfidence = resolveConfidence(entry, now);
+                const updated = {
+                    ...entry,
+                    strength,
+                    confidence: effectiveConfidence,
+                };
+                survivors.push(updated);
+                if (!dryRun && (strength !== entry.strength || effectiveConfidence !== entry.confidence)) {
+                    pendingWrites.push(updated);
                 }
+                result.decayed++;
             }
         }
     }
-    // -------------------------------------------------------------------------
-    // 1.6. Batch extraction — extract facts from episodic memories missing them
-    // -------------------------------------------------------------------------
-    const extractedFromIds = new Set(survivors.filter((e) => e.extracted_from).map((e) => e.extracted_from));
-    const extractionCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !extractedFromIds.has(e.id));
-    result.extractionCandidates = extractionCandidates.length;
-    const apiKey = process.env.ANTHROPIC_API_KEY ?? '';
-    if (apiKey && extractionCandidates.length > 0 && !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, {
-                    apiKey,
-                    model: config.extraction.model,
+    // AT1 rejection-guard db handle (docs/plans/2026-08-15-at1-rejected-value-tombstone.md):
+    // opened ONCE for the whole non-dry-run consolidate, covering BOTH the
+    // auto-promote pass (1.4, immediately below) and the merge pass (3,
+    // further down) — both build deterministic content that batchWriteAndDelete
+    // writes through the guard's bypass, so both need a producer-side
+    // tombstone check before pushing to pendingWrites. A single handle here
+    // replaces what used to be a per-pass open. Dry-run never reaches the
+    // bypass (no batchWriteAndDelete call), so there is nothing for a handle
+    // to protect against — stays null and every `if (consolidateDb)` below is
+    // a no-op.
+    //
+    // AT1 P2 fix (codex, handle-leak restructure): the open must be followed
+    // IMMEDIATELY by the try whose finally closes it, covering every phase
+    // that can touch consolidateDb — not just the merge pass. Previously the
+    // try/finally wrapped only section 3 (merge pass); an exception thrown by
+    // auto-promote (1.4), replay (1.5), batch extraction (1.6), the DAG
+    // passes (1.7-1.9), or physics (2) would propagate past the open handle
+    // with nothing to close it. No behavior change on the happy path — each
+    // of those phases already best-effort catches its own exceptions today
+    // (physics has its own try/catch below; each DAG pass wraps its own
+    // dynamic import + call in try/catch) — this only closes the handle on
+    // the rare path where one of them throws past its own catch. Deliberately
+    // NOT re-indented (mechanical wrap only, kept surgical): every statement
+    // between this try and its finally (below, at the end of the merge pass)
+    // stays at its original indentation.
+    const consolidateDb = dryRun ? null : openHippoDb(hippoRoot);
+    // Declared here (not at the merge pass, its point of use) so it survives
+    // this try/finally — a `let` declared INSIDE the try would go out of
+    // scope before the `if (mergesSkippedRejected > 0)` check that reads it
+    // after the finally closes the handle.
+    let mergesSkippedRejected = 0;
+    try {
+        // -------------------------------------------------------------------------
+        // 1.4. Auto-promote complete sessions to traces
+        // -------------------------------------------------------------------------
+        //
+        // For each session within the configured window that has a `session_complete`
+        // event and no existing trace (idempotency via the source_session_id column),
+        // render the action sequence as markdown and persist a Layer.Trace memory.
+        // Traces inherit decay, search, replay, and physics from the base MemoryEntry.
+        if (!dryRun && config.autoTraceCapture !== false) {
+            let tracesSkippedRejected = 0;
+            const windowDays = config.autoTraceWindowDays ?? 7;
+            const sinceMs = now.getTime() - windowDays * 24 * 60 * 60 * 1000;
+            // Auto-trace currently runs in a single-tenant context (the env-resolved
+            // tenant for this process). Multi-tenant deployments that want
+            // consolidation across all tenants need a per-tenant loop layered on top
+            // of this — tracked in docs/plans/2026-05-02-continuity-tables-tenant-scope.md.
+            const consolidationTenant = resolveTenantId({});
+            const promotable = findPromotableSessions(hippoRoot, consolidationTenant, sinceMs);
+            for (const session of promotable) {
+                // Idempotency: skip if a trace for this session already exists.
+                if (traceExistsForSession(hippoRoot, consolidationTenant, session.session_id))
+                    continue;
+                const events = listSessionEvents(hippoRoot, consolidationTenant, {
+                    session_id: session.session_id,
+                    limit: 1000,
                 });
-                if (facts.length > 0) {
-                    storeExtractedFacts(hippoRoot, candidate, facts);
-                    extractedCount += facts.length;
+                const completeEvent = events.find((e) => e.event_type === 'session_complete');
+                if (!completeEvent)
+                    continue; // defence-in-depth; findPromotableSessions filters already.
+                const outcomeRaw = completeEvent.content;
+                if (outcomeRaw !== 'success' && outcomeRaw !== 'failure' && outcomeRaw !== 'partial') {
+                    // Malformed terminal event — skip rather than crash the whole sleep.
+                    continue;
                 }
+                const outcome = outcomeRaw;
+                const steps = events
+                    .filter((e) => e.event_type !== 'session_complete')
+                    .map((e) => ({ action: e.content, observation: '' }));
+                const summary = typeof completeEvent.metadata.summary === 'string'
+                    ? completeEvent.metadata.summary
+                    : '(untitled)';
+                const trace = createMemory(renderTraceContent({ task: summary, steps, outcome }), {
+                    layer: Layer.Trace,
+                    trace_outcome: outcome,
+                    source_session_id: session.session_id,
+                    tags: ['auto-promoted'],
+                    source: 'auto-promote',
+                });
+                // AT1 (same producer-side pattern as the merge pass below): traceExistsForSession
+                // only sees rows CURRENTLY in the store — once a rejected trace is
+                // removed, that idempotency check no longer blocks regeneration, and
+                // this write would otherwise reach batchWriteAndDelete's guard bypass
+                // unchecked, resurrecting it every sleep. Check under THE ENTRY'S OWN
+                // stamped tenantId (read off `trace` after createMemory — never guess
+                // the tenant) + the built content's digest. A hit skips the push
+                // entirely: not counted as promoted, not added to survivors.
+                if (consolidateDb) {
+                    const traceDigest = rejectionDigest(trace.content);
+                    const tombstone = findRejectedValue(consolidateDb, trace.tenantId, traceDigest);
+                    if (tombstone) {
+                        tracesSkippedRejected++;
+                        try {
+                            appendAuditEvent(consolidateDb, {
+                                tenantId: trace.tenantId,
+                                actor: 'sleep',
+                                op: 'reject_refusal',
+                                metadata: {
+                                    digest: traceDigest,
+                                    reason: tombstone.reason,
+                                    sourceSessionId: session.session_id,
+                                },
+                            });
+                        }
+                        catch {
+                            // Best-effort — mirrors store.ts's audit() semantics.
+                        }
+                        continue;
+                    }
+                }
+                pendingWrites.push(trace);
+                survivors.push(trace);
+                result.promotedTraces++;
+                result.details.push(`  🧬 promoted trace ${trace.id} from session ${session.session_id} (${outcome})`);
             }
-            catch {
-                // Best-effort — continue with next candidate
+            if (result.promotedTraces > 0) {
+                result.details.push(`  🧬 promoted ${result.promotedTraces} trace${result.promotedTraces === 1 ? '' : 's'} from completed session${result.promotedTraces === 1 ? '' : 's'}`);
             }
-        }
-        result.extracted = extractedCount;
-    }
-    // -------------------------------------------------------------------------
-    // 1.7. DAG summarization — cluster extracted facts and generate summaries
-    // -------------------------------------------------------------------------
-    const extractedFacts = survivors.filter((e) => e.tags.includes('extracted') && e.dag_level === 1);
-    if (apiKey && extractedFacts.length >= 3 && !dryRun) {
-        try {
-            const { buildDag } = await import('./dag.js');
-            const dagResult = await buildDag(hippoRoot, extractedFacts, {
-                apiKey,
-                model: config.extraction.model,
-            });
-            result.dagCandidateClusters = dagResult.candidateClusters;
-            result.dagSummariesCreated = dagResult.summariesCreated;
-            if (dagResult.summariesCreated > 0) {
-                result.details.push(`  🌳 DAG: ${dagResult.summariesCreated} summaries created, ${dagResult.factsLinked} facts linked`);
+            if (tracesSkippedRejected > 0) {
+                console.error(`consolidate: skipped ${tracesSkippedRejected} auto-promoted trace(s) whose content matches a rejected value`);
             }
         }
-        catch {
-            // Best-effort
+        // -------------------------------------------------------------------------
+        // 1.5. Replay pass — rehearse high-value survivors
+        // -------------------------------------------------------------------------
+        //
+        // Biologically-inspired counterpart to hippocampal replay during slow-wave
+        // sleep: sample N memories weighted by outcome + valence + under-rehearsal
+        // + idle time, then apply the same retrieval-strengthening `markRetrieved`
+        // applies to real queries. Distinct from decay (removal), physics (motion),
+        // and merge (compression) — this is the "rehearse the important stuff so
+        // it doesn't fade" pass.
+        {
+            const replayCount = config.replay?.count ?? REPLAY_COUNT_DEFAULT;
+            // EVAL-ONLY ablation (see ablation.ts): replay rehearsal IS recall
+            // strengthening (same markRetrieved dynamics), so the strengthen-off arm
+            // silences the whole pass - markRetrieved would return unmutated entries
+            // and persisting them anyway would still refresh updated_at / mirrors.
+            if (replayCount > 0 && survivors.length > 0 && !isRecallBoostAblated()) {
+                const seed = Math.floor(now.getTime() / 1000) & 0xffffffff;
+                const picked = sampleForReplay(survivors, replayCount, now, seed);
+                if (picked.length > 0) {
+                    const rehearsed = markRetrieved(picked, now);
+                    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++) {
+                        const replacement = rehearsedById.get(survivors[i].id);
+                        if (replacement)
+                            survivors[i] = replacement;
+                    }
+                    result.replayed = rehearsed.length;
+                    result.details.push(`  💭 replayed ${rehearsed.length} memor${rehearsed.length === 1 ? 'y' : 'ies'}: ` +
+                        rehearsed.map((e) => e.id).join(', '));
+                    if (!dryRun) {
+                        for (const r of rehearsed)
+                            pendingWrites.push(r);
+                    }
+                }
+            }
         }
-    }
-    // -------------------------------------------------------------------------
-    // 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.
-    if (apiKey && !dryRun) {
-        try {
-            const { rebuildDirtySummaries } = await import('./dag.js');
-            const rawCap = parseInt(process.env.HIPPO_DAG_REBUILD_CAP ?? '20', 10);
-            // R1 MED must-fix: hard ceiling so misconfigured env can't burn
-            // unbounded LLM cost.
-            const cap = Number.isFinite(rawCap) && rawCap > 0
-                ? Math.min(rawCap, 1000)
-                : 20;
-            const rebuildResult = await rebuildDirtySummaries(hippoRoot, {
-                apiKey,
-                model: config.extraction.model,
-                cap,
-            });
-            result.summariesRebuilt = rebuildResult.rebuilt;
-            result.summariesRebuildFailed = rebuildResult.failed;
-            result.summariesZeroChildSkipped = rebuildResult.zeroChildSkipped;
-            result.summariesRebuildCapped = rebuildResult.capped;
-            if (rebuildResult.rebuilt > 0 || rebuildResult.zeroChildSkipped > 0 || rebuildResult.failed > 0) {
-                const parts = [];
-                if (rebuildResult.rebuilt > 0)
-                    parts.push(`${rebuildResult.rebuilt} rebuilt`);
-                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(', ')}`);
+        // -------------------------------------------------------------------------
+        // 1.6. Batch extraction — extract facts from episodic memories missing them
+        // -------------------------------------------------------------------------
+        const extractedFromIds = new Set(survivors.filter((e) => e.extracted_from).map((e) => e.extracted_from));
+        const extractionCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !extractedFromIds.has(e.id));
+        result.extractionCandidates = extractionCandidates.length;
+        const apiKey = process.env.ANTHROPIC_API_KEY ?? '';
+        if (apiKey && extractionCandidates.length > 0 && !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, {
+                        apiKey,
+                        model: config.extraction.model,
+                    });
+                    if (facts.length > 0) {
+                        storeExtractedFacts(hippoRoot, candidate, facts);
+                        extractedCount += facts.length;
+                    }
+                }
+                catch {
+                    // Best-effort — continue with next candidate
+                }
             }
+            result.extracted = extractedCount;
         }
-        catch {
-            // Best-effort — same posture as buildDag block above.
+        // -------------------------------------------------------------------------
+        // 1.7. DAG summarization — cluster extracted facts and generate summaries
+        // -------------------------------------------------------------------------
+        const extractedFacts = survivors.filter((e) => e.tags.includes('extracted') && e.dag_level === 1);
+        if (apiKey && extractedFacts.length >= 3 && !dryRun) {
+            try {
+                const { buildDag } = await import('./dag.js');
+                const dagResult = await buildDag(hippoRoot, extractedFacts, {
+                    apiKey,
+                    model: config.extraction.model,
+                });
+                result.dagCandidateClusters = dagResult.candidateClusters;
+                result.dagSummariesCreated = dagResult.summariesCreated;
+                if (dagResult.summariesCreated > 0) {
+                    result.details.push(`  🌳 DAG: ${dagResult.summariesCreated} summaries created, ${dagResult.factsLinked} facts linked`);
+                }
+            }
+            catch {
+                // Best-effort
+            }
         }
-    }
-    // -------------------------------------------------------------------------
-    // 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.
-    if (apiKey && !dryRun) {
-        try {
-            const { buildEntityProfiles } = await import('./dag.js');
-            const { loadAllL2Summaries } = await import('./store.js');
-            const l2Summaries = loadAllL2Summaries(hippoRoot);
-            if (l2Summaries.length >= 2) {
-                const profileResult = await buildEntityProfiles(hippoRoot, l2Summaries, {
+        // -------------------------------------------------------------------------
+        // 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.
+        if (apiKey && !dryRun) {
+            try {
+                const { rebuildDirtySummaries } = await import('./dag.js');
+                const rawCap = parseInt(process.env.HIPPO_DAG_REBUILD_CAP ?? '20', 10);
+                // R1 MED must-fix: hard ceiling so misconfigured env can't burn
+                // unbounded LLM cost.
+                const cap = Number.isFinite(rawCap) && rawCap > 0
+                    ? Math.min(rawCap, 1000)
+                    : 20;
+                const rebuildResult = await rebuildDirtySummaries(hippoRoot, {
                     apiKey,
                     model: config.extraction.model,
+                    cap,
                 });
-                result.entityProfilesCreated = profileResult.profilesCreated;
-                if (profileResult.profilesCreated > 0) {
-                    result.details.push(`  🌲 DAG L3: ${profileResult.profilesCreated} entity profiles, ${profileResult.l2sLinked} L2s linked`);
+                result.summariesRebuilt = rebuildResult.rebuilt;
+                result.summariesRebuildFailed = rebuildResult.failed;
+                result.summariesZeroChildSkipped = rebuildResult.zeroChildSkipped;
+                result.summariesRebuildCapped = rebuildResult.capped;
+                if (rebuildResult.rebuilt > 0 || rebuildResult.zeroChildSkipped > 0 || rebuildResult.failed > 0) {
+                    const parts = [];
+                    if (rebuildResult.rebuilt > 0)
+                        parts.push(`${rebuildResult.rebuilt} rebuilt`);
+                    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 {
+                // Best-effort — same posture as buildDag block above.
+            }
         }
-        catch {
-            // Best-effort.
+        // -------------------------------------------------------------------------
+        // 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.
+        if (apiKey && !dryRun) {
+            try {
+                const { buildEntityProfiles } = await import('./dag.js');
+                const { loadAllL2Summaries } = await import('./store.js');
+                const l2Summaries = loadAllL2Summaries(hippoRoot);
+                if (l2Summaries.length >= 2) {
+                    const profileResult = await buildEntityProfiles(hippoRoot, l2Summaries, {
+                        apiKey,
+                        model: config.extraction.model,
+                    });
+                    result.entityProfilesCreated = profileResult.profilesCreated;
+                    if (profileResult.profilesCreated > 0) {
+                        result.details.push(`  🌲 DAG L3: ${profileResult.profilesCreated} entity profiles, ${profileResult.l2sLinked} L2s linked`);
+                    }
+                }
+            }
+            catch {
+                // Best-effort.
+            }
         }
-    }
-    // -------------------------------------------------------------------------
-    // 2. Physics simulation pass
-    // -------------------------------------------------------------------------
-    if (!dryRun) {
-        try {
-            const physicsEnabled = config.physics.enabled === true
-                || (config.physics.enabled === 'auto');
-            if (physicsEnabled) {
-                const db = openHippoDb(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, 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);
+        // -------------------------------------------------------------------------
+        // 2. Physics simulation pass
+        // -------------------------------------------------------------------------
+        if (!dryRun) {
+            try {
+                const physicsEnabled = config.physics.enabled === true
+                    || (config.physics.enabled === 'auto');
+                if (physicsEnabled) {
+                    const db = openHippoDb(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, 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)}`);
                         }
-                        // 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);
+                    finally {
+                        closeHippoDb(db);
+                    }
                 }
             }
+            catch (error) {
+                result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
+            }
         }
-        catch (error) {
-            result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
-        }
-    }
-    // -------------------------------------------------------------------------
-    // 3. Merge pass  - episodic entries only
-    // -------------------------------------------------------------------------
-    const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.tags.includes('extracted'));
-    const used = new Set();
-    for (let i = 0; i < mergeCandidates.length; i++) {
-        if (used.has(mergeCandidates[i].id))
-            continue;
-        const cluster = [mergeCandidates[i]];
-        for (let j = i + 1; j < mergeCandidates.length; j++) {
-            if (used.has(mergeCandidates[j].id))
+        // -------------------------------------------------------------------------
+        // 3. Merge pass  - episodic entries only
+        // -------------------------------------------------------------------------
+        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.tags.includes('extracted'));
+        const used = new Set();
+        // AT1 consolidation-loop fix (docs/plans/2026-08-15-at1-rejected-value-tombstone.md):
+        // reuses the single consolidateDb handle opened once above (before the
+        // auto-promote pass, 1.4) 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. (mergesSkippedRejected itself is
+        // declared up at the try's opening above 1.4, not here — it has to
+        // survive the try/finally that now wraps this whole section; see the
+        // handle-leak restructure comment there.)
+        for (let i = 0; i < mergeCandidates.length; i++) {
+            if (used.has(mergeCandidates[i].id))
                 continue;
-            const overlap = textOverlap(mergeCandidates[i].content, mergeCandidates[j].content);
-            if (overlap >= MERGE_OVERLAP_THRESHOLD) {
-                cluster.push(mergeCandidates[j]);
+            const cluster = [mergeCandidates[i]];
+            for (let j = i + 1; j < mergeCandidates.length; j++) {
+                if (used.has(mergeCandidates[j].id))
+                    continue;
+                const overlap = textOverlap(mergeCandidates[i].content, mergeCandidates[j].content);
+                if (overlap >= MERGE_OVERLAP_THRESHOLD) {
+                    cluster.push(mergeCandidates[j]);
+                }
             }
-        }
-        if (cluster.length < MERGE_MIN_CLUSTER)
-            continue;
-        // Mark cluster members as used
-        for (const e of cluster)
-            used.add(e.id);
-        result.merged += cluster.length;
-        // Create a semantic summary
-        const mergedContent = mergeContents(cluster);
-        const allTags = Array.from(new Set(cluster.flatMap((e) => e.tags)));
-        const maxValence = pickStrongestValence(cluster);
-        result.details.push(`  🔀 merged ${cluster.length} episodic entries into semantic: "${mergedContent.slice(0, 60)}..."`);
-        if (!dryRun) {
-            const semantic = createMemory(mergedContent, {
-                layer: Layer.Semantic,
-                tags: allTags,
-                emotional_valence: maxValence,
-                schema_fit: 0.7,
-                source: 'consolidation',
-                confidence: 'inferred',
-            });
-            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, now, decayOpts);
-                pendingWrites.push(e);
+            if (cluster.length < MERGE_MIN_CLUSTER)
+                continue;
+            // Create a semantic summary
+            const mergedContent = mergeContents(cluster);
+            const allTags = Array.from(new Set(cluster.flatMap((e) => e.tags)));
+            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. The prior version checked
+            // cluster[0].tenantId, but createMemory (below) is never passed a
+            // tenantId option, so it always stamps its own default ('default',
+            // see memory.ts) regardless of the cluster's source tenant — the
+            // check was consulting a tenant's tombstones that the write was never
+            // going to land in (a false negative on the real destination, and a
+            // possible false-block on the source tenant's unrelated tombstones).
+            // This fix only makes the CHECK match wherever the row actually
+            // lands; it deliberately does NOT change that destination — merge
+            // rows always landing in 'default' regardless of source tenant is a
+            // real, pre-existing cross-tenant question, tracked separately as an
+            // AT1 follow-up (not this fix's scope) rather than folded in here.
+            let semantic = null;
+            if (!dryRun) {
+                semantic = createMemory(mergedContent, {
+                    layer: Layer.Semantic,
+                    tags: allTags,
+                    emotional_valence: maxValence,
+                    schema_fit: 0.7,
+                    source: 'consolidation',
+                    confidence: 'inferred',
+                });
+            }
+            // 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.
+            if (consolidateDb && semantic) {
+                const mergeDigest = rejectionDigest(semantic.content);
+                const tombstone = findRejectedValue(consolidateDb, semantic.tenantId, mergeDigest);
+                if (tombstone) {
+                    // Still mark used — these members are not re-tried against a
+                    // DIFFERENT cluster within this same pass; next sleep re-clusters
+                    // them fresh.
+                    for (const e of cluster)
+                        used.add(e.id);
+                    mergesSkippedRejected++;
+                    try {
+                        appendAuditEvent(consolidateDb, {
+                            tenantId: semantic.tenantId,
+                            actor: 'sleep',
+                            op: 'reject_refusal',
+                            metadata: {
+                                digest: mergeDigest,
+                                reason: tombstone.reason,
+                                sourceIds: cluster.map((e) => e.id),
+                            },
+                        });
+                    }
+                    catch {
+                        // Best-effort — mirrors store.ts's audit() semantics.
+                    }
+                    continue;
+                }
+            }
+            // 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) {
+                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, now, decayOpts);
+                    pendingWrites.push(e);
+                }
             }
         }
     }
+    finally {
+        if (consolidateDb)
+            closeHippoDb(consolidateDb);
+    }
+    if (mergesSkippedRejected > 0) {
+        console.error(`consolidate: skipped ${mergesSkippedRejected} merge(s) whose content matches a rejected value`);
+    }
     // Flush all writes/deletes in a single transaction
     if (!dryRun) {
         batchWriteAndDelete(hippoRoot, pendingWrites, pendingDeletes);
@@ -455,7 +707,7 @@ export async function consolidate(hippoRoot, options = {}) {
     // 4. Log run
     // -------------------------------------------------------------------------
     if (!dryRun) {
-        const detectedConflicts = detectConflicts(survivors, now, decayOpts);
+        const detectedConflicts = detectConflicts(survivors, now, decayOpts, rescuedIds);
         replaceDetectedConflicts(hippoRoot, detectedConflicts, now.toISOString());
         if (detectedConflicts.length > 0) {
             result.details.push(`  ⚠️ detected ${detectedConflicts.length} memory conflict${detectedConflicts.length === 1 ? '' : 's'}`);
@@ -467,6 +719,57 @@ export async function consolidate(hippoRoot, options = {}) {
             removed: result.removed,
         });
         incrementSleepCount(hippoRoot);
+        // One audit row per rescue (attributability, D1). Written here, AFTER
+        // batchWriteAndDelete above has committed this cycle's writes/deletes
+        // (and after conflict detection + run logging), not inline in the decay
+        // pass — same durability posture as api.ts's top-level 'consolidate'
+        // summary audit row (written only once the whole sleep has completed).
+        // Writing it earlier would assert rescues for a cycle whose effects
+        // never landed if a later phase threw. Real writes only — dry-run
+        // previews the decision (details line above) but persists nothing.
+        if (rescuedEntries.length > 0) {
+            try {
+                const auditDb = openHippoDb(hippoRoot);
+                try {
+                    // Review-round F5: per-row try/catch, not one try/catch around the
+                    // whole loop — a single failed appendAuditEvent must not silently
+                    // drop every remaining row. Mirrors the physics pass's
+                    // skipped-warning precedent (line ~564 above): count losses, keep
+                    // the overall fail-soft posture, tell the operator via details.
+                    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 {
+                            auditFailures++;
+                        }
+                    }
+                    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);
+                }
+            }
+            catch {
+                // openHippoDb/closeHippoDb-level failure: audit must never crash a
+                // mutation (mirrors store.ts's audit() posture).
+                result.details.push(`  ⚠️ memory-value: mv_rescue audit unavailable this cycle ` +
+                    `(${rescuedEntries.length} rescue${rescuedEntries.length === 1 ? '' : 's'} not audited)`);
+            }
+        }
     }
     return result;
 }
@@ -495,8 +798,16 @@ function pickStrongestValence(entries) {
     }
     return 'neutral';
 }
-function detectConflicts(entries, now, decayOpts = {}) {
-    const survivors = entries.filter((entry) => entry.layer !== Layer.Semantic && calculateStrength(entry, now, decayOpts) >= DECAY_THRESHOLD);
+function detectConflicts(entries, now, decayOpts = {}, 
+// LC2-E3 (opt-in, default off): ids rescued by this cycle's decay pass.
+// detectConflicts recomputes its own strength>=DECAY_THRESHOLD survivor
+// filter independently of the decay pass above; without this bypass,
+// rescued entries would be silently re-excluded from conflict detection
+// every cycle even though the decay pass just decided to keep them.
+// Default empty set: flag-off behavior is unchanged.
+rescuedIds = new Set()) {
+    const survivors = entries.filter((entry) => entry.layer !== Layer.Semantic
+        && (rescuedIds.has(entry.id) || calculateStrength(entry, now, decayOpts) >= DECAY_THRESHOLD));
     const detected = [];
     for (let i = 0; i < survivors.length; i++) {
         for (let j = i + 1; j < survivors.length; j++) {