hippo-memory 1.30.0 → 1.32.0

package/dist/consolidate.js

@@ -12,6 +12,7 @@ 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';
@@ -75,6 +76,7 @@ export async function consolidate(hippoRoot, options = {}) {
         summariesRebuilt: 0,
         summariesRebuildFailed: 0,
         summariesZeroChildSkipped: 0,
+        summariesRebuildRefused: 0,
         summariesRebuildCapped: false,
         entityProfilesCreated: 0,
         dryRun,
@@ -236,331 +238,509 @@ export async function consolidate(hippoRoot, options = {}) {
             }
         }
     }
-    // -------------------------------------------------------------------------
-    // 1.4. Auto-promote complete sessions to traces
-    // -------------------------------------------------------------------------
+    // AT1 rejection-guard db handle (docs/plans/2026-08-15-at1-rejected-value-tombstone.md):
+    // covers 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.
     //
-    // 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;
+    // T3 fix (2026-08-15 hardening pass, perf hygiene): memoized lazy getter,
+    // not an eager open. The handle only serves these two tombstone checks —
+    // a sleep with zero promotable sessions and zero merge clusters never
+    // reaches either use site, so opening it unconditionally on every
+    // non-dry-run sleep paid a db-open cost for nothing. dryRun still never
+    // opens (getConsolidateDb short-circuits before touching the handle).
+    // Every `if (consolidateDb)` guard below becomes `const consolidateDb =
+    // getConsolidateDb();` at its use site — same semantics, opened on first
+    // real use. consolidateDbOpened (not just a truthy handle check) is the
+    // single source of truth for "was this ever opened", so the finally below
+    // closes it exactly once and never double-opens.
+    //
+    // AT1 P2 fix (codex, handle-leak restructure): the getter's lifetime must
+    // start IMMEDIATELY before the try whose finally closes it, covering every
+    // phase that can touch it — 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 an 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.
+    let consolidateDbHandle = null;
+    let consolidateDbOpened = false;
+    const getConsolidateDb = () => {
+        if (dryRun)
+            return null;
+        if (!consolidateDbOpened) {
+            consolidateDbHandle = openHippoDb(hippoRoot);
+            consolidateDbOpened = true;
+        }
+        return consolidateDbHandle;
+    };
+    // 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,
+                });
+                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',
+                    // T1 fix (2026-08-15 hardening pass): stamp the trace into the SAME
+                    // tenant the traceExistsForSession idempotency check (above) runs
+                    // under. Before
+                    // this, createMemory omitted tenantId and the trace always landed
+                    // 'default' (memory.ts:535) while the idempotency check ran under
+                    // consolidationTenant — for any non-default tenant that check never
+                    // hit, and the trace regenerated every sleep.
+                    tenantId: consolidationTenant,
+                });
+                // 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.
+                const consolidateDb = getConsolidateDb();
+                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})`);
+            }
+            if (result.promotedTraces > 0) {
+                result.details.push(`  🧬 promoted ${result.promotedTraces} trace${result.promotedTraces === 1 ? '' : 's'} from completed session${result.promotedTraces === 1 ? '' : 's'}`);
+            }
+            if (tracesSkippedRejected > 0) {
+                console.error(`consolidate: skipped ${tracesSkippedRejected} auto-promoted trace(s) whose content matches a rejected value`);
             }
-            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(', '));
+                    if (!dryRun) {
+                        for (const r of rehearsed)
+                            pendingWrites.push(r);
+                    }
+                }
+            }
         }
-    }
-    // -------------------------------------------------------------------------
-    // 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;
+        // -------------------------------------------------------------------------
+        // 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;
+                    }
                 }
-                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);
+                catch {
+                    // Best-effort — continue with next candidate
                 }
             }
+            result.extracted = extractedCount;
         }
-    }
-    // -------------------------------------------------------------------------
-    // 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)) {
+        // -------------------------------------------------------------------------
+        // 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 facts = await extractFacts(candidate.content, {
+                const { buildDag } = await import('./dag.js');
+                const dagResult = await buildDag(hippoRoot, extractedFacts, {
                     apiKey,
                     model: config.extraction.model,
                 });
-                if (facts.length > 0) {
-                    storeExtractedFacts(hippoRoot, candidate, facts);
-                    extractedCount += facts.length;
+                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 — continue with next candidate
+                // Best-effort
             }
         }
-        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`);
-            }
-        }
-        catch {
-            // Best-effort
-        }
-    }
-    // -------------------------------------------------------------------------
-    // 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(', ')}`);
-            }
-        }
-        catch {
-            // Best-effort — same posture as buildDag block above.
-        }
-    }
-    // -------------------------------------------------------------------------
-    // 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.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 {
+                // 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'}`);
-        }
-    }
-    // -------------------------------------------------------------------------
-    // 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))
-                continue;
-            const overlap = textOverlap(mergeCandidates[i].content, mergeCandidates[j].content);
-            if (overlap >= MERGE_OVERLAP_THRESHOLD) {
-                cluster.push(mergeCandidates[j]);
+            catch (error) {
+                result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
             }
         }
-        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);
+        // -------------------------------------------------------------------------
+        // 3. Merge pass  - episodic entries only
+        // -------------------------------------------------------------------------
+        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.tags.includes('extracted'));
+        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 bucket = mergeCandidatesByTenant.get(entry.tenantId);
+            if (bucket)
+                bucket.push(entry);
+            else
+                mergeCandidatesByTenant.set(entry.tenantId, [entry]);
+        }
+        // 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 (const [mergeTenant, tenantCandidates] of mergeCandidatesByTenant) {
+            for (let i = 0; i < tenantCandidates.length; i++) {
+                if (used.has(tenantCandidates[i].id))
+                    continue;
+                const cluster = [tenantCandidates[i]];
+                for (let j = i + 1; j < tenantCandidates.length; j++) {
+                    if (used.has(tenantCandidates[j].id))
+                        continue;
+                    const overlap = textOverlap(tenantCandidates[i].content, tenantCandidates[j].content);
+                    if (overlap >= MERGE_OVERLAP_THRESHOLD) {
+                        cluster.push(tenantCandidates[j]);
+                    }
+                }
+                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.
+                // 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: mergeTenant,
+                    });
+                }
+                // 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.
+                const consolidateDb = getConsolidateDb();
+                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 (consolidateDbHandle)
+            closeHippoDb(consolidateDbHandle);
+    }
+    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);