hippo-memory 1.52.8 → 1.52.9

package/dist/merged-row.js

@@ -0,0 +1,35 @@
+// A sleep-merged row copies its sources' texts, so retiring a text (reject, or superseding its source) must reach the row too.
+// SHORTCUT: reject rewrites merged rows at once, live and dormant; supersede and `resolve --reject-loser` wait for the next sleep's check, which sees a dormant row only once restored.
+import { generateId } from './memory.js';
+import { duplicateKey, heldTexts, mergedText } from './same-text.js';
+/** The row that replaces a merged row once its retired texts leave: undefined when it holds none, null when nothing else is left. */
+export function mergedSuccessor(row, retired, retiredIds) {
+    const texts = heldTexts(row);
+    const kept = texts.filter((t) => !retired(t));
+    if (kept.length === texts.length)
+        return undefined;
+    if (kept.length === 0)
+        return null;
+    const count = `${kept.length} related ${kept.length === 1 ? 'memory' : 'memories'}`;
+    const header = row.content.slice(0, row.content.indexOf('\n\n')).replace(/\d+ related memor(?:y|ies)/, count);
+    // A new id, as a fresh merge would get; age and half-life carry over so the rewrite buys the row no extra life.
+    return {
+        ...row,
+        id: generateId('sem'),
+        content: mergedText(header, kept),
+        parents: row.parents.filter((id) => !retiredIds.has(id)),
+        conflicts_with: [],
+    };
+}
+/** Sleep's check on a merged row: drops texts whose source was superseded since the merge, or that a rejection now covers. */
+export function successorAfterRetirement(row, byId, rejected) {
+    if (row.source !== 'consolidation' || row.superseded_by)
+        return undefined;
+    const sources = row.parents.flatMap((id) => byId.get(id) ?? []);
+    const retiredIds = new Set(sources.filter((s) => Boolean(s.superseded_by) || rejected(s.content)).map((s) => s.id));
+    const live = new Set(sources.filter((s) => !retiredIds.has(s.id)).map((s) => duplicateKey(s.content)));
+    const gone = new Set(sources.filter((s) => retiredIds.has(s.id)).map((s) => duplicateKey(s.content)));
+    const retired = (text) => (gone.has(duplicateKey(text)) && !live.has(duplicateKey(text))) || rejected(text);
+    return mergedSuccessor(row, retired, retiredIds);
+}
+//# sourceMappingURL=merged-row.js.map

package/dist/multihop.d.ts

@@ -1,10 +1,11 @@
 import type { MemoryEntry } from './memory.js';
-import { type SearchResult } from './search.js';
+import { type ResultCost, type SearchResult } from './search.js';
 export declare function multihopSearch(query: string, entries: MemoryEntry[], options?: {
     budget?: number;
     now?: Date;
     hippoRoot?: string;
     minResults?: number;
+    cost?: ResultCost;
     includeSuperseded?: boolean;
     asOf?: string;
 }): SearchResult[];

package/dist/multihop.js

