hippo-memory 1.69.0 → 1.71.0

package/dist/memory-value.js

@@ -1,250 +0,0 @@
-/**
- * Learned memory-value scorer, wired into the sleep decay pass as a
- * rescue-only veto.
- *
- * computeMvFeatures mirrors benchmarks/memory-value/extract.mjs's
- * computeFeatures for the 8 live dims the fitter optimized over
- * (FIT_DIMS) — the only dims MEMORY_VALUE_WEIGHTS carries a weight for.
- * Any future edit to either side must keep them byte-equivalent; the parity
- * test in tests/memory-value-wiring.test.ts enforces this.
- *
- * scoreEntries mirrors benchmarks/memory-value/evaluate.mjs's per-store
- * min-max normalization + weighted scorer (no additional orientation
- * multiply — the frozen weights already encode sign/orientation).
- *
- * rescueSet implements rescue-only semantics: a condemned entry is
- * rescued iff its learned score ranks in the top 30% (RESCUE_BUDGET, the
- * measured keep-budget operating point) of its own tenant's non-pinned
- * candidate set. Deletes(flag-on) subset Deletes(flag-off) by construction — this
- * function can only ever shrink the condemned set, never grow it.
- */
-import { calculateStrength } from './memory.js';
-import { compareEntryIdentity } from './compare.js';
-import { MEMORY_VALUE_WEIGHTS, SOURCE_ARTIFACT_SHA256 } from './memory-value-weights.js';
-/** The 8 live feature dims (FIT_DIMS) — canonical order for iteration. */
-export const MV_FEATURE_NAMES = [
-    'age_days',
-    'half_life_days',
-    'strength',
-    'retrieval_count',
-    'outcome_positive',
-    'outcome_negative',
-    'outcome_ratio',
-    'content_length',
-];
-/** The keep-budget operating point (the only point with measured
- *  evidence): a code constant tied to that evidence, not user-tunable. */
-const RESCUE_BUDGET = 0.3;
-/**
- * Small-tenant degeneracy: below this per-tenant non-pinned candidate-set
- * size, a rank statistic is noise (the measured evidence says nothing about
- * tiny scale), and the floor prevents immortal-entry
- * convergence: keepN=ceil(0.3*N) guarantees >=1 rescue at N=1, so without a
- * floor a condemned-only 1-entry tenant would be rescued every single sleep
- * forever. A condemned-only tenant below the floor instead drains normally
- * as entries are deleted: the surviving rescued subset only ever shrinks
- * toward 0, never regrows past 10 to regain eligibility on its own. Code
- * constant tied to that reasoning, not user-tunable (same posture as
- * RESCUE_BUDGET).
- */
-const MIN_RESCUE_GROUP = 10;
-/**
- * Blind v1 feature dict for one MemoryEntry, restricted to the 8 dims the
- * frozen weights carry (mirrors extract.mjs's computeFeatures).
- *
- * CRITICAL: `strength` is CLOCK-BASIS `calculateStrength(entry, now)` with
- * NO DecayOptions — that is how the frozen weights' training features were
- * computed (extract.mjs never passes decayOpts). Passing the production
- * decay basis (config.decayBasis via consolidate.ts's decayOpts) into this
- * feature would silently break parity with the frozen weight vector. This
- * is an intentional divergence from the condemnation TRIGGER in
- * consolidate.ts, which keeps using decayOpts as today — only the rescue
- * FEATURE is clock-basis.
- */
-export function computeMvFeatures(entry, now) {
-    const ageDays = (now.getTime() - Date.parse(entry.created)) / (1000 * 60 * 60 * 24);
-    const pos = entry.outcome_positive ?? 0;
-    const neg = entry.outcome_negative ?? 0;
-    return {
-        age_days: ageDays,
-        half_life_days: entry.half_life_days,
-        strength: calculateStrength(entry, now), // clock-basis, never decayOpts — see doc comment above
-        retrieval_count: entry.retrieval_count,
-        outcome_positive: pos,
-        outcome_negative: neg,
-        outcome_ratio: (pos - neg) / (pos + neg + 1), // same formula as extract.mjs / calculateRewardFactor's ratio term
-        content_length: entry.content.length,
-    };
-}
-/**
- * Throws if the weight constant is malformed: fewer/extra dims, a
- * non-finite weight value, or a missing source digest. Flag-on + a broken
- * constant must THROW, never silently behave as flag-off.
- *
- * Parameterized (defaults to the real frozen singleton) so the throw
- * conditions are directly unit-testable without mutating the frozen
- * MEMORY_VALUE_WEIGHTS export — mirrors fit.mjs's verifyFrozenWeights
- * (see tests/memory-value-fit.test.ts's `describe('verifyFrozenWeights')`).
- */
-function isFiniteWeightValue(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}
-function isNonEmptyDigestString(value) {
-    return typeof value === 'string' && value.length > 0;
-}
-export function validateWeights(weights = MEMORY_VALUE_WEIGHTS, digest = SOURCE_ARTIFACT_SHA256) {
-    for (const key of MV_FEATURE_NAMES) {
-        const v = weights[key];
-        if (!isFiniteWeightValue(v)) {
-            throw new Error(`memory-value: weights constant is malformed — "${key}" is not a finite number ` +
-                `(src/memory-value-weights.ts)`);
-        }
-    }
-    if (!isNonEmptyDigestString(digest)) {
-        throw new Error('memory-value: weights constant is malformed — SOURCE_ARTIFACT_SHA256 digest missing (src/memory-value-weights.ts)');
-    }
-}
-/**
- * Min-max normalize each of the 8 features over the given entry set
- * (constant feature -> 0, matching evaluate.mjs), then score = dot(weights,
- * normalized). The normalization context is exactly the entries passed in —
- * callers control the bounded scope (per-tenant, non-pinned).
- *
- * `weights` defaults to the real frozen singleton; parameterized (like
- * validateWeights) so callers/tests can score against an explicit vector
- * without touching the module singleton.
- *
- * Non-finite features: Date.parse on a malformed `created`
- * string yields NaN, and NaN would silently corrupt every OTHER entry's
- * min-max in the same group. An entry with ANY non-finite computed feature
- * is excluded from the normalization context entirely (its raw values never
- * touch min/max) and always scores -Infinity — the lowest possible score, so
- * it sorts to the bottom of its tenant deterministically and (via rescueSet's
- * explicit finite-score guard below) can never be rescued. Conservative
- * direction: deletes(flag-on) subset deletes(flag-off) still holds.
- */
-export function scoreEntries(entries, now, weights = MEMORY_VALUE_WEIGHTS) {
-    const raw = new Map();
-    for (const e of entries)
-        raw.set(e.id, computeMvFeatures(e, now));
-    const nonFiniteIds = new Set();
-    for (const e of entries) {
-        const nf = raw.get(e.id);
-        if (MV_FEATURE_NAMES.some((f) => !Number.isFinite(nf[f])))
-            nonFiniteIds.add(e.id);
-    }
-    const normContextEntries = entries.filter((e) => !nonFiniteIds.has(e.id));
-    const minMax = new Map();
-    for (const f of MV_FEATURE_NAMES) {
-        let min = Infinity;
-        let max = -Infinity;
-        for (const e of normContextEntries) {
-            const v = raw.get(e.id)[f];
-            if (v < min)
-                min = v;
-            if (v > max)
-                max = v;
-        }
-        minMax.set(f, { min, max });
-    }
-    const norm = (f, v) => {
-        const { min, max } = minMax.get(f);
-        return max === min ? 0 : (v - min) / (max - min);
-    };
-    const scores = new Map();
-    for (const e of entries) {
-        if (nonFiniteIds.has(e.id)) {
-            scores.set(e.id, -Infinity);
-            continue;
-        }
-        const nf = raw.get(e.id);
-        let sum = 0;
-        for (const f of MV_FEATURE_NAMES)
-            sum += weights[f] * norm(f, nf[f]);
-        scores.set(e.id, sum);
-    }
-    return scores;
-}
-/**
- * Groups non-pinned entries by tenantId, scores + ranks each tenant's
- * group independently, and returns per-entry rank context for every
- * non-pinned entry (not just condemned ones) — the shared basis for both
- * rescueSet's rescue decision and consolidate.ts's audit-row rank context,
- * so the two never compute the ranking differently.
- *
- * `weights`/`digest` default to the real frozen singleton — parameterized
- * (like validateWeights/scoreEntries) purely for direct unit-testability of
- * the fail-loud path, never overridden by production callers.
- */
-export function rankNonPinnedByTenant(entries, now, weights = MEMORY_VALUE_WEIGHTS, digest = SOURCE_ARTIFACT_SHA256) {
-    validateWeights(weights, digest);
-    const byTenant = new Map();
-    for (const e of entries) {
-        if (e.pinned)
-            continue; // pinned entries never compete for rescue (never condemned)
-        // Default an undefined tenantId as dag.ts:341 does: a raw/legacy row can carry one at runtime,
-        // and keying it "undefined" would split it into its own singleton tenant.
-        const tenantId = e.tenantId ?? 'default';
-        const list = byTenant.get(tenantId);
-        if (list)
-            list.push(e);
-        else
-            byTenant.set(tenantId, [e]);
-    }
-    const result = new Map();
-    for (const [tenantId, group] of byTenant) {
-        const scores = scoreEntries(group, now, weights);
-        // score DESC, then compareEntryIdentity, the shared tie-break of every score-primary sort (src/compare.ts).
-        // `-Infinity - -Infinity` is NaN, which Array.sort leaves insertion-order-dependent, so NaN ties too.
-        const sorted = [...group].sort((a, b) => {
-            const diff = scores.get(b.id) - scores.get(a.id);
-            return diff === 0 || Number.isNaN(diff) ? compareEntryIdentity(a, b) : diff;
-        });
-        // Tenants smaller than MIN_RESCUE_GROUP never rescue (keepN 0); see that constant's doc comment.
-        const keepN = sorted.length < MIN_RESCUE_GROUP
-            ? 0
-            : Math.min(sorted.length, Math.ceil(RESCUE_BUDGET * sorted.length));
-        sorted.forEach((e, i) => {
-            result.set(e.id, {
-                tenantId,
-                score: scores.get(e.id),
-                rank: i + 1,
-                totalNonPinned: sorted.length,
-                keepN,
-            });
-        });
-    }
-    return result;
-}
-/**
- * Rescue decision: a condemned entry is rescued iff it ranks in the top
- * 30% of its tenant's non-pinned candidate set by learned score. Returns the
- * subset of condemnedIds that are rescued — the caller filters commits
- * (rescued -> survivors) and threads the same set into detectConflicts.
- *
- * `weights`/`digest` default to the real frozen singleton; production
- * callers (consolidate.ts) never pass overrides — the params exist purely so
- * "flag on + a broken constant throws" is directly testable end-to-end
- * through this function without mutating the frozen module singleton.
- *
- * `precomputedRanks`: when the caller has already
- * computed the per-tenant ranking (e.g. consolidate.ts needs it separately
- * for detail/audit rank context), pass it here to skip the internal
- * rankNonPinnedByTenant call — the whole-store ranking pass then runs
- * exactly once per sleep instead of twice. Omitted (the default), rescueSet
- * computes it internally as before — existing callers/tests are unaffected.
- */
-export function rescueSet(entries, condemnedIds, now, weights = MEMORY_VALUE_WEIGHTS, digest = SOURCE_ARTIFACT_SHA256, precomputedRanks) {
-    validateWeights(weights, digest); // fail loud before any rescue computation
-    const ranked = precomputedRanks ?? rankNonPinnedByTenant(entries, now, weights, digest);
-    const rescued = new Set();
-    for (const id of condemnedIds) {
-        const info = ranked.get(id);
-        // An explicit finite guard, not just -Infinity sorting last: when a whole tenant
-        // ties at -Infinity, rank alone could place one inside keepN.
-        if (info && info.rank <= info.keepN && Number.isFinite(info.score))
-            rescued.add(id);
-    }
-    return rescued;
-}
-//# sourceMappingURL=memory-value.js.map

