hippo-memory 1.59.0 → 1.61.0

package/dist/consolidate/conflicts.js

@@ -0,0 +1,178 @@
+import { Layer, calculateStrength } from '../memory.js';
+import { jaccardMinShared, overlapPartners } from '../overlap-index.js';
+import { isQuarantineScope } from '../quarantine.js';
+import { DECAY_THRESHOLD } from './decay.js';
+// Contradictions should be gated by content overlap, not shared tags. Tags like
+// `feedback` / `policy` are too coarse and can make unrelated rules look like
+// conflicts before the polarity heuristics run.
+// Jaccard threshold on stopword-filtered tokens. Only applied after a polarity
+// signal has already been detected (explicit pair or inferred negation), so
+// this just filters out drive-by topic similarity, not semantic drift.
+const CONFLICT_OVERLAP_THRESHOLD = 0.5;
+// Minimum distinctive shared tokens before we trust an overlap score. Filters
+// out cases where two memories share only common English + a project name.
+const CONFLICT_MIN_RARE_SHARED = 2;
+// Polarity is detected on the first N words only. A stray "not" in the middle
+// of a long memory shouldn't flip the whole thing negative.
+const POLARITY_WINDOW_WORDS = 40;
+const CONFLICT_STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'was', 'are', 'were', 'be', 'been', 'being', 'to', 'of', 'in',
+    'for', 'on', 'with', 'at', 'by', 'from', 'it', 'this', 'that', 'and', 'or', 'but', 'so',
+    'if', 'as', 'we', 'i', 'you', 'they', 'he', 'she', 'my', 'our', 'your', 'its', 'his',
+    'her', 'their', 'up', 'out', 'just', 'also', 'then', 'than', 'some', 'all', 'any',
+    'each', 'very', 'too', 'do', 'did', 'does', 'has', 'had', 'have', 'will', 'would',
+    'could', 'should', 'may', 'might', 'can', 'shall', 'when', 'where', 'what', 'which',
+    'who', 'how', 'why', 'there', 'here', 'about', 'into', 'over', 'after', 'before',
+    'between', 'through', 'during', 'against', 'within', 'without', 'toward', 'upon',
+    'more', 'most', 'less', 'least', 'other', 'such', 'same', 'new', 'old', 'one', 'two',
+]);
+/** Pairs of live non-semantic memories that contradict each other, in survivor order. */
+export 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
+        // CD5: an unreviewed quarantined row must not taint a visible memory as conflicted.
+        && !isQuarantineScope(entry.scope ?? null)
+        && (rescuedIds.has(entry.id) || calculateStrength(entry, now, decayOpts) >= DECAY_THRESHOLD));
+    const detected = [];
+    const profiles = survivors.map((entry) => conflictProfile(entry.content));
+    const partnersOf = overlapPartners(profiles.map((p) => p.distinct), jaccardMinShared(CONFLICT_OVERLAP_THRESHOLD, CONFLICT_MIN_RARE_SHARED));
+    for (let i = 0; i < survivors.length; i++) {
+        for (const j of partnersOf(i)) {
+            // Traces are variants of each other, not contradictions. Two
+            // strategies for the same task can both be valid; conflict detection
+            // exists for stated-rule disagreement, not strategy diversity.
+            if (survivors[i].layer === Layer.Trace && survivors[j].layer === Layer.Trace)
+                continue;
+            if (survivors[i].superseded_by || survivors[j].superseded_by)
+                continue;
+            if (!recalledTogether(survivors[i], survivors[j]))
+                continue;
+            if ([survivors[i], survivors[j]].some((e) => e.tags.includes('extracted') || e.tags.includes('session-digest')))
+                continue;
+            const reasonAndScore = describeConflict(profiles[i], profiles[j]);
+            if (!reasonAndScore)
+                continue;
+            detected.push({
+                memory_a_id: survivors[i].id,
+                memory_b_id: survivors[j].id,
+                reason: reasonAndScore.reason,
+                score: reasonAndScore.score,
+            });
+        }
+    }
+    return detected;
+}
+/** One project's ambient context can show both: same tenant, and the same project or a user-global row beside a project's. */
+function recalledTogether(a, b) {
+    if (a.tenantId !== b.tenantId)
+        return false;
+    const [x, y] = [a.origin_project ?? null, b.origin_project ?? null];
+    return x === y || (x === '' && y !== null) || (y === '' && x !== null);
+}
+function conflictProfile(text) {
+    const opening = openingWindow(text);
+    // Polarity is measured only in the first POLARITY_WINDOW_WORDS, so a stray
+    // negation deep in a prose memory doesn't flip the intent.
+    // Pad with spaces so space-delimited patterns match words at the start/end.
+    return { distinct: distinctiveTokens(text), polarity: inferConflictPolarity(opening), window: ' ' + opening.toLowerCase() + ' ' };
+}
+function describeConflict(a, b) {
+    // Jaccard on stopword-stripped tokens. Defer the threshold check until we
+    // know whether an explicit polarity pair is present (lower bar for those).
+    const overlapScore = jaccardSets(a.distinct, b.distinct);
+    // Require at least N shared distinctive tokens so two short memories sharing
+    // only "the project name" don't register.
+    let shared = 0;
+    for (const t of a.distinct)
+        if (b.distinct.has(t))
+            shared++;
+    if (shared < CONFLICT_MIN_RARE_SHARED)
+        return null;
+    const conflictType = classifyConflictType(a.window, b.window, a.polarity, b.polarity);
+    if (!conflictType)
+        return null;
+    if (overlapScore < CONFLICT_OVERLAP_THRESHOLD)
+        return null;
+    return {
+        reason: conflictType,
+        score: overlapScore,
+    };
+}
+function distinctiveTokens(text) {
+    return new Set(text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter((t) => t.length > 2 && !CONFLICT_STOPWORDS.has(t)));
+}
+export function jaccardSets(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const t of a)
+        if (b.has(t))
+            inter++;
+    const union = a.size + b.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
+function openingWindow(text) {
+    return text.split(/\s+/).slice(0, POLARITY_WINDOW_WORDS).join(' ');
+}
+// Takes opening windows only, so " on " and " off " as prepositions deep in long prose don't read as enabled/disabled.
+function classifyConflictType(a, b, aPolarity, bPolarity) {
+    // Tightened tokens: require whole-word boundaries so " on " alone doesn't
+    // match "on/off". Pair only `enabled` ↔ `disabled` and explicit on/off in
+    // imperative context.
+    const enabledDisabled = (containsAny(a, [' enabled ', ' enable ']) && containsAny(b, [' disabled ', ' disable ']))
+        || (containsAny(b, [' enabled ', ' enable ']) && containsAny(a, [' disabled ', ' disable ']));
+    if (enabledDisabled)
+        return 'enabled/disabled mismatch on overlapping statement';
+    const trueFalse = (containsAny(a, [' true ', ' true.', ' true,', ' yes ']) && containsAny(b, [' false ', ' false.', ' false,', ' no ']))
+        || (containsAny(b, [' true ', ' true.', ' true,', ' yes ']) && containsAny(a, [' false ', ' false.', ' false,', ' no ']));
+    if (trueFalse)
+        return 'true/false mismatch on overlapping statement';
+    const alwaysNever = (containsAny(a, [' always ', ' must ']) && containsAny(b, [' never ', ' must not ']))
+        || (containsAny(b, [' always ', ' must ']) && containsAny(a, [' never ', ' must not ']));
+    if (alwaysNever)
+        return 'always/never mismatch on overlapping statement';
+    if ((aPolarity === 'positive' && bPolarity === 'negative') || (aPolarity === 'negative' && bPolarity === 'positive')) {
+        return 'negation polarity mismatch on overlapping statement';
+    }
+    return null;
+}
+function inferConflictPolarity(text) {
+    const lowered = ` ${text.toLowerCase()} `;
+    const negativePatterns = [
+        ' not ', ' never ', ' no ', " don't ", ' do not ', " doesn't ", ' does not ',
+        " can't ", ' cannot ', " shouldn't ", ' should not ', ' disabled ', ' disable ', ' off ',
+        ' false ', ' missing ', ' broken ', ' failed ',
+    ];
+    const positivePatterns = [
+        ' enabled ', ' enable ', ' works ', ' working ', ' true ', ' available ', ' present ', ' on ',
+        ' always ', ' must ',
+    ];
+    if (containsAny(lowered, negativePatterns))
+        return 'negative';
+    if (containsAny(lowered, positivePatterns))
+        return 'positive';
+    return 'neutral';
+}
+function stripConflictPolarity(text) {
+    return text
+        .toLowerCase()
+        .replace(/\b(?:not|never|no|don['’]?t|do\s+not|doesn['’]?t|does\s+not|can['’]?t|cannot|shouldn['’]?t|should\s+not|enabled|enable|disabled|disable|on|off|true|false|always|must|must\s+not|works?|working|missing|broken|failed|available|present)\b/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function containsAny(text, needles) {
+    return needles.some((needle) => text.includes(needle));
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/consolidate/decay.d.ts

@@ -0,0 +1,12 @@
+import { MemoryEntry } from '../memory.js';
+import { type MvRankInfo } from '../memory-value.js';
+import type { SleepRun } from './run.js';
+export declare const DECAY_THRESHOLD = 0.05;
+/** What the decay pass hands to the conflict check and the rescue audit at the end of the run. */
+export interface DecayOutcome {
+    rescuedIds: Set<string>;
+    rescuedEntries: MemoryEntry[];
+    rankById: Map<string, MvRankInfo>;
+}
+export declare function decayPass(run: SleepRun): DecayOutcome;
+//# sourceMappingURL=decay.d.ts.map

package/dist/consolidate/decay.js

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

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

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

package/dist/consolidate/llm-passes.js

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

package/dist/consolidate/merge.d.ts

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