hippo-memory 1.52.8 → 1.53.0

package/dist/consolidate.js

@@ -9,8 +9,10 @@
 import { evalNow, isRecallBoostAblated } from './ablation.js';
 import { Layer, calculateStrength, canAutoDelete, createMemory } from './memory.js';
 import { loadAllEntries, batchWriteAndDelete, appendConsolidationRun, replaceDetectedConflicts, loadSessionDecayContext, incrementSleepCount, findPromotableSessions, traceExistsForSession, listSessionEvents, } from './store.js';
-import { textOverlap, markRetrieved } from './search.js';
+import { textOverlap, markRetrieved, tokenize } from './search.js';
 import { compareEntryIdentity } from './compare.js';
+import { duplicateKey, mergedText } from './same-text.js';
+import { successorAfterRetirement } from './merged-row.js';
 import { openHippoDb, closeHippoDb } from './db.js';
 import { rejectionDigest, findRejectedValue } from './rejection.js';
 import { countExpiredDormant, purgeExpiredDormant } from './dormant.js';
@@ -27,9 +29,12 @@ import { appendAuditEvent } from './audit.js';
 import { migrateDefaultHalfLife, LEGACY_TYPED_HALF_LIFE } from './half-life-migration.js';
 import { derivationScope, commonDerivationScope, derivationPartitionKey } from './recall-scope.js';
 import { isQuarantineScope } from './quarantine.js';
+import { NO_MERGE_TAGS } from './shared.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
+const MERGE_MAX_SOURCES = 5; // with MERGE_MAX_CHARS, keeps a merged row near 500 tokens, a third of the 1,500-token context budget
+const MERGE_MAX_CHARS = 2000; // total source text; sources past either cap stay unmerged and keep their half-life
 // Half-life scale for merged source episodics. Demotion must go through
 // half_life_days: calculateStrength() recomputes live strength from
 // last_retrieved/half_life and never reads the stored strength field, so a
@@ -61,6 +66,9 @@ const CONFLICT_STOPWORDS = new Set([
     'more', 'most', 'less', 'least', 'other', 'such', 'same', 'new', 'old', 'one', 'two',
 ]);
 const REPLAY_COUNT_DEFAULT = 5;
+function keptAsWritten(entry) {
+    return entry.tags.some((tag) => NO_MERGE_TAGS.has(tag));
+}
 function isJsonString(value) {
     return typeof value === 'string';
 }