package/dist/memory.d.ts

@@ -1,294 +0,0 @@
-/**
- * Core data model for Hippo memory entries.
- * Based on the strength formula from PLAN.md.
- */
-export declare enum Layer {
-    Buffer = "buffer",
-    Episodic = "episodic",
-    Semantic = "semantic",
-    Trace = "trace"
-}
-export type EmotionalValence = 'neutral' | 'positive' | 'negative' | 'critical';
-export type ConfidenceLevel = 'verified' | 'observed' | 'inferred' | 'stale';
-export type TraceOutcome = 'success' | 'failure' | 'partial' | null;
-export type MemoryKind = 'raw' | 'distilled' | 'superseded' | 'archived';
-/**
- * Timestamp invariant.
- *
- * All in-process writes of timestamp fields on `MemoryEntry` (`created`,
- * `last_retrieved`, `valid_from`) and on session-state types (SessionEvent,
- * TaskSnapshot, SessionHandoff, AssembledContextItem.createdAt, etc.) emit
- * canonical `Date.prototype.toISOString()` output: 24 characters, UTC,
- * milliseconds precision, trailing `Z` (e.g. `2026-05-06T09:55:49.123Z`).
- *
- * Caveat — markdown rebuild. `deserializeEntry` / `rebuildIndex` preserve
- * frontmatter timestamp strings as-is. Legacy markdown that recorded a
- * non-canonical offset (e.g. `2026-05-06T05:55:49-04:00`) round-trips
- * through SQLite without normalization, and DAG `earliest_at` / `latest_at`
- * caches are computed from those strings. Importers SHOULD normalize on
- * write; rebuild from drifted markdown is a known limitation.
- *
- * Byte-comparison sort (`<` / `>`) is chronological for any pair of
- * canonical UTC ISO strings. ~50× faster than `localeCompare` with no
- * semantic gain. `assemble` sorts by byte compare; if a future
- * import path admits non-canonical timestamps, that sort and any
- * downstream chronological reasoning will need a normalization pass.
- */
-export interface MemoryEntry {
-    id: string;
-    created: string;
-    last_retrieved: string;
-    retrieval_count: number;
-    strength: number;
-    half_life_days: number;
-    layer: Layer;
-    tags: string[];
-    emotional_valence: EmotionalValence;
-    schema_fit: number;
-    source: string;
-    outcome_score: number | null;
-    outcome_positive: number;
-    outcome_negative: number;
-    conflicts_with: string[];
-    pinned: boolean;
-    confidence: ConfidenceLevel;
-    content: string;
-    parents: string[];
-    starred: boolean;
-    trace_outcome: TraceOutcome;
-    source_session_id: string | null;
-    valid_from: string;
-    superseded_by: string | null;
-    extracted_from: string | null;
-    dag_level: number;
-    dag_parent_id: string | null;
-    descendant_count?: number;
-    earliest_at?: string | null;
-    latest_at?: string | null;
-    /** 1 when this summary row has at least one child invalidated,
-     *  superseded, forgotten, or archived since it was last rebuilt. Cleared
-     *  by rebuildDirtySummaries during sleep. Always 0 for non-summary
-     *  rows (dag_level !== 2). */
-    summary_dirty?: 0 | 1;
-    /** ISO 8601 timestamp of the last successful rebuild for this
-     *  summary, or null if never rebuilt. */
-    last_rebuilt_at?: string | null;
-    /** Monotonically-increasing counter of successful rebuilds for this
-     *  summary. 0 for initial buildDag write; bumped by each rebuild. */
-    rebuild_count?: number;
-    /** Reserved: ISO 8601 timestamp the level-3 entity profile
-     *  was built. Only ever populated on dag_level=3 rows. */
-    dag_level_3_built_at?: string | null;
-    kind: MemoryKind;
-    scope: string | null;
-    owner: string | null;
-    artifact_ref: string | null;
-    tenantId: string;
-    /**
-     * Memory scope isolation: owning project for ambient-context
-     * partitioning. A lowercased project name, '' for user-global (injectable
-     * everywhere), or null for no known project (a legacy row, or a shared-store
-     * write that named none) - ambient context treats null as other-project (deny).
-     * Stamped at write time by store/entry-row.ts stampOriginProject via fallbackOrigin;
-     * undefined only on entries not yet written.
-     */
-    origin_project?: string | null;
-    /**
-     * Raw SQLite FTS5 bm25() score from the FTS path of
-     * `loadSearchEntries`.
-     *
-     * Populated ONLY when ALL of the following hold:
-     *   - `loadSearchEntries` was called with a non-empty query, AND
-     *   - FTS5 is available (meta `fts5_available = 1`), AND
-     *   - the FTS join returned at least one row (path 2 of `loadSearchRows`).
-     *
-     * `undefined` on every other path: empty query, FTS unavailable, LIKE
-     * fallback, full-store fallback, `readEntry`, `loadAllEntries`, manual
-     * upsert, deserializeEntry from markdown.
-     *
-     * SCALE: FTS5 bm25() is negative; lower = better match (ascending order).
-     * NOT a drop-in for the JS-side BM25 in `src/search.ts` — that is a
-     * different scorer (different tokenizer, different params, positive
-     * scale). Treat `bm25_score` as provenance/rank metadata only.
-     */
-    bm25_score?: number;
-}
-/** Tag on a memory whose named file/symbol/script changed after it was stored. */
-export declare const CHURN_STALE_TAG = "churn-stale";
-/**
- * Test-only helper. Tests that mutate `process.env.HIPPO_LOSS_AVERSION_RATIO`
- * MUST call this in BOTH `beforeEach` AND `afterEach`:
- *   - beforeEach: clear any stale cache from a previous test before setting
- *     the env var for this test.
- *   - afterEach: clear the cache so the next test (which may not set the env
- *     var) reads the clean default instead of this test's value.
- * See `tests/emotional-multipliers-j5.test.ts` for the canonical pattern.
- */
-export declare function _resetLossAversionRatioCacheForTests(): void;
-/**
- * Compute the reward factor from cumulative outcome counts.
- *
- *   reward_ratio  = (positive - negative) / (positive + negative + 1)
- *   reward_factor = 1 + 0.5 * reward_ratio
- *
- * Range: (0.5, 1.5). Neutral (no outcomes) returns 1.0.
- * Modulates effective half-life: memories with consistent positive outcomes
- * decay slower; consistent negative outcomes decay faster.
- */
-export declare function calculateRewardFactor(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
-/**
- * Net wrongness: bad outcome marks past good ones, never below zero.
- * Strength halves per unit (capped at 3) and recall stops strengthening
- * the memory, so a correction outranks pinning, error tags and heavy recall.
- */
-export declare function netWrong(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>): number;
-/**
- * Options for decay basis.
- * - clock: wall-clock time (former default)
- * - session: decay by sleep cycle count (for intermittent agents)
- * - adaptive: auto-scale half-life by session frequency (default)
- */
-/** What calculateStrength reads, so a caller can score a row without loading its text. */
-export type StrengthInputs = Pick<MemoryEntry, 'pinned' | 'created' | 'last_retrieved' | 'half_life_days' | 'retrieval_count' | 'emotional_valence' | 'outcome_positive' | 'outcome_negative'>;
-export interface DecayOptions {
-    decayBasis?: 'clock' | 'session' | 'adaptive';
-    /** Average interval between sleep cycles, in days. Used by 'adaptive' and 'session' modes. */
-    avgSessionIntervalDays?: number;
-    /** Total sleep cycles completed. Used by consolidation tracking. */
-    sleepCount?: number;
-}
-/**
- * Calculate current strength at a given time.
- * strength(t) = base_strength * decay * retrieval_boost * emotional_multiplier
- *
- * Decay basis modes:
- * - clock: classic wall-clock decay (daysSince / halfLife)
- * - session: decay by sleep cycles instead of days (sessionsSince / halfLife)
- * - adaptive: wall-clock decay with half-life scaled by session frequency
- *
- * Pinned memories skip time decay; being marked wrong still fades them (netWrong).
- */
-export declare function calculateStrength(entry: StrengthInputs, now?: Date, options?: DecayOptions): number;
-/** calculateStrength's clock-basis formula as SQL over `memories` columns, flags and multipliers baked in; keep in step.
- *  An unparseable date scores NULL here and 0 in JS, so sums agree. */
-export declare function strengthSql(now: Date): string;
-/**
- * Derive half-life based on signals, as per PLAN.md table.
- */
-export declare function deriveHalfLife(base: number, entry: Partial<MemoryEntry>): number;
-/**
- * Apply outcome feedback to a memory entry.
- *
- * Increments outcome_positive or outcome_negative counters.
- * The reward factor in calculateStrength() uses these counts to
- * continuously modulate the effective half-life:
- *   reward_ratio  = (pos - neg) / (pos + neg + 1)
- *   reward_factor = 1 + 0.5 * reward_ratio    // range (0.5, 1.5)
- *   effective_hl  = half_life_days * reward_factor
- *
- * No fixed half-life delta. Decay rate adjusts proportionally to
- * cumulative reward signal, inspired by R-STDP in spiking networks.
- */
-export declare function applyOutcome(entry: MemoryEntry, good: boolean): MemoryEntry;
-/** applyOutcome as a served outcome applies it: a good outcome reconfirms the entry, so its churn-stale tag goes. */
-export declare function entryAfterOutcome(entry: MemoryEntry, good: boolean): MemoryEntry;
-/**
- * Generate a random memory ID using crypto.randomUUID().
- */
-export declare function generateId(prefix?: string): string;
-export interface ConfidenceFacets {
-    tier: ConfidenceLevel;
-    agedOut: boolean;
-}
-export declare function confidenceFacets(entry: MemoryEntry, now?: Date): ConfidenceFacets;
-export declare function confidenceLabel(entry: MemoryEntry, now?: Date): {
-    text: string;
-    warn: boolean;
-};
-/**
- * Resolve the effective confidence for a memory entry.
- * If the entry has not been retrieved in 30+ days and is not 'verified',
- * returns 'stale'. Otherwise returns the stored confidence value.
- */
-export declare function resolveConfidence(entry: MemoryEntry, now?: Date): ConfidenceLevel;
-/**
- * Base half-life for a new memory, in days, before `deriveHalfLife`'s
- * write-time multipliers. 365 because 7 days lost the current fact far more
- * often, and 730 days or no decay did no better. `hippo sleep` moves memories still
- * on an older base (src/half-life-migration.ts).
- */
-export declare const DEFAULT_HALF_LIFE_DAYS = 365;
-export declare const COMPACTION_MEMORY_TAG = "compaction-memory";
-export declare const COMPACTION_SOURCE_PREFIX = "compaction:";
-/** An imported agent memory (its tool's tag, and a source starting that tool's prefix) is kept for good: the agent's note file is its record. Both, since merge copies source tags onto rows whose source is 'consolidation'. */
-export interface KeepPair {
-    readonly tag: string;
-    readonly sourcePrefix: string;
-}
-export declare const KEEP_PAIRS: readonly KeepPair[];
-export declare const AUTO_DELETABLE_SQL: string;
-export declare function isKeptForGood(entry: Pick<MemoryEntry, 'tags' | 'source' | 'superseded_by'>): boolean;
-export declare function canAutoDelete(entry: Pick<MemoryEntry, 'pinned' | 'kind' | 'tags' | 'source' | 'superseded_by'>): boolean;
-export interface CreateMemoryOptions {
-    layer?: Layer;
-    tags?: string[];
-    emotional_valence?: EmotionalValence;
-    pinned?: boolean;
-    schema_fit?: number;
-    source?: string;
-    confidence?: ConfidenceLevel;
-    /** The store's `loadConfig(hippoRoot).defaultHalfLifeDays`; required so no writer falls back to the compiled default by leaving it out. */
-    baseHalfLifeDays: number;
-    trace_outcome?: TraceOutcome;
-    source_session_id?: string | null;
-    valid_from?: string;
-    extracted_from?: string;
-    dag_level?: number;
-    dag_parent_id?: string;
-    kind?: MemoryKind;
-    scope?: string | null;
-    owner?: string | null;
-    artifact_ref?: string | null;
-    tenantId?: string;
-}
-/** Create a new memory entry with defaults. Untyped JavaScript callers that omit the options get the compiled default half-life. */
-export declare function createMemory(content: string, options: CreateMemoryOptions): MemoryEntry;
-/** The row that replaces `old`: a supersede never changes where a memory belongs, so source, scope, session and a stamped origin carry over. */
-export declare function createSuccessor(old: MemoryEntry, content: string, opts: {
-    tenantId: string;
-    baseHalfLifeDays: number;
-    layer?: Layer;
-    tags?: string[];
-    pinned?: boolean;
-}): MemoryEntry;
-/**
- * Compute how well new content fits existing knowledge patterns.
- * Returns 0..1 where:
- *   >0.7 = high fit (consistent with existing knowledge, consolidates faster)
- *   0.3-0.7 = moderate fit
- *   <0.3 = novel (doesn't match existing patterns, decays faster if unused)
- *
- * Uses tag overlap (always available) weighted by how common each tag is.
- * Rare shared tags signal stronger schema fit than common ones.
- */
-export declare function computeSchemaFit(content: string, tags: string[], existingEntries: MemoryEntry[]): number;
-/**
- * Update retrieval metadata on entries that were returned by a search.
- * Returns the mutated copies (caller must persist to disk).
- *
- * EVAL-ONLY ablation (see ablation.ts): with HIPPO_ABLATE_RECALL_BOOST set,
- * this returns the entries UNMUTATED - neutralizing all three strengthening
- * sub-effects (clock reset, retrieval_count, half-life increment) at the
- * single shared write site. The entries (not an empty array) must be
- * returned because callers derive `last_retrieval_ids` from the return
- * value, and a later `hippo outcome --good/--bad` targets those ids - an
- * empty return would silently co-ablate the outcome channel in the
- * strengthen-off arm. PERSISTENCE is gated separately at
- * each persisting caller (CLI recall, api context, MCP recall/context,
- * consolidation replay): writeEntry on identical rows still refreshes
- * updated_at, rewrites mirrors, and marks DAG parents dirty,
- * so those write loops skip under the flag.
- * The default `now` honors HIPPO_FAKE_NOW (simulated-time protocols).
- */
-export declare function markRetrieved(entries: MemoryEntry[], now?: Date): MemoryEntry[];
-//# sourceMappingURL=memory.d.ts.map