hippo-memory 1.52.8 → 1.52.9

package/dist/codex-patch.d.ts

@@ -0,0 +1,12 @@
+/** Codex prints this line only when a patch applied (apply-patch lib.rs). */
+export declare const PATCH_SUCCESS_LINE = "Success. Updated the following files:";
+/** Paths a patch body adds, deletes, updates or moves to, in patch order; [] when the text holds no patch. */
+export declare function patchPaths(body: string): string[];
+export interface ShellPatch {
+    body: string;
+    /** The `cd <dir> &&` target, relative to the call's working directory. */
+    cd: string | null;
+}
+/** The patch a shell call hands to apply_patch, or null for any other command. */
+export declare function shellPatch(command: readonly string[] | string): ShellPatch | null;
+//# sourceMappingURL=codex-patch.d.ts.map

package/dist/codex-patch.js

@@ -0,0 +1,71 @@
+// Files named by a Codex apply_patch call, read the way openai/codex codex-rs/apply-patch reads them
+// (parser.rs for the body, invocation.rs for the shell forms it runs as apply_patch).
+import * as path from 'path';
+import { isStringValue } from './capture.js';
+/** Codex prints this line only when a patch applied (apply-patch lib.rs). */
+export const PATCH_SUCCESS_LINE = 'Success. Updated the following files:';
+const BEGIN_PATCH = '*** Begin Patch';
+const END_PATCH = '*** End Patch';
+const MOVE_TO = '*** Move to: ';
+const FILE_HEADER = /^\*\*\* (Add|Delete|Update) File: (.+)$/;
+/** Paths a patch body adds, deletes, updates or moves to, in patch order; [] when the text holds no patch. */
+export function patchPaths(body) {
+    const lines = body.split(/\r?\n/);
+    const start = lines.findIndex((l) => l.trim() === BEGIN_PATCH);
+    if (start < 0)
+        return [];
+    const paths = [];
+    let updating = false;
+    let canMove = false;
+    for (const line of lines.slice(start + 1)) {
+        // Inside an update hunk a leading space marks a context line, so headers match on trimEnd only there.
+        const head = updating ? line.trimEnd() : line.trim();
+        if (head === END_PATCH)
+            break;
+        const header = FILE_HEADER.exec(head);
+        if (header) {
+            paths.push(header[2].trim());
+            updating = header[1] === 'Update';
+            canMove = updating;
+            continue;
+        }
+        if (canMove && head.startsWith(MOVE_TO))
+            paths.push(head.slice(MOVE_TO.length).trim());
+        canMove = false;
+    }
+    return paths.filter(Boolean);
+}
+const HEREDOC = /^\s*(?:cd\s+(?<cd>'[^']*'|"[^"]*"|[^\s'"&|;]+)\s+&&\s+)?(?:apply_patch|applypatch)\s+<<\s*(?<q>['"]?)(?<tag>\w+)\k<q>[ \t]*\r?\n(?<body>[\s\S]*?)\r?\n\s*\k<tag>\s*$/;
+/** The script a shell argv runs, for the shells Codex checks for an apply_patch heredoc. */
+function shellScript(argv) {
+    const exe = path.basename(argv[0] ?? '').toLowerCase().replace(/\.exe$/, '');
+    if ((exe === 'bash' || exe === 'zsh' || exe === 'sh') && argv.length === 3 && (argv[1] === '-lc' || argv[1] === '-c'))
+        return argv[2];
+    if (exe === 'pwsh' || exe === 'powershell') {
+        const rest = argv.slice(1).filter((a) => a.toLowerCase() !== '-noprofile');
+        if (rest.length === 2 && rest[0].toLowerCase() === '-command')
+            return rest[1];
+    }
+    if (exe === 'cmd' && argv.length === 3 && argv[1].toLowerCase() === '/c')
+        return argv[2];
+    return null;
+}
+/** The patch a shell call hands to apply_patch, or null for any other command. */
+export function shellPatch(command) {
+    let script;
+    if (isStringValue(command)) {
+        script = command;
+    }
+    else {
+        const exe = path.basename(command[0] ?? '').toLowerCase();
+        if (command.length === 2 && (exe === 'apply_patch' || exe === 'applypatch'))
+            return { body: command[1], cd: null };
+        script = shellScript(command);
+    }
+    const match = script === null ? null : HEREDOC.exec(script);
+    if (!match?.groups)
+        return null;
+    const cd = match.groups.cd ?? null;
+    return { body: match.groups.body, cd: cd === null ? null : cd.replace(/^(['"])(.*)\1$/, '$2') };
+}
+//# sourceMappingURL=codex-patch.js.map

package/dist/config.d.ts

@@ -138,5 +138,4 @@ export interface HippoConfig {
     };
 }
 export declare function loadConfig(hippoRoot: string): HippoConfig;
-export declare function saveConfig(hippoRoot: string, config: HippoConfig): void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -201,8 +201,4 @@ export function loadConfig(hippoRoot) {
         return { ...DEFAULT_CONFIG };
     }
 }
-export function saveConfig(hippoRoot, config) {
-    const configPath = path.join(hippoRoot, 'config.json');
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
-}
 //# sourceMappingURL=config.js.map

package/dist/connectors/slack/types.d.ts

@@ -40,7 +40,6 @@ export interface SlackEventEnvelope {
         [k: string]: JsonValue;
     };
 }
-export type SlackInbound = SlackEventEnvelope | SlackUrlVerification;
 export declare function isSlackEventEnvelope(x: JsonValue): x is JsonValue & SlackEventEnvelope;
 export declare function isSlackMessageEvent(x: JsonValue | SlackEventEnvelope['event']): x is SlackMessageEvent;
 //# sourceMappingURL=types.d.ts.map

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';
 }
@@ -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.js

@@ -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,

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;