@@ -1,6 +1,9 @@
-import { search } from './search.js';
+import { fitBudget, search } from './search.js';
 export function multihopSearch(query, entries, options = {}) {
-    const pass1 = search(query, entries, { ...options, budget: (options.budget ?? 4000) * 2 });
+    const budget = options.budget ?? 4000;
+    // Pass 1 searches wide to find entities, so each return fits the caller's budget, as search() does.
+    const fit = (ordered) => fitBudget(ordered, budget, options.minResults ?? 1, options.cost);
+    const pass1 = search(query, entries, { ...options, budget: budget * 2 });
     const topK = pass1.slice(0, 10);
     if (topK.length === 0)
         return [];
@@ -17,7 +20,7 @@ export function multihopSearch(query, entries, options = {}) {
         .map((t) => t.split(':')[1])
         .filter((e) => !queryLower.includes(e.toLowerCase()));
     if (newEntities.length === 0)
-        return pass1;
+        return fit(pass1);
     const followUpQuery = newEntities.join(' ') + ' ' + query;
     const pass2 = search(followUpQuery, entries, options);
     const merged = new Map();
@@ -30,6 +33,6 @@ export function multihopSearch(query, entries, options = {}) {
     // T2 note: PLAIN stable score sort on purpose -- pass1/pass2 inputs are
     // deterministically ordered (search() carries the content tail), stability
     // inherits that, and ties keep pass-1 results ahead of pass-2 follow-ups.
-    return [...merged.values()].sort((a, b) => b.score - a.score);
+    return fit([...merged.values()].sort((a, b) => b.score - a.score));
 }
 //# sourceMappingURL=multihop.js.map

package/dist/physics-state.d.ts

@@ -26,10 +26,6 @@ export declare function savePhysicsState(db: DatabaseSyncLike, particles: Physic
  * Returns the new particle (does not persist — caller must save).
  */
 export declare function initializeParticle(entry: MemoryEntry, embedding: number[], now?: Date): PhysicsParticle;
-/**
- * Delete physics state for a memory. (Also handled by CASCADE, but explicit for clarity.)
- */
-export declare function deletePhysicsState(db: DatabaseSyncLike, memoryId: string): void;
 /**
  * Reset all physics states from original embeddings.
  * Drops existing physics data and re-initializes from the embedding index.

package/dist/physics-state.js

@@ -129,12 +129,6 @@ export function initializeParticle(entry, embedding, now = evalNow()) {
         lastSimulation: now.toISOString(),
     };
 }
-/**
- * Delete physics state for a memory. (Also handled by CASCADE, but explicit for clarity.)
- */
-export function deletePhysicsState(db, memoryId) {
-    db.prepare('DELETE FROM memory_physics WHERE memory_id = ?').run(memoryId);
-}
 /**
  * Reset all physics states from original embeddings.
  * Drops existing physics data and re-initializes from the embedding index.

package/dist/predictions.d.ts

@@ -116,7 +116,7 @@ export interface PredictionBaserate {
  */
 export declare function computePredictionBaserate(hippoRoot: string, tenantId: string, classTag: string, actor?: string, 
 /** v0.32 / J3.2 — when false, skip the predict_baserate audit emit. The
- *  J3.2 orchestrator (computePlanningFallacyHint, below) calls this with
+ *  J3.2 orchestrator (computePlanningFallacyOutput, below) calls this with
  *  emitAudit=false and emits its own `recall_autodebias_hint` audit row
  *  instead, so the predict_baserate channel stays scoped to deliberate
  *  CLI / HTTP / MCP predict-baserate calls and does NOT pollute on every
@@ -183,10 +183,6 @@ export interface PlanningFallacyWatching {
  * `computePlanningFallacyOutput`. Carries EITHER `hint` (baserate
  * available) OR `watching` (regex fired, no baserate), or NEITHER (mode=off,
  * no queryText, no regex match, or nClosed=0 silent path). Never both.
- *
- * Existing `computePlanningFallacyHint` (preserved as a backward-compat
- * wrapper) returns only the hint variant; new code should call
- * `computePlanningFallacyOutput` directly to surface the watching variant.
  */
 export interface PlanningFallacyOutput {
     hint?: PlanningFallacyHint;
@@ -206,8 +202,7 @@ export interface ComputePlanningFallacyHintOpts {
     actor?: string;
 }
 /**
- * J3.2 orchestrator (v1.13.4: richer return type — see computePlanningFallacyHint
- * below for the backward-compat wrapper that returns only the hint variant).
+ * J3.2 orchestrator.
  *
  * Composes the forward-claim detector + class resolver + baserate compute,
  * with telemetry-grade audit emission at every decision point (success,
@@ -233,14 +228,4 @@ export interface ComputePlanningFallacyHintOpts {
  * on full match+resolve+baserate path. Well under 50ms target.
  */
 export declare function computePlanningFallacyOutput(hippoRoot: string, tenantId: string, queryText: string, opts?: ComputePlanningFallacyHintOpts): PlanningFallacyOutput;
-/**
- * v1.13.4 backward-compat wrapper: thin shim around
- * computePlanningFallacyOutput that returns only the hint variant.
- * Existing callers (api.recall, cmdRecall, MCP handler) that don't yet
- * consume the watching variant continue to work unchanged.
- *
- * New callers that want to surface the silent no-class-match / tiebreak
- * paths to users should call computePlanningFallacyOutput directly.
- */
-export declare function computePlanningFallacyHint(hippoRoot: string, tenantId: string, queryText: string, opts?: ComputePlanningFallacyHintOpts): PlanningFallacyHint | null;
 //# sourceMappingURL=predictions.d.ts.map

package/dist/predictions.js

@@ -284,7 +284,7 @@ export function loadPredictionsByClass(hippoRoot, tenantId, classTag, opts = {})
  */
 export function computePredictionBaserate(hippoRoot, tenantId, classTag, actor = 'cli', 
 /** v0.32 / J3.2 — when false, skip the predict_baserate audit emit. The
- *  J3.2 orchestrator (computePlanningFallacyHint, below) calls this with
+ *  J3.2 orchestrator (computePlanningFallacyOutput, below) calls this with
  *  emitAudit=false and emits its own `recall_autodebias_hint` audit row
  *  instead, so the predict_baserate channel stays scoped to deliberate
  *  CLI / HTTP / MCP predict-baserate calls and does NOT pollute on every
@@ -487,8 +487,7 @@ function resolveClassFromTokens(hippoRoot, tenantId, queryTokens) {
     }
 }
 /**
- * J3.2 orchestrator (v1.13.4: richer return type — see computePlanningFallacyHint
- * below for the backward-compat wrapper that returns only the hint variant).
+ * J3.2 orchestrator.
  *
  * Composes the forward-claim detector + class resolver + baserate compute,
  * with telemetry-grade audit emission at every decision point (success,
@@ -616,16 +615,4 @@ export function computePlanningFallacyOutput(hippoRoot, tenantId, queryText, opt
         },
     };
 }
-/**
- * v1.13.4 backward-compat wrapper: thin shim around
- * computePlanningFallacyOutput that returns only the hint variant.
- * Existing callers (api.recall, cmdRecall, MCP handler) that don't yet
- * consume the watching variant continue to work unchanged.
- *
- * New callers that want to surface the silent no-class-match / tiebreak
- * paths to users should call computePlanningFallacyOutput directly.
- */
-export function computePlanningFallacyHint(hippoRoot, tenantId, queryText, opts = {}) {
-    return computePlanningFallacyOutput(hippoRoot, tenantId, queryText, opts).hint ?? null;
-}
 //# sourceMappingURL=predictions.js.map

package/dist/reject-flow.d.ts

@@ -7,8 +7,8 @@
  * SAME multi-step transaction + post-commit mirror-purge flow. Extracted
  * here (leaf module) so neither duplicates it.
  *
- * Module direction: this file imports from store.ts, rejection.ts,
- * raw-archive.ts and dormant.ts. Nothing imports FROM this file except
+ * Module direction: this file imports from store.ts, rejection.ts, raw-archive.ts,
+ * dormant.ts, same-text.ts and merged-row.ts. Nothing imports FROM this file except
  * cli.ts and api.ts, so it introduces no cycle.
  */
 import { type RejectedValueRow } from './rejection.js';
@@ -28,12 +28,14 @@ export interface RejectFlowResult {
      *  tombstone itself stores no content — this is the only place it's seen
      *  again after this call returns). */
     content: string;
-    /** Every live row removed this call (all tenant rows whose normalized
-     *  digest matched — not just the id passed, per the K1/R7 duplicate
-     *  lesson). */
+    /** Every row removed this call, live or dormant: all whose normalized digest matched (not just the id
+     *  passed, per the K1/R7 duplicate lesson), and each sleep-merged row holding the value, whose other
+     *  texts move to a new row: listed in successorIds when it was live, dormantSuccessorIds when dormant. */
     removedIds: string[];
     /** Subset of removedIds that were kind='raw' (archived, not deleted). */
     removedRawIds: string[];
+    successorIds: string[];
+    dormantSuccessorIds: string[];
 }
 /**
  * `hippo reject` / `api.reject` core flow. ONE connection, one transaction:

package/dist/reject-flow.js

@@ -7,15 +7,17 @@
  * SAME multi-step transaction + post-commit mirror-purge flow. Extracted
  * here (leaf module) so neither duplicates it.
  *
- * Module direction: this file imports from store.ts, rejection.ts,
- * raw-archive.ts and dormant.ts. Nothing imports FROM this file except
+ * Module direction: this file imports from store.ts, rejection.ts, raw-archive.ts,
+ * dormant.ts, same-text.ts and merged-row.ts. Nothing imports FROM this file except
  * cli.ts and api.ts, so it introduces no cycle.
  */
 import { closeHippoDb } from './db.js';
 import { appendAuditEvent } from './audit.js';
 import { archiveRawMemory } from './raw-archive.js';
-import { purgeDormantByDigest } from './dormant.js';
-import { openStore, deleteEntryCore, purgeMirrorBestEffort, } from './store.js';
+import { deleteDormantRow, listDormantSnapshots, purgeDormantByDigest, replaceDormantEntry } from './dormant.js';
+import { openStore, deleteEntryCore, purgeMirrorBestEffort, selectAllEntries, stampOriginProject, writeEntryDbOnly, writeEntryMirrors, } from './store.js';
+import { heldTexts } from './same-text.js';
+import { mergedSuccessor } from './merged-row.js';
 import { rejectionDigest, normalizeValueForRejection, insertRejectedValue, deleteRejectedValue, listRejectedValues, } from './rejection.js';
 /**
  * `hippo reject` / `api.reject` core flow. ONE connection, one transaction:
@@ -66,6 +68,8 @@ export function rejectValue(opts) {
         const now = new Date().toISOString();
         const removedIds = [];
         const removedRawIds = [];
+        const successors = [];
+        const dormantSuccessorIds = [];
         db.exec('BEGIN');
         try {
             insertRejectedValue(db, {
@@ -80,13 +84,14 @@ export function rejectValue(opts) {
             // O(N) scan over the tenant's rows (plan §4): human-triggered command
             // on ~1-5k-row stores — acceptable, documented. A digest column on
             // memories is the escape if stores grow 100x; not needed now.
-            // SAFETY: rows' shape matches the three columns named in the SELECT above.
-            const rows = db
-                .prepare(`SELECT id, kind, content FROM memories WHERE tenant_id = ?`)
-                .all(opts.tenantId);
-            for (const row of rows) {
-                if (rejectionDigest(row.content) !== digest)
+            const holdsValue = (text) => rejectionDigest(text) === digest;
+            const merged = [];
+            for (const row of selectAllEntries(db, opts.tenantId)) {
+                if (!holdsValue(row.content)) {
+                    if (heldTexts(row).some(holdsValue))
+                        merged.push(row);
                     continue;
+                }
                 if (row.kind === 'raw') {
                     // Append-only trigger respected — archiveRawMemory is the only
                     // legitimate removal path for kind='raw', and its inner SAVEPOINT
@@ -102,12 +107,34 @@ export function rejectValue(opts) {
                 }
                 removedIds.push(row.id);
             }
-            // Dormant copies (src/dormant.ts) go too, in the same transaction: a
+            for (const row of merged) {
+                const successor = mergedSuccessor(row, holdsValue, new Set(removedIds));
+                deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
+                removedIds.push(row.id);
+                if (!successor)
+                    continue;
+                const kept = stampOriginProject(opts.hippoRoot, successor);
+                writeEntryDbOnly(db, kept, { actor: opts.actor });
+                successors.push(kept);
+            }
+            // Dormant copies (src/dormant.ts), whole or inside a merged row, go too, in the same transaction: a
             // rejected value may not linger where `hippo dormant restore` could
             // bring it back. They have no markdown mirror, so the post-commit
             // mirror purge below is a no-op for them; they join removedIds for the
             // audit trail and the caller's report.
             removedIds.push(...purgeDormantByDigest(db, opts.tenantId, digest));
+            for (const dormant of listDormantSnapshots(db, opts.tenantId)) {
+                const successor = mergedSuccessor(dormant.entry, holdsValue, new Set(removedIds));
+                if (successor === undefined)
+                    continue;
+                removedIds.push(dormant.entry.id);
+                if (!successor) {
+                    deleteDormantRow(db, opts.tenantId, dormant.entry.id);
+                    continue;
+                }
+                replaceDormantEntry(db, opts.tenantId, dormant.entry.id, successor);
+                dormantSuccessorIds.push(successor.id);
+            }
             try {
                 appendAuditEvent(db, {
                     tenantId: opts.tenantId,
@@ -149,7 +176,9 @@ export function rejectValue(opts) {
                 db.prepare(`UPDATE raw_archive SET mirror_cleaned_at = ? WHERE memory_id = ?`).run(new Date().toISOString(), id);
             }
         }
-        return { digest, content, removedIds, removedRawIds };
+        for (const successor of successors)
+            writeEntryMirrors(opts.hippoRoot, successor);
+        return { digest, content, removedIds, removedRawIds, successorIds: successors.map((s) => s.id), dormantSuccessorIds };
     }
     finally {
         closeHippoDb(db);

package/dist/salience.js

@@ -6,6 +6,7 @@
  * not everything that enters working memory deserves long-term storage.
  */
 import { textOverlap } from './search.js';
+import { duplicateKey, heldTextKeys } from './same-text.js';
 const DEFAULTS = {
     recentWindow: 20,
     overlapThreshold: 0.6,
@@ -37,11 +38,17 @@ export function computeSalience(content, tags, recentMemories, options = {}) {
             }
             return { decision: 'store', reason: 'error_despite_overlap', score: 0.7 };
         }
-        return {
-            decision: 'skip',
-            reason: `duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
-            score: 0.1,
-        };
+        // A near-duplicate may be a changed value (port 8080 then 8081), so only the same text is skipped.
+        const key = duplicateKey(trimmed);
+        const same = window.find((m) => heldTextKeys(m).includes(key));
+        if (!same) {
+            return {
+                decision: 'store',
+                reason: `near_duplicate (${(duplicateMatch.overlap * 100).toFixed(0)}% overlap with ${duplicateMatch.matchId})`,
+                score: 0.5,
+            };
+        }
+        return { decision: 'skip', reason: `duplicate (same text as ${same.id})`, score: 0.1 };
     }
     if (isError) {
         return { decision: 'store', reason: 'error_novel', score: 0.9 };

package/dist/same-text.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryEntry } from './memory.js';
+type Text = Pick<MemoryEntry, 'content'> & {
+    source?: string;
+    pinned?: boolean;
+};
+export declare function duplicateKey(text: string): string;
+/** A sleep-merged row's text: a header, a blank line, then each text as a "- " bullet with its later lines indented. */
+export declare function mergedText(header: string, texts: readonly string[]): string;
+/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+export declare function heldTexts(entry: Text): string[];
+/** Keys of every text a row holds word for word: its own, plus each source text inside a sleep-merged row. */
+export declare function heldTextKeys(entry: Text): string[];
+export declare function storedTextKeys(entries: readonly Text[]): Set<string>;
+/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+export declare function dropHeldCopies<T>(rows: readonly T[], textOf: (row: T) => Text): T[];
+export {};
+//# sourceMappingURL=same-text.d.ts.map

package/dist/same-text.js

@@ -0,0 +1,38 @@
+export function duplicateKey(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** A sleep-merged row's text: a header, a blank line, then each text as a "- " bullet with its later lines indented. */
+export function mergedText(header, texts) {
+    return `${header}\n\n${texts.map((t) => `- ${t.trim().replace(/\n/g, '\n  ')}`).join('\n')}`;
+}
+/** Each source text a sleep-merged row holds; a two-row merge by an older release kept one text whole after its header. */
+export function heldTexts(entry) {
+    const cut = entry.content.indexOf('\n\n');
+    if (entry.source !== 'consolidation' || cut < 0)
+        return [];
+    const body = entry.content.slice(cut + 2);
+    if (/^\[Consolidated from \d+ related memories\]$/.test(entry.content.slice(0, cut)))
+        return [body];
+    return `\n${body}`.split('\n- ').slice(1).map((t) => t.replace(/\n {2}/g, '\n'));
+}
+/** Keys of every text a row holds word for word: its own, plus each source text inside a sleep-merged row. */
+export function heldTextKeys(entry) {
+    return [duplicateKey(entry.content), ...heldTexts(entry).map(duplicateKey)];
+}
+export function storedTextKeys(entries) {
+    return new Set(entries.flatMap(heldTextKeys));
+}
+/** A final result list without copies: drops each unpinned row a sleep-merged row in the list holds word for word, and each later unpinned copy of a text. */
+export function dropHeldCopies(rows, textOf) {
+    const held = new Set(rows.flatMap((r) => heldTextKeys(textOf(r)).slice(1)));
+    const seen = new Set();
+    return rows.filter((r) => {
+        const keys = heldTextKeys(textOf(r));
+        const hidden = seen.has(keys[0]) || (keys.length === 1 && held.has(keys[0]));
+        if (hidden && !textOf(r).pinned)
+            return false; // rows merged by older releases can hold a pin's text
+        seen.add(keys[0]);
+        return true;
+    });
+}
+//# sourceMappingURL=same-text.js.map

package/dist/scheduler.d.ts

@@ -25,6 +25,10 @@ export declare function saveWorkspaceRegistry(globalRoot: string, registry: Work
 export declare function registerWorkspace(globalRoot: string, projectDir: string): WorkspaceRegistry;
 export declare function listRegisteredWorkspaces(globalRoot: string): string[];
 export declare function buildDailyRunnerCommand(projectDir: string, platform?: NodeJS.Platform): string;
+/** What the Windows task runs. A plain `cmd /c` task opens a visible console every morning. */
+export declare function buildWindowsTaskRun(cmd: string): string;
+/** Argv for `schtasks`, passed without a shell: through cmd.exe the `&&` in /tr split the command. */
+export declare function buildSchtasksCreateArgs(taskName: string, cmd: string): string[];
 export declare function runDailyMaintenance(workspaces: readonly string[], runCommand: (cwd: string, args: string[]) => void): void;
 export {};
 //# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.js

@@ -65,6 +65,14 @@ export function buildDailyRunnerCommand(projectDir, platform = process.platform)
     const resolved = path.posix.resolve(projectDir.replace(/\\/g, '/'));
     return `cd "${resolved}" && hippo daily-runner`;
 }
+/** What the Windows task runs. A plain `cmd /c` task opens a visible console every morning. */
+export function buildWindowsTaskRun(cmd) {
+    return `conhost.exe --headless cmd /c ${cmd}`;
+}
+/** Argv for `schtasks`, passed without a shell: through cmd.exe the `&&` in /tr split the command. */
+export function buildSchtasksCreateArgs(taskName, cmd) {
+    return ['/create', '/tn', taskName, '/tr', buildWindowsTaskRun(cmd), '/sc', 'daily', '/st', '06:15', '/f'];
+}
 export function runDailyMaintenance(workspaces, runCommand) {
     for (const workspace of workspaces) {
         const resolved = normalizeWorkspace(workspace);

package/dist/search.d.ts

@@ -84,6 +84,9 @@ export interface SearchResult {
         direction: 'from' | 'to';
     };
 }
+/** What a result costs against a budget: the tokens of the text it prints as. */
+export type ResultCost = (r: SearchResult) => number;
+export declare function fitBudget<T extends SearchResult>(ordered: T[], budget: number, minResults: number, cost?: ResultCost): T[];
 export interface ScoreBreakdown {
     /**
      * - `hybrid`: BM25 blended with a non-zero cosine from a cached doc vector.
@@ -186,6 +189,8 @@ export declare function hybridSearch(query: string, entries: MemoryEntry[], opti
     /** Minimum number of results to return regardless of budget.
      *  Prevents budget saturation when memories are large. Default 1. */
     minResults?: number;
+    /** Budget cost per result; the caller that prints passes the cost of its printed text. */
+    cost?: ResultCost;
     /** Active scope for scope-boost scoring. Auto-detected if not provided. */
     scope?: string | null;
     /** Include superseded memories in results. Default false. */
@@ -249,6 +254,7 @@ export declare function physicsSearch(query: string, entries: MemoryEntry[], opt
     queryEmbedding?: number[];
     explain?: boolean;
     minResults?: number;
+    cost?: ResultCost;
     /** Active scope for scope-boost scoring. Auto-detected if not provided. */
     scope?: string | null;
     /** Include superseded memories. Default false. Must be threaded through
@@ -277,6 +283,7 @@ export declare function search(query: string, entries: MemoryEntry[], options?:
     now?: Date;
     hippoRoot?: string;
     minResults?: number;
+    cost?: ResultCost;
     includeSuperseded?: boolean;
     asOf?: string;
 }): SearchResult[];

package/dist/search.js

@@ -138,6 +138,19 @@ export function temporalBoost(entry, direction, range) {
         return 0.8 + 0.4 * (1 - normalized);
     }
 }
+// Skip-and-continue, with the first minResults kept whatever they cost; one loop so every engine spends alike.
+export function fitBudget(ordered, budget, minResults, cost) {
+    const results = [];
+    let used = 0;
+    for (const r of ordered) {
+        const tokens = cost ? cost(r) : r.tokens;
+        if (results.length >= minResults && used + tokens > budget)
+            continue;
+        used += tokens;
+        results.push(r);
+    }
+    return results;
+}
 // ---------------------------------------------------------------------------
 // v0.30 / E4 — DAG L2 summary scoring helpers
 // ---------------------------------------------------------------------------
@@ -526,17 +539,7 @@ export async function hybridSearch(query, entries, options = {}) {
         const withPostRank = reranked.map((r, i) => ({ ...r, postRerankRank: i + 1 }));
         ordered = [...withPostRank, ...tail];
     }
-    // Apply token budget (guarantee at least minResults items)
-    const results = [];
-    let usedTokens = 0;
-    for (let i = 0; i < ordered.length; i++) {
-        const tokens = ordered[i].tokens;
-        if (results.length >= minResults && usedTokens + tokens > budget)
-            continue;
-        usedTokens += tokens;
-        results.push(ordered[i]);
-    }
-    return results;
+    return fitBudget(ordered, budget, minResults, options.cost);
 }
 /**
  * MMR (Maximal Marginal Relevance) re-ranking.
@@ -764,16 +767,7 @@ export async function physicsSearch(query, entries, options = {}) {
     const merged = mergeScorePools(physicsResults, classicResults);
     // Sort and apply budget, deterministic tiebreak on ties.
     merged.sort(compareScoredResults);
-    const results = [];
-    let usedTokens = 0;
-    for (let i = 0; i < merged.length; i++) {
-        const tokens = merged[i].tokens;
-        if (results.length >= minResults && usedTokens + tokens > budget)
-            continue;
-        usedTokens += tokens;
-        results.push(merged[i]);
-    }
-    return results;
+    return fitBudget(merged, budget, minResults, options.cost);
 }
 /** Normalize two score pools to [0,1] and combine. */
 function mergeScorePools(poolA, poolB) {
@@ -906,17 +900,7 @@ export function search(query, entries, options = {}) {
         }
         dedupedSync.sort(compareScoredResults);
     }
-    // Apply token budget
-    const results = [];
-    let usedTokens = 0;
-    for (let i = 0; i < dedupedSync.length; i++) {
-        const tokens = dedupedSync[i].tokens;
-        if (results.length >= minResults && usedTokens + tokens > budget)
-            continue;
-        usedTokens += tokens;
-        results.push(dedupedSync[i]);
-    }
-    return results;
+    return fitBudget(dedupedSync, budget, minResults, options.cost);
 }
 /**
  * Update retrieval metadata on entries that were returned by a search.

package/dist/secret-detect.d.ts

@@ -38,6 +38,8 @@ export declare function detectSecret(entry: {
  * CS1 pre-compact snapshot fields — can scrub it in place instead.
  */
 export declare function redactSecrets(text: string): string;
+/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+export declare function maskEmails(text: string): string;
 /** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
 export declare function redactSecretsStrict(text: string): string;
 //# sourceMappingURL=secret-detect.d.ts.map

package/dist/secret-detect.js

@@ -90,6 +90,12 @@ export function detectSecret(entry) {
 export function redactSecrets(text) {
     return redactText(text, false);
 }
+/** A domain's first label must open on a letter, so asset names like logo@2x.png and pins like react@18.2.0 stay. */
+const EMAIL = /\b[A-Za-z0-9._%+-]+@[A-Za-z][A-Za-z0-9-]*(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}\b/g;
+/** Memories never hold a raw email address (AGENTS.md); phone numbers are left alone, as their patterns misfire on ids. */
+export function maskEmails(text) {
+    return text.replace(EMAIL, '[email]');
+}
 /** Stricter redaction for text that leaves the machine: no co-occurrence guard, plus Bearer and Basic auth headers and JWTs. */
 export function redactSecretsStrict(text) {
     return redactText(text, true);