@@ -145,7 +153,7 @@ export async function consolidate(hippoRoot, options = {}) {
         for (const e of all)
             e.half_life_days = halfLife.halfLives.get(e.id) ?? e.half_life_days;
     const backingObjects = memoriesBackingObjects(hippoRoot);
-    // Retirable: auto-deletable (never pinned, never raw) and not backing a first-class object.
+    // Retirable: auto-deletable (never pinned, raw or kept for good) and not backing a first-class object.
     const retirable = (entry) => canAutoDelete(entry) && !backingObjects.has(entry.id);
     const snapshot = new Map(structuredClone(all).map((e) => [e.id, e]));
     // Load decay options from config + session context
@@ -166,7 +174,7 @@ export async function consolidate(hippoRoot, options = {}) {
     // 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, never raw, never backing a first-class object).
+    // Only called for rows `retirable` allows (never pinned, raw, kept for good or backing a first-class object).
     const retireFaded = (entry, strength) => {
         const why = `(strength ${strength.toFixed(4)} < ${DECAY_THRESHOLD})`;
         // A faded secret is deleted, never kept dormant: keeping it would hold a
@@ -503,7 +511,7 @@ export async function consolidate(hippoRoot, options = {}) {
         // 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 && !e.superseded_by && !extractedFromIds.has(e.id));
+        const extractionCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !extractedFromIds.has(e.id) && !keptAsWritten(e));
         result.extractionCandidates = extractionCandidates.length;
         // extraction.enabled=false is the opt-out for every LLM phase below, key or no key.
         const apiKey = config.extraction.enabled !== false ? (process.env.ANTHROPIC_API_KEY ?? '') : '';
@@ -674,10 +682,35 @@ export async function consolidate(hippoRoot, options = {}) {
                 result.details.push(`  ⚠️ physics simulation skipped: ${error instanceof Error ? error.message : 'unknown error'}`);
             }
         }
+        const byId = new Map(all.map((e) => [e.id, e]));
+        const rejectedIn = (tenantId) => (text) => {
+            const db = getConsolidateDb();
+            return db !== null && findRejectedValue(db, tenantId, rejectionDigest(text)) !== null;
+        };
+        for (let i = survivors.length - 1; i >= 0; i--) {
+            const row = survivors[i];
+            const successor = retirable(row) ? successorAfterRetirement(row, byId, rejectedIn(row.tenantId)) : undefined;
+            if (successor === undefined)
+                continue;
+            result.details.push(`  ✂️  ${row.id} held a retired text${successor ? `, ${successor.id} holds the rest` : ''}`);
+            if (dryRun)
+                continue;
+            pendingDeletes.push(row.id);
+            if (successor) {
+                pendingWrites.push(successor);
+                survivors[i] = successor;
+            }
+            else {
+                survivors.splice(i, 1);
+            }
+        }
         // -------------------------------------------------------------------------
         // 3. Merge pass  - episodic entries only
         // -------------------------------------------------------------------------
-        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !e.tags.includes('extracted'));
+        const alreadyMergedIds = new Set(survivors.flatMap((e) => e.parents));
+        const mergeCandidates = survivors.filter((e) => e.layer === Layer.Episodic && !e.superseded_by && !keptAsWritten(e) && !alreadyMergedIds.has(e.id)
+            && !e.pinned // a pin merged with a look-alike would read as one of two values
+            && tokenize(e.content).length > 0);
         const used = new Set();
         // T1 fix (2026-08-15 hardening pass): partition by tenantId BEFORE the
         // overlap loop so a cluster can never span tenants. Previously textOverlap
@@ -708,17 +741,25 @@ export async function consolidate(hippoRoot, options = {}) {
             const mergeTenant = tenantCandidates[0].tenantId;
             const mergeScope = derivationScope(tenantCandidates[0].scope);
             for (let i = 0; i < tenantCandidates.length; i++) {
-                if (used.has(tenantCandidates[i].id))
+                if (used.has(tenantCandidates[i].id) || tenantCandidates[i].content.length > MERGE_MAX_CHARS)
                     continue;
-                const cluster = [tenantCandidates[i]];
+                const related = [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]);
+                        related.push(tenantCandidates[j]);
                     }
                 }
+                const cluster = [];
+                let clusterChars = 0;
+                for (const e of related) {
+                    if (cluster.length === MERGE_MAX_SOURCES || clusterChars + e.content.length > MERGE_MAX_CHARS)
+                        continue;
+                    cluster.push(e);
+                    clusterChars += e.content.length;
+                }
                 if (cluster.length < MERGE_MIN_CLUSTER)
                     continue;
                 // Create a semantic summary
@@ -734,17 +775,20 @@ export async function consolidate(hippoRoot, options = {}) {
                 // 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,
-                        scope: mergeScope,
-                        baseHalfLifeDays: config.defaultHalfLifeDays,
-                    });
+                    semantic = {
+                        ...createMemory(mergedContent, {
+                            layer: Layer.Semantic,
+                            tags: allTags,
+                            emotional_valence: maxValence,
+                            schema_fit: 0.7,
+                            source: 'consolidation',
+                            confidence: 'inferred',
+                            tenantId: mergeTenant,
+                            scope: mergeScope,
+                            baseHalfLifeDays: config.defaultHalfLifeDays,
+                        }),
+                        parents: cluster.map((e) => e.id),
+                    };
                 }
                 // mergeContents is DETERMINISTIC CONCATENATION (not an LLM paraphrase)
                 // — if a human rejected exactly this byte-identical rollup before, an
@@ -756,13 +800,17 @@ export async function consolidate(hippoRoot, options = {}) {
                 // the tombstone is lifted.
                 const consolidateDb = getConsolidateDb();
                 if (consolidateDb && semantic) {
-                    const mergeDigest = rejectionDigest(semantic.content);
-                    const tombstone = findRejectedValue(consolidateDb, semantic.tenantId, mergeDigest);
+                    const newDigest = rejectionDigest(semantic.content);
+                    const oldDigest = rejectionDigest(legacyMergeContents(related)); // tombstones from older releases hold this format's digest
+                    const newHit = findRejectedValue(consolidateDb, semantic.tenantId, newDigest);
+                    const tombstone = newHit ?? findRejectedValue(consolidateDb, semantic.tenantId, oldDigest);
+                    const mergeDigest = newHit ? newDigest : oldDigest;
                     if (tombstone) {
                         // 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)
+                        const rejected = newHit ? cluster : related; // the old format digested the uncapped list, so rows past the cap were rejected too
+                        for (const e of rejected)
                             used.add(e.id);
                         mergesSkippedRejected++;
                         try {
@@ -773,7 +821,7 @@ export async function consolidate(hippoRoot, options = {}) {
                                 metadata: {
                                     digest: mergeDigest,
                                     reason: tombstone.reason,
-                                    sourceIds: cluster.map((e) => e.id),
+                                    sourceIds: rejected.map((e) => e.id),
                                 },
                             });
                         }
@@ -922,17 +970,22 @@ export async function consolidate(hippoRoot, options = {}) {
 // Helpers
 // ---------------------------------------------------------------------------
 function mergeContents(entries) {
-    // Simple merge: take the longest entry as the base, prepend a summary note.
-    // Equal-length merge bases previously fell to cluster-assembly order;
-    // compareEntryIdentity is a deterministic tie key (content asc -> metadata -> id asc),
-    // a no-op when lengths differ (docs/plans/2026-07-16-dedupe-survivor-determinism.md T2).
-    const sorted = [...entries].sort((a, b) => (b.content.length - a.content.length) || compareEntryIdentity(a, b));
-    const base = sorted[0].content;
-    if (entries.length === 2) {
-        return `[Consolidated from ${entries.length} related memories]\n\n${base}`;
+    // Each distinct text goes in once and in full (the merge demotes every source), one bullet with its lines indented, so heldTextKeys can read it back.
+    // Newest first says which version is current; compareEntryIdentity settles ties, so the row and its rejection digest depend only on the sources.
+    const sorted = [...entries].sort((a, b) => (Date.parse(b.created) - Date.parse(a.created)) || compareEntryIdentity(a, b));
+    const texts = new Map();
+    for (const e of sorted) {
+        if (!texts.has(duplicateKey(e.content)))
+            texts.set(duplicateKey(e.content), e.content);
     }
-    // Bullets follow the base order (not raw cluster order) so the merged row
-    // and its rejection digest are byte-identical across ingest orders.
+    const header = entries.length === 2 ? '[Consolidated from 2 related memories, newest first]' : `[Consolidated pattern from ${entries.length} related memories, newest first]`;
+    return mergedText(header, [...texts.values()]);
+}
+function legacyMergeContents(entries) {
+    // The old format dropped text, so it is only ever digested to match rejections recorded against it, never written.
+    const sorted = [...entries].sort((a, b) => (b.content.length - a.content.length) || compareEntryIdentity(a, b));
+    if (entries.length === 2)
+        return `[Consolidated from ${entries.length} related memories]\n\n${sorted[0].content}`;
     const bullets = sorted.map((e) => `- ${e.content.split('\n')[0].slice(0, 120)}`).join('\n');
     return `[Consolidated pattern from ${entries.length} related memories]\n\n${bullets}`;
 }
@@ -966,7 +1019,7 @@ rescuedIds = new Set()) {
                 continue;
             if (survivors[i].superseded_by || survivors[j].superseded_by)
                 continue;
-            if (survivors[i].tags.includes('extracted') || survivors[j].tags.includes('extracted'))
+            if ([survivors[i], survivors[j]].some((e) => e.tags.includes('extracted') || e.tags.includes('session-digest')))
                 continue;
             const reasonAndScore = describeConflict(survivors[i], survivors[j]);
             if (!reasonAndScore)

package/dist/context-render.d.ts

@@ -0,0 +1,36 @@
+import { type MemoryEntry } from './memory.js';
+import { type SessionHandoff } from './handoff.js';
+import type { SessionEvent, TaskSnapshot } from './store.js';
+import type { AssembleCost, AssembleResult, AssembledContextItem, ContextCost, ContextResultEntry, DrillDownChild, DrillDownCost, DrillDownResult } from './api.js';
+export declare function snapshotText(s: TaskSnapshot): string;
+export declare function handoffText(h: SessionHandoff): string;
+/** Needs at least one event; the header reads the latest. */
+export declare function sessionTrailText(events: SessionEvent[]): string;
+export declare function contextHeading(heading: string, entries: number, tokens: number): string;
+export declare function contextLine(item: {
+    entry: MemoryEntry;
+    isGlobal: boolean;
+}, framing: string, showStrength: boolean, now: Date, strengthPct?: number): string;
+export declare function crossProjectHeading(entries: number): string;
+export declare function crossProjectLine(item: Pick<ContextResultEntry, 'entry' | 'origin'>): string;
+/** A header's token figure is part of the text it counts, so render until the figure matches the text. */
+export declare function settleTokens(render: (tokens: number) => string): string;
+export declare function printedTokens(text: string): number;
+export interface AssembleHeadingCounts {
+    sessionId: string;
+    items: number;
+    tokens: number;
+    totalRaw: number;
+    summarized: number;
+    evicted: number;
+}
+export declare function assembleHeading(c: AssembleHeadingCounts): string;
+export declare function assembleLine(it: AssembledContextItem): string;
+/** The window in full, as the MCP tool returns it; the header counts the whole block. */
+export declare function assembleText(r: AssembleResult): string;
+export declare function assembleCost(sessionId: string): AssembleCost;
+export declare function drillLine(c: DrillDownChild): string;
+export declare function drillText(r: DrillDownResult): string;
+export declare const drillCost: DrillDownCost;
+export declare function contextCost(format: 'markdown' | 'additional-context', framing: string): ContextCost;
+//# sourceMappingURL=context-render.d.ts.map

package/dist/context-render.js

@@ -0,0 +1,154 @@
+// The strings a context block prints. The budget prices these same strings, so selection and print cannot drift.
+import { calculateStrength, confidenceFacets, confidenceLabel } from './memory.js';
+import { evalNow } from './ablation.js';
+import { estimateTokens } from './search.js';
+import { renderAmbientSummary } from './ambient.js';
+import { formatHandoffEvidenceLine } from './handoff.js';
+export function snapshotText(s) {
+    return [
+        '## Active Task Snapshot\n',
+        `- Task: ${s.task}`,
+        `- Status: ${s.status}`,
+        `- Updated: ${s.updated_at}`,
+        `- Source: ${s.source}`,
+        ...(s.session_id ? [`- Session: ${s.session_id}`] : []),
+        '', '### Summary', s.summary, '', '### Next step', s.next_step, '',
+    ].join('\n');
+}
+export function handoffText(h) {
+    const lines = ['## Session Handoff\n', `- Session: ${h.sessionId}`, `- Updated: ${h.updatedAt}`];
+    if (h.taskId)
+        lines.push(`- Task: ${h.taskId}`);
+    if (h.repoRoot)
+        lines.push(`- Repo: ${h.repoRoot}`);
+    if (h.outcome)
+        lines.push(`- Outcome: ${h.outcome}`);
+    if (h.targetRuntime)
+        lines.push(`- Target runtime: ${h.targetRuntime}`);
+    if (h.cardId)
+        lines.push(`- Card: ${h.cardId}`);
+    lines.push('', '### Summary', h.summary);
+    if (h.nextAction)
+        lines.push('', '### Next action', h.nextAction);
+    if (h.artifacts && h.artifacts.length > 0)
+        lines.push('', '### Artifacts', ...h.artifacts.map((a) => `- ${a}`));
+    if (h.constraints && h.constraints.length > 0)
+        lines.push('', '### Constraints', ...h.constraints.map((c) => `- ${c}`));
+    if (h.evidence)
+        lines.push('', '### Evidence', formatHandoffEvidenceLine(h.evidence));
+    lines.push('');
+    return lines.join('\n');
+}
+/** Needs at least one event; the header reads the latest. */
+export function sessionTrailText(events) {
+    const latest = events[events.length - 1];
+    return [
+        '## Recent Session Trail\n',
+        `- Session: ${latest.session_id}`,
+        `- Task: ${latest.task ?? 'n/a'}`,
+        `- Updated: ${latest.created_at}`,
+        '',
+        ...events.map((e) => `- [${e.created_at}] (${e.event_type}) ${e.content}`),
+        '',
+    ].join('\n');
+}
+export function contextHeading(heading, entries, tokens) {
+    return `## ${heading} (${entries} entries, ${tokens} tokens)\n`;
+}
+export function contextLine(item, framing, showStrength, now, strengthPct = Math.round(calculateStrength(item.entry) * 100)) {
+    const e = item.entry;
+    const tagStr = e.tags.length > 0 ? ` [${e.tags.join(', ')}]` : '';
+    const strengthStr = showStrength ? ` (${strengthPct}%)` : '';
+    const globalPrefix = item.isGlobal ? '[global] ' : '';
+    const label = confidenceLabel(e, now);
+    const confTag = `[${label.text}]${label.warn ? ' ⚠️' : ''}`;
+    if (framing === 'observe') {
+        const dateStr = new Date(e.created).toISOString().slice(0, 10);
+        // Verified rules print without the date prefix.
+        if (confidenceFacets(e, now).tier === 'verified')
+            return `- **${confTag} ${globalPrefix}${e.content}**${tagStr}${strengthStr}`;
+        return `- **${confTag} Previously observed (${dateStr}): ${globalPrefix}${e.content}**${tagStr}${strengthStr}`;
+    }
+    if (framing === 'suggest')
+        return `- **${confTag} Consider checking: ${globalPrefix}${e.content}**${tagStr}${strengthStr}`;
+    return `- **${confTag} ${globalPrefix}${e.content}**${tagStr}${strengthStr}`;
+}
+export function crossProjectHeading(entries) {
+    return `\n## Other-project memory (explicitly requested, ${entries} entries)\n`;
+}
+export function crossProjectLine(item) {
+    const originLabel = item.origin === null || item.origin === '' ? 'unknown-origin' : item.origin;
+    const tagStr = item.entry.tags.length > 0 ? ` [${item.entry.tags.join(', ')}]` : '';
+    return `- **[${originLabel}]** ${item.entry.content}${tagStr}`;
+}
+/** A header's token figure is part of the text it counts, so render until the figure matches the text. */
+export function settleTokens(render) {
+    let t = 0;
+    let text = render(t);
+    // The figure only gains digits, so this settles in a few rounds; the cap guards a render that reads the clock.
+    for (let i = 0; i < 8 && estimateTokens(text) !== t; i++) {
+        t = estimateTokens(text);
+        text = render(t);
+    }
+    return text;
+}
+// Every summary slot at its longest wording, so the footer reserve covers whatever the summary says.
+const WIDEST_AMBIENT = {
+    tagEntropy: 1, avgStrength: 0, recencyFreshness: 1, emotionalSkew: -1, schemaFitRatio: 0, errorDensity: 0,
+    consolidationRatio: 1, conflictIntensity: 1, extractionCoverage: 1,
+    dagDepth: Number.MAX_SAFE_INTEGER, totalMemories: Number.MAX_SAFE_INTEGER,
+};
+// Each piece is priced with the newline that follows it, so the pieces' sum bounds the joined block.
+export function printedTokens(text) {
+    return estimateTokens(text + '\n');
+}
+export function assembleHeading(c) {
+    return `Session ${c.sessionId} \u2014 ${c.items} items, ${c.tokens} tokens (raw=${c.totalRaw}, summarized=${c.summarized}, evicted=${c.evicted})`;
+}
+export function assembleLine(it) {
+    const prefix = it.isSummary ? '[summary]' : it.isFreshTail ? '[tail]' : '[older]';
+    return `  ${prefix} ${it.createdAt} ${it.id} - ${it.content}`;
+}
+/** The window in full, as the MCP tool returns it; the header counts the whole block. */
+export function assembleText(r) {
+    return settleTokens((t) => [assembleHeading({ ...r, items: r.items.length, tokens: t }), ...r.items.map(assembleLine)].join('\n'));
+}
+// Every format prices the full lines: JSON carries full content, and the CLI's previews are never longer.
+export function assembleCost(sessionId) {
+    return {
+        item: (it) => printedTokens(assembleLine(it)),
+        fixed: (w) => printedTokens(assembleHeading({ sessionId, items: w, tokens: w, totalRaw: w, summarized: w, evicted: w })),
+    };
+}
+function drillHead(s, shown, total, truncated) {
+    const span = s.earliestAt ? ` (${s.earliestAt} -> ${s.latestAt})` : '';
+    return `Summary ${s.id} \u2014 ${s.descendantCount} descendants${span}\n  ${s.content}\n\nChildren (${shown}/${total}${truncated ? ', truncated' : ''}):`;
+}
+export function drillLine(c) {
+    return `  [L${c.dagLevel}] ${c.id} - ${c.content}`;
+}
+export function drillText(r) {
+    return [drillHead(r.summary, r.children.length, r.totalChildren, r.truncated), ...r.children.map(drillLine)].join('\n');
+}
+export const drillCost = {
+    child: (c) => printedTokens(drillLine(c)),
+    fixed: (s, w) => printedTokens(drillHead(s, w, w, true)),
+};
+// Headers and footer are reserved at their widest (counts at the budget itself, strength at 100%) before any entry.
+export function contextCost(format, framing) {
+    const hook = format === 'additional-context';
+    const price = printedTokens;
+    return {
+        entry: (item) => price(item.category === 'cross-project' && !(hook && item.promptRecall)
+            ? crossProjectLine(item)
+            : contextLine({ entry: item.entry, isGlobal: item.isGlobal ?? false }, framing, !hook, evalNow(), 100)),
+        fixed: (budget, can) => price(contextHeading('Project Memory', budget, budget))
+            + (can.cross ? price(crossProjectHeading(budget)) : 0)
+            + (hook && can.promptRecall ? price(contextHeading('Prompt-Relevant Memory', budget, budget)) : 0)
+            + (!hook && can.ambient ? price(`\n${renderAmbientSummary(WIDEST_AMBIENT)}`) : 0),
+        snapshot: (s) => price(snapshotText(s)),
+        handoff: (h) => price(handoffText(h)),
+        trail: (events) => price(sessionTrailText(events)),
+    };
+}
+//# sourceMappingURL=context-render.js.map

package/dist/dag.js

@@ -4,6 +4,7 @@ import { RejectedValueError } from './rejection.js';
 import { redactSecrets } from './secret-detect.js';
 import { derivationScope, derivationPartitionKey } from './recall-scope.js';
 import { loadConfig } from './config.js';
+import { neverAutoShareTags } from './shared.js';
 export function clusterFacts(facts) {
     if (facts.length === 0)
         return [];
@@ -120,7 +121,7 @@ export async function buildDag(hippoRoot, facts, opts) {
             // (memory.ts:535 defaults tenantId when the option is omitted).
             const summaryEntry = createMemory(summary, {
                 layer: Layer.Semantic,
-                tags: [...cluster.entityTags, 'dag-summary'],
+                tags: [...cluster.entityTags, ...neverAutoShareTags(cluster.members), 'dag-summary'],
                 confidence: 'inferred',
                 dag_level: 2,
                 tenantId: factTenant,
@@ -329,7 +330,7 @@ export async function buildEntityProfiles(hippoRoot, l2Summaries, opts) {
             const nowIso = new Date().toISOString();
             const profileEntry = createMemory(summary, {
                 layer: Layer.Semantic,
-                tags: [...cluster.entityTags, 'dag-entity-profile'],
+                tags: [...cluster.entityTags, ...neverAutoShareTags(cluster.members), 'dag-entity-profile'],
                 confidence: 'inferred',
                 dag_level: 3,
                 tenantId, // HIGH #1 fold: thread tenant explicitly

package/dist/db.d.ts

@@ -16,7 +16,11 @@ export declare function getCurrentSchemaVersion(): number;
 /** Thrown by {@link assertBinaryCompatible}; doctor uses it to pick the upgrade fix over a generic permissions fix. */
 export declare class IncompatibleBinaryError extends Error {
 }
-export declare function openHippoDb(hippoRoot: string): DatabaseSyncLike;
+export declare function isSqliteBusy(error: unknown): boolean;
+/** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
+export declare function openHippoDb(hippoRoot: string, opts?: {
+    busyWaitMs?: number;
+}): DatabaseSyncLike;
 /** Open an existing store without changing it: no mkdir, WAL switch, migration or mirror cleanup. Throws when hippo.db is missing. */
 export declare function openHippoDbReadOnly(hippoRoot: string): DatabaseSyncLike;
 export declare function getSchemaVersion(db: DatabaseSyncLike): number;

package/dist/db.js

@@ -11,7 +11,7 @@ const require = createRequire(import.meta.url);
 // runtime (Node's built-in synchronous SQLite module); there are no bundled
 // types for it here, so this require + cast is the module's documented boundary.
 const { DatabaseSync } = require('node:sqlite');
-const CURRENT_SCHEMA_VERSION = 48;
+const CURRENT_SCHEMA_VERSION = 49;
 const MIGRATIONS = [
     {
         version: 1,
@@ -2398,12 +2398,12 @@ const MIGRATIONS = [
         version: 45,
         up: (db) => {
             // Token ledger (src/token-ledger.ts, ROADMAP TE0): one row per block of
-            // memory text hippo hands an agent (hook, CLI, MCP, HTTP). `event` is
-            // 'inject' (sent), 'skip' (unchanged since the session's last inject,
-            // not sent) or 'reset' (compaction dropped earlier injections, so the
-            // next one must be sent). block_hash lets the per-prompt hook skip an
-            // unchanged block. Rows older than the retention window are pruned on
-            // write. Additive only: no min_compatible_binary bump.
+            // memory text hippo hands an agent (hook, CLI, MCP, HTTP). `event` is 'inject'
+            // (sent), 'skip' (unchanged since the session's last inject, not sent), 'reset'
+            // (compaction dropped earlier injections, so the next one must be sent) or
+            // 'reread' (re-read by later calls, booked at session end per call day). block_hash
+            // lets the per-prompt hook skip an unchanged block. Rows older than the retention
+            // window are pruned on write. Additive only: no min_compatible_binary bump.
             db.exec(`
         CREATE TABLE IF NOT EXISTS token_ledger (
           id         INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -2471,6 +2471,36 @@ const MIGRATIONS = [
             db.exec(MEMORY_QUARANTINE_DDL);
         },
     },
+    {
+        version: 49,
+        up: (db) => {
+            // Compaction record (src/compaction-record.ts): one row per Claude Code compaction, written before it (started)
+            // and after it (summarised, done). Not a memory row. Additive only: no min_compatible_binary bump.
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS compactions (
+          tenant_id       TEXT NOT NULL DEFAULT 'default',
+          id              TEXT NOT NULL,
+          session_id      TEXT NOT NULL,
+          origin_project  TEXT NOT NULL DEFAULT '',
+          compact_trigger TEXT,
+          cwd             TEXT,
+          transcript_path TEXT,
+          snapshot_saved  INTEGER NOT NULL DEFAULT 0,
+          started_at      TEXT NOT NULL,
+          summarised_at   TEXT,
+          summary         TEXT,
+          items_json      TEXT,
+          items_written   INTEGER NOT NULL DEFAULT 0,
+          status          TEXT NOT NULL DEFAULT 'started' CHECK (status IN ('started','summarised','done','no-summary')),
+          PRIMARY KEY (tenant_id, id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_compactions_session
+          ON compactions(tenant_id, session_id, started_at);
+        CREATE INDEX IF NOT EXISTS idx_compactions_status
+          ON compactions(tenant_id, status);
+      `);
+        },
+    },
 ];
 function tableHasColumn(db, tableName, columnName) {
     if (!/^[a-z_]+$/i.test(tableName))
@@ -2504,7 +2534,7 @@ function assertBinaryCompatible(db) {
             `Upgrade hippo-memory to open it; an older binary does not know this schema and could expose private rows or damage the store.`);
     }
 }
-function isSqliteBusy(error) {
+export function isSqliteBusy(error) {
     const code = error?.errcode;
     return code === 5 || code === 6 || code === 517;
 }
@@ -2526,16 +2556,18 @@ function execWithBusyRetry(db, sql, timeoutMs = 30000) {
         }
     }
 }
-export function openHippoDb(hippoRoot) {
+/** `busyWaitMs` shortens every lock wait of this open, for a hook that must finish inside its own timeout. */
+export function openHippoDb(hippoRoot, opts) {
     fs.mkdirSync(hippoRoot, { recursive: true });
     const db = new DatabaseSync(getHippoDbPath(hippoRoot));
+    const busyWaitMs = opts?.busyWaitMs;
     try {
-        db.exec('PRAGMA busy_timeout = 5000');
-        execWithBusyRetry(db, 'PRAGMA journal_mode = WAL');
+        db.exec(`PRAGMA busy_timeout = ${busyWaitMs ?? 5000}`);
+        execWithBusyRetry(db, 'PRAGMA journal_mode = WAL', busyWaitMs);
         db.exec('PRAGMA synchronous = NORMAL');
         db.exec('PRAGMA wal_autocheckpoint = 100');
         db.exec('PRAGMA foreign_keys = ON');
-        runMigrations(db, hippoRoot);
+        runMigrations(db, hippoRoot, busyWaitMs);
         // Path A backfill: delete any orphan markdown mirrors for already-archived
         // raw_archive rows. Idempotent via per-row raw_archive.mirror_cleaned_at
         // (v21). Wrapped in try/catch — a filesystem failure must not prevent DB open.
@@ -2576,7 +2608,7 @@ export function openHippoDbReadOnly(hippoRoot) {
         throw error;
     }
 }
-function runMigrations(db, hippoRoot) {
+function runMigrations(db, hippoRoot, busyWaitMs) {
     ensureMetaTable(db);
     // Before anything writes, so a stale binary never repairs or migrates a store it does not understand.
     assertBinaryCompatible(db);
@@ -2586,7 +2618,7 @@ function runMigrations(db, hippoRoot) {
     for (const migration of MIGRATIONS) {
         if (migration.version <= currentVersion)
             continue;
-        execWithBusyRetry(db, 'BEGIN IMMEDIATE');
+        execWithBusyRetry(db, 'BEGIN IMMEDIATE', busyWaitMs);
         try {
             // A newer binary may have migrated and raised the minimum while we waited for the lock.
             assertBinaryCompatible(db);

package/dist/dedupe.d.ts

@@ -1,6 +1,6 @@
 /**
- * Store-level deduplication. Scans for near-duplicate memories by content
- * Jaccard overlap, keeps the stronger copy (by strength + retrieval count),
+ * Store-level deduplication. Scans for memories with the same text apart
+ * from spacing, keeps the stronger copy (by strength + retrieval count),
  * removes the rest.
  *
  * Extracted from cli.ts in Episode A (v1.11.3) so `api.sleep` can dedupe
@@ -59,13 +59,13 @@ export interface DedupResult {
  */
 export declare function strengthBucket(strength: number | null | undefined): number;
 /**
- * Scan the store for near-duplicate memories and remove the weaker copy.
- * Two memories are duplicates if their content has > threshold Jaccard
- * overlap AND they belong to the same tenant: the scan is partitioned by
+ * Scan the store for duplicates and remove the weaker copy: same text apart
+ * from spacing, since a near-duplicate can differ in a value (port, version,
+ * path, name), AND the same tenant: the scan is partitioned by
  * tenantId, so byte-identical content in two tenants is never a duplicate
  * pair (the tenant boundary is an isolation boundary; cross-tenant removal
  * was the v1.32.0 known-issue data-loss bug).
- * Keeps the one with higher strength (or more retrievals if tied).
+ * Keeps the one with higher strength (or more retrievals if tied). `threshold` is accepted for old callers and ignored.
  */
 export declare function deduplicateStore(hippoRoot: string, options?: {
     threshold?: number;