hippo-memory 1.69.0 → 1.71.0

package/dist/refine-llm.js

@@ -1,167 +0,0 @@
-/**
- * LLM-powered refinement of consolidated semantic memories.
- *
- * The rule-based `mergeContents` in consolidate.ts produces functional but
- * ugly semantic memories — typically "[Consolidated from N related memories]"
- * prepended to the longest source, or a bulleted list. `hippo refine` takes
- * those and asks Claude to synthesize a clean, generalized principle.
- *
- * Design choices:
- * - Separate command (not baked into `hippo sleep`) so API-key users opt in.
- * - Idempotent via the `llm-refined` tag — re-running skips already-refined.
- * - Uses fetch directly so no SDK dependency.
- * - On failure (API error, bad response), the original memory is untouched.
- */
-import { Layer } from './memory.js';
-import { writeEntry } from './store/entry-writes.js';
-import { loadAllEntries, readEntry } from './store/entry-reads.js';
-import { redactSecretsStrict } from './secret-detect.js';
-import { fetchWithRetry, llmTimeoutMs } from './http-retry.js';
-import { log } from './log.js';
-const REFINED_TAG = 'llm-refined';
-const CONSOLIDATED_MARKERS = [
-    '[Consolidated from',
-    '[Consolidated pattern from',
-];
-/**
- * Ask Claude to synthesize a clean semantic memory from the merged content
- * plus the original source memories. Returns the refined content string or
- * `null` when the API call failed.
- */
-export async function refineSemanticMemory(merged, sources, opts) {
-    const model = opts.model ?? 'claude-sonnet-4-6';
-    const fetchFn = opts.fetcher ?? fetch;
-    const sourceBlock = sources
-        .slice(0, 8)
-        .map((s, i) => `[source ${i + 1}] ${redactSecretsStrict(s.content).slice(0, 400)}`)
-        .join('\n\n');
-    const prompt = `You are refining a semantic memory in an agent's memory store. The rule-based consolidator merged several related episodic memories into one, but the output is clumsy. Produce a single coherent semantic memory that captures the underlying principle.
-
-Rules:
-- Output ONLY the refined content — no preamble, no quote marks, no "Here is...".
-- Keep it concise: one paragraph, no headers, no bullet lists unless the sources are inherently a list.
-- Preserve specific facts (names, numbers, paths, IDs) from the sources.
-- Generalize: state the pattern, not each instance.
-- Do NOT include the "[Consolidated from N ...]" marker.
-
-Current merged content:
-${redactSecretsStrict(merged)}
-
-Source memories (up to 8 shown):
-${sourceBlock}`;
-    let res;
-    try {
-        res = await fetchWithRetry('https://api.anthropic.com/v1/messages', {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                'x-api-key': opts.apiKey,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: 800,
-                messages: [{ role: 'user', content: prompt }],
-            }),
-        }, { timeoutMs: llmTimeoutMs(), fetchFn });
-    }
-    catch (err) {
-        log.warn(`refine: request failed: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-    if (!res.ok) {
-        log.warn(`refine: API answered HTTP ${res.status}`);
-        return null;
-    }
-    let text;
-    try {
-        // SAFETY: data is the Anthropic Messages API response body; the
-        // documented response shape is `{ content: [{ type, text, ... }] }`
-        // for a text-generating request like this one.
-        const data = await res.json();
-        text = data.content?.[0]?.text?.trim() ?? '';
-    }
-    catch (err) {
-        log.warn(`refine: unreadable response: ${err instanceof Error ? err.message : String(err)}`);
-        return null;
-    }
-    if (text.length < 10) {
-        log.warn('refine: response was empty or too short to use');
-        return null;
-    }
-    return text;
-}
-function isConsolidated(entry) {
-    if (entry.layer !== Layer.Semantic)
-        return false;
-    return CONSOLIDATED_MARKERS.some((m) => entry.content.startsWith(m));
-}
-/**
- * Scan the store for consolidated semantic memories, refine each with the
- * LLM, and write the refined content back. Tags with `llm-refined` so
- * repeated runs are idempotent (unless `all` is set).
- */
-export async function refineStore(hippoRoot, opts) {
-    const result = {
-        scanned: 0,
-        refined: 0,
-        skipped: 0,
-        failed: 0,
-        details: [],
-    };
-    // When opts.tenantId is provided, scope the top-level scan to this
-    // tenant's consolidated entries.
-    const entries = loadAllEntries(hippoRoot, opts.tenantId);
-    let processed = 0;
-    for (const entry of entries) {
-        if (!isConsolidated(entry))
-            continue;
-        result.scanned++;
-        if (!opts.all && entry.tags.includes(REFINED_TAG)) {
-            result.skipped++;
-            result.details.push({ id: entry.id, status: 'skipped', reason: 'already refined' });
-            continue;
-        }
-        if (opts.limit !== undefined && processed >= opts.limit)
-            break;
-        processed++;
-        // Best-effort: walk parents_json (schema v9) to fetch originals. When
-        // parents aren't recorded we still refine using just the merged content.
-        const sources = [];
-        const parentIds = Array.isArray(entry.parents) ? entry.parents : [];
-        for (const pid of parentIds) {
-            // Parent lookup scoped by opts.tenantId when provided.
-            // Cross-tenant parents return null and are silently skipped — refine
-            // still produces output from the merged content alone (graceful
-            // degradation rather than refuse-to-refine).
-            const p = readEntry(hippoRoot, pid, opts.tenantId);
-            if (p)
-                sources.push(p);
-        }
-        const refined = await refineSemanticMemory(entry.content, sources, {
-            apiKey: opts.apiKey,
-            model: opts.model,
-            fetcher: opts.fetcher,
-        });
-        if (refined === null) {
-            result.failed++;
-            result.details.push({ id: entry.id, status: 'failed', reason: 'api error or empty response' });
-            continue;
-        }
-        if (opts.dryRun) {
-            result.refined++;
-            result.details.push({ id: entry.id, status: 'refined', reason: 'dry-run (no write)' });
-            continue;
-        }
-        const updated = {
-            ...entry,
-            content: refined,
-            tags: entry.tags.includes(REFINED_TAG) ? entry.tags : [...entry.tags, REFINED_TAG],
-        };
-        writeEntry(hippoRoot, updated);
-        result.refined++;
-        result.details.push({ id: entry.id, status: 'refined' });
-    }
-    return result;
-}
-//# sourceMappingURL=refine-llm.js.map

package/dist/reject-flow.d.ts

@@ -1,69 +0,0 @@
-/**
- * Rejected-value tombstone: shared reject/unreject/list flow.
- *
- * The CLI (`hippo reject`/`rejections`/`unreject`) and the Context-based
- * `api.reject`/`api.unreject`/`api.listRejections` surfaces both need the
- * 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,
- * 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';
-export interface RejectFlowOpts {
-    hippoRoot: string;
-    tenantId: string;
-    actor: string;
-    reason: string;
-    /** By-id form: reject the CURRENT content of an existing memory. */
-    memoryId?: string;
-    /** Pre-emptive form: reject a value not currently stored (or already gone). */
-    value?: string;
-    /** The caller's own personal scope: the only personal rows the sweep may remove. Unset (the CLI) skips every personal row. */
-    ownScope?: string;
-}
-export interface RejectFlowResult {
-    digest: string;
-    /** The rejected content, for the CLI's at-reject-time echo (the
-     *  tombstone itself stores no content — this is the only place it's seen
-     *  again after this call returns). */
-    content: string;
-    /** Every row removed this call, live or dormant: all whose normalized digest matched (not just the id
-     *  passed, since duplicates share a digest), 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:
- * insert the tombstone, enumerate + remove every live tenant row whose
- * normalized digest matches (kind-aware), one aggregate `reject_value`
- * audit, COMMIT. Then post-commit (mirrors the existing purge+reaper
- * pattern verbatim from api.archiveRaw, api.ts:1913-1938): best-effort
- * mirror purge per removed id, `mirror_cleaned_at` stamps for raw ids.
- * index.json itself is only refreshed by `rebuildIndex()`.
- */
-export declare function rejectValue(opts: RejectFlowOpts): RejectFlowResult;
-export type UnrejectOutcome = {
-    status: 'ok';
-    digest: string;
-    reason: string | null;
-} | {
-    status: 'not_found';
-} | {
-    status: 'ambiguous';
-    candidates: RejectedValueRow[];
-};
-/**
- * `hippo unreject` / `api.unreject` — resolve a unique tombstone by digest
- * (or prefix), delete it, audit `unreject_value`. The only v1 escape hatch
- * (plan §4): no per-write force flag.
- */
-export declare function unrejectValue(hippoRoot: string, tenantId: string, digestOrPrefix: string, actor: string): UnrejectOutcome;
-/** `hippo rejections` / `api.listRejections` — list tombstones for a tenant. */
-export declare function listRejectionsForTenant(hippoRoot: string, tenantId: string): RejectedValueRow[];
-//# sourceMappingURL=reject-flow.d.ts.map

package/dist/reject-flow.js

@@ -1,260 +0,0 @@
-/**
- * Rejected-value tombstone: shared reject/unreject/list flow.
- *
- * The CLI (`hippo reject`/`rejections`/`unreject`) and the Context-based
- * `api.reject`/`api.unreject`/`api.listRejections` surfaces both need the
- * 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,
- * 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 { BadRequestError } from './api-errors.js';
-import { appendAuditEvent, reportAuditWriteFailure } from './audit.js';
-import { isPersonalScope } from './recall-scope.js';
-import { archiveRawMemory } from './raw-archive.js';
-import { deleteDormantRow, listDormantSnapshots, purgeDormantByDigest, replaceDormantEntry } from './dormant.js';
-import { stampOriginProject } from './store/entry-row.js';
-import { purgeMirrorBestEffort } from './store/mirrors.js';
-import { openStore } from './store/open.js';
-import { writeEntryDbOnly, writeEntryMirrors } from './store/entry-writes.js';
-import { selectAllEntries } from './store/entry-reads.js';
-import { deleteEntryCore } from './store/delete-and-batch.js';
-import { heldTexts } from './same-text.js';
-import { mergedSuccessor } from './merged-row.js';
-import { rejectionDigest, normalizeValueForRejection, insertRejectedValue, deleteRejectedValue, listRejectedValues, } from './rejection.js';
-function assertRejectOpts(opts) {
-    if (!opts.reason.trim()) {
-        throw new Error('reject requires a non-empty --reason (the tombstone stores no content; reason is its only identity).');
-    }
-    if (opts.memoryId === undefined && opts.value === undefined) {
-        throw new Error('reject requires either a memory id or --value.');
-    }
-    if (opts.memoryId !== undefined && opts.value !== undefined) {
-        // Enforced here, not only in the CLI parser, so a direct api caller passing both
-        // is refused instead of silently getting the memoryId path with `value` ignored.
-        throw new Error('reject accepts either a memory id or --value, not both.');
-    }
-    if (opts.value !== undefined && normalizeValueForRejection(opts.value).length === 0) {
-        // Direct api callers can pass strings the CLI flag parser would have
-        // refused; an empty-normalized tombstone would refuse nothing meaningful
-        // and pollute the listing.
-        throw new Error('reject --value requires non-empty content.');
-    }
-}
-function contentToReject(db, opts) {
-    if (opts.memoryId === undefined)
-        return opts.value;
-    // SAFETY: row's shape matches the three columns named in the SELECT above.
-    const row = db
-        .prepare(`SELECT content, tenant_id, scope FROM memories WHERE id = ?`)
-        .get(opts.memoryId);
-    if (!row || row.tenant_id !== opts.tenantId) {
-        throw new Error(`memory not found: ${opts.memoryId}`);
-    }
-    // A tombstone is tenant-wide, so one made from personal text would show its reason to everyone.
-    if (isPersonalScope(row.scope))
-        throw new BadRequestError("Personal memories can't be rejected. Use forget to remove it.");
-    return row.content;
-}
-/** Every row but another person's personal one, which is outside the caller's recall and so outside its reject. */
-function inReach(opts, scope) {
-    return !isPersonalScope(scope) || scope === opts.ownScope;
-}
-function removeLiveRows(db, opts, holdsValue, removal) {
-    const { removedIds, removedRawIds, successors } = removal;
-    const merged = [];
-    for (const row of selectAllEntries(db, opts.tenantId)) {
-        if (!inReach(opts, row.scope))
-            continue;
-        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
-            // composes safely inside this BEGIN/COMMIT.
-            archiveRawMemory(db, row.id, { reason: opts.reason, who: opts.actor });
-            removedRawIds.push(row.id);
-        }
-        else {
-            // suppressForgetAudit: the aggregate reject_value row below is the
-            // trail for these removals, not N individual forget rows.
-            deleteEntryCore(db, row.id, { actor: opts.actor, suppressForgetAudit: true });
-        }
-        removedIds.push(row.id);
-    }
-    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.
-function removeDormantCopies(db, opts, digest, holdsValue, removal) {
-    const { tenantId } = opts;
-    const { removedIds, dormantSuccessorIds } = removal;
-    removedIds.push(...purgeDormantByDigest(db, tenantId, digest, (scope) => inReach(opts, scope)));
-    for (const dormant of listDormantSnapshots(db, tenantId)) {
-        if (!inReach(opts, dormant.entry.scope))
-            continue;
-        const successor = mergedSuccessor(dormant.entry, holdsValue, new Set(removedIds));
-        if (successor === undefined)
-            continue;
-        removedIds.push(dormant.entry.id);
-        if (!successor) {
-            deleteDormantRow(db, tenantId, dormant.entry.id);
-            continue;
-        }
-        replaceDormantEntry(db, tenantId, dormant.entry.id, successor);
-        dormantSuccessorIds.push(successor.id);
-    }
-}
-function auditRejectValue(db, opts, digest, removedIds) {
-    try {
-        appendAuditEvent(db, {
-            tenantId: opts.tenantId,
-            actor: opts.actor,
-            op: 'reject_value',
-            targetId: opts.memoryId,
-            metadata: { digest, removedIds, count: removedIds.length },
-        });
-    }
-    catch (error) {
-        // Inside the open transaction: the reject commits without its trail row rather than rolling back over bookkeeping.
-        reportAuditWriteFailure('reject_value', String(error), opts.memoryId);
-    }
-}
-// Post-commit, db handle still open (same pattern as api.archiveRaw):
-// best-effort mirror purge per removed id, reaper-backstop stamp for
-// raw ids.
-function purgeRemovedMirrors(db, hippoRoot, removal) {
-    for (const id of removal.removedIds) {
-        // purgeMirrorBestEffort retries once, then for non-raw ids (which the
-        // reaper never scans) reports the EXPLICIT leftover path(s). See its own doc comment (store.ts, near
-        // removeEntryMirrors) for the full rationale.
-        const mirrorOk = purgeMirrorBestEffort(hippoRoot, id, removal.removedRawIds.includes(id), 'hippo reject');
-        if (mirrorOk && removal.removedRawIds.includes(id)) {
-            db.prepare(`UPDATE raw_archive SET mirror_cleaned_at = ? WHERE memory_id = ?`).run(new Date().toISOString(), id);
-        }
-    }
-    for (const successor of removal.successors)
-        writeEntryMirrors(hippoRoot, successor);
-}
-/**
- * `hippo reject` / `api.reject` core flow. ONE connection, one transaction:
- * insert the tombstone, enumerate + remove every live tenant row whose
- * normalized digest matches (kind-aware), one aggregate `reject_value`
- * audit, COMMIT. Then post-commit (mirrors the existing purge+reaper
- * pattern verbatim from api.archiveRaw, api.ts:1913-1938): best-effort
- * mirror purge per removed id, `mirror_cleaned_at` stamps for raw ids.
- * index.json itself is only refreshed by `rebuildIndex()`.
- */
-export function rejectValue(opts) {
-    assertRejectOpts(opts);
-    const db = openStore(opts.hippoRoot);
-    try {
-        const content = contentToReject(db, opts);
-        const digest = rejectionDigest(content);
-        const now = new Date().toISOString();
-        const removal = { removedIds: [], removedRawIds: [], successors: [], dormantSuccessorIds: [] };
-        db.exec('BEGIN IMMEDIATE');
-        try {
-            insertRejectedValue(db, {
-                tenantId: opts.tenantId,
-                digest,
-                reason: opts.reason,
-                rejectedBy: opts.actor,
-                rejectedAt: now,
-                sourceMemoryId: opts.memoryId ?? null,
-                normalizedChars: normalizeValueForRejection(content).length,
-            });
-            // 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.
-            const holdsValue = (text) => rejectionDigest(text) === digest;
-            removeLiveRows(db, opts, holdsValue, removal);
-            removeDormantCopies(db, opts, digest, holdsValue, removal);
-            auditRejectValue(db, opts, digest, removal.removedIds);
-            db.exec('COMMIT');
-        }
-        catch (err) {
-            try {
-                db.exec('ROLLBACK');
-            }
-            catch {
-                // already rolled back
-            }
-            throw err;
-        }
-        purgeRemovedMirrors(db, opts.hippoRoot, removal);
-        const { removedIds, removedRawIds, successors, dormantSuccessorIds } = removal;
-        return { digest, content, removedIds, removedRawIds, successorIds: successors.map((s) => s.id), dormantSuccessorIds };
-    }
-    finally {
-        closeHippoDb(db);
-    }
-}
-/**
- * `hippo unreject` / `api.unreject` — resolve a unique tombstone by digest
- * (or prefix), delete it, audit `unreject_value`. The only v1 escape hatch
- * (plan §4): no per-write force flag.
- */
-export function unrejectValue(hippoRoot, tenantId, digestOrPrefix, actor) {
-    // An empty/blank prefix startsWith-matches EVERY digest and would list the whole
-    // tombstone set as ambiguous, so reject it before the DB round trip.
-    if (digestOrPrefix.trim().length === 0) {
-        return { status: 'not_found' };
-    }
-    const db = openStore(hippoRoot);
-    try {
-        const all = listRejectedValues(db, tenantId);
-        const matches = all.filter((r) => r.digest.startsWith(digestOrPrefix));
-        if (matches.length === 0)
-            return { status: 'not_found' };
-        if (matches.length > 1)
-            return { status: 'ambiguous', candidates: matches };
-        const target = matches[0];
-        deleteRejectedValue(db, tenantId, target.digest);
-        try {
-            appendAuditEvent(db, {
-                tenantId,
-                actor,
-                op: 'unreject_value',
-                targetId: target.sourceMemoryId ?? undefined,
-                metadata: { digest: target.digest, reason: target.reason },
-            });
-        }
-        catch (error) {
-            reportAuditWriteFailure('unreject_value', String(error), target.sourceMemoryId);
-        }
-        return { status: 'ok', digest: target.digest, reason: target.reason };
-    }
-    finally {
-        closeHippoDb(db);
-    }
-}
-/** `hippo rejections` / `api.listRejections` — list tombstones for a tenant. */
-export function listRejectionsForTenant(hippoRoot, tenantId) {
-    const db = openStore(hippoRoot);
-    try {
-        return listRejectedValues(db, tenantId);
-    }
-    finally {
-        closeHippoDb(db);
-    }
-}
-//# sourceMappingURL=reject-flow.js.map

package/dist/rejection.d.ts

@@ -1,100 +0,0 @@
-/**
- * Rejected-value tombstone: core invariant.
- *
- * Exact-normalized-value semantics: a human who rejects a fact can refuse
- * byte-stable re-ingestion of the same value across remember/capture/import/
- * sync surfaces. Paraphrase/semantic matching is explicitly out of scope
- * (documented limitation, plan "Design").
- *
- * Kept db-agnostic (helpers take a `DatabaseSyncLike` handle) and does NOT
- * import from store.ts — store.ts imports from here, and the reverse would
- * be a cycle.
- */
-import type { DatabaseSyncLike } from './db.js';
-import { BadRequestError } from './api-errors.js';
-/**
- * Normalize content for rejection-digest comparisons: Unicode NFC →
- * lowercase → collapse whitespace runs to a single space → trim. No
- * punctuation stripping — over-normalization creates false refusals, which
- * are worse than misses (plan §1).
- */
-export declare function normalizeValueForRejection(content: string): string;
-/**
- * Full sha256 hex (64 chars) of the normalized content. Reuses the strong-
- * identity convention (importers.ts:814 content-hash tag), NOT the privacy-
- * lossy 16-char convention (recall-trace query hashing) — a tombstone lookup
- * key needs collision resistance, not redaction (plan §1).
- */
-export declare function rejectionDigest(content: string): string;
-/**
- * Thrown by the write-path guard (checkRejectionGuard, called from
- * upsertEntryRow) when an incoming write would introduce a value matching a
- * tombstoned digest. Carries enough context for the transaction-owner catch
- * blocks (writeEntry, api.supersede) to write a post-rollback
- * `reject_refusal` audit row via `auditRejectionRefusal` (plan §3).
- */
-export declare class RejectedValueError extends BadRequestError {
-    readonly digest: string;
-    readonly tenantId: string;
-    readonly entryId: string;
-    readonly reason: string | null;
-    readonly rejectedAt: string;
-    constructor(opts: {
-        digest: string;
-        tenantId: string;
-        entryId: string;
-        reason: string | null;
-        rejectedAt: string;
-    });
-}
-export interface RejectedValueRow {
-    tenantId: string;
-    digest: string;
-    reason: string | null;
-    rejectedBy: string | null;
-    rejectedAt: string;
-    sourceMemoryId: string | null;
-    normalizedChars: number | null;
-}
-/**
- * Look up a tombstone by tenant + digest. One indexed point query — the
- * guard's common-case cost, a miss ends the guard (plan §3).
- */
-export declare function findRejectedValue(db: DatabaseSyncLike, tenantId: string, digest: string): RejectedValueRow | null;
-/**
- * Insert (or refresh) a tombstone row. Caller owns the transaction — used by
- * the `reject` verb and `resolveConflict`'s `rejectLoserValue` path.
- */
-export declare function insertRejectedValue(db: DatabaseSyncLike, opts: {
-    tenantId: string;
-    digest: string;
-    reason: string;
-    rejectedBy: string;
-    rejectedAt: string;
-    sourceMemoryId?: string | null;
-    normalizedChars: number;
-}): void;
-/**
- * Delete a tombstone by tenant + exact digest: the `unreject` verb, the
- * only escape hatch.
- */
-export declare function deleteRejectedValue(db: DatabaseSyncLike, tenantId: string, digest: string): boolean;
-/** List tombstones for a tenant, newest first: the `rejections` verb. */
-export declare function listRejectedValues(db: DatabaseSyncLike, tenantId: string): RejectedValueRow[];
-/**
- * The write-path guard's check helper, called from `upsertEntryRow`
- * (store.ts). Fires when the incoming content's digest matches a tombstone
- * AND the write *introduces* that content: the row is new, OR the stored
- * row's content digest differs from the incoming one — an UPSERT editing a
- * same-id row TO a rejected value is a content introduction and must be
- * refused. Unchanged same-id re-persists (recall boost, decay, star toggle)
- * are exempt by construction (plan §3).
- *
- * Ordering minimizes queries on the common (miss) path: (a) caller has
- * already computed nothing yet — this does the digest + point lookup first;
- * (b) a miss returns immediately (ONE indexed point query); (c) only on a
- * tombstone hit does it SELECT the stored row's content to classify
- * new-row vs content-introduction (+1 query, rare path).
- */
-export declare function checkRejectionGuard(db: DatabaseSyncLike, tenantId: string, entryId: string, content: string): void;
-//# sourceMappingURL=rejection.d.ts.map

package/dist/replay.d.ts

@@ -1,41 +0,0 @@
-/**
- * Replay — biologically-inspired rehearsal during consolidation.
- *
- * Hippocampal replay is internally-driven reactivation of memories during
- * slow-wave sleep: the brain picks important recent experiences and "plays
- * them back" without external input, strengthening them before they decay.
- * In McClelland's complementary-learning-systems framing, replay is also
- * how episodic memories train the neocortex (interleaved rehearsal); in
- * reward-modulated STDP, replay is gated by dopamine so rewarded
- * experiences get preferentially consolidated.
- *
- * This module implements a lightweight, deterministic analog. During each
- * `hippo sleep`, we sample N surviving memories by a priority score that
- * weighs reward feedback, emotional valence, under-rehearsal, and age —
- * then apply the same retrieval-strengthening dynamics `markRetrieved`
- * applies to real queries. The effect is that important memories stay
- * strong even when the user hasn't explicitly queried them recently.
- *
- * Distinct from the other consolidation passes:
- *   - decay: removes what's too weak
- *   - physics: moves particles in embedding space
- *   - merge: collapses near-duplicate episodics into semantics
- *   - REPLAY: picks winners and rehearses them (this file)
- */
-import { type MemoryEntry } from './memory.js';
-/**
- * Priority score used to rank survivors for replay. Higher = more likely
- * to be sampled. Pure function of the entry and current time.
- */
-export declare function replayPriority(entry: MemoryEntry, now: Date): number;
-/**
- * Pick `count` memories for replay, weighted by `replayPriority`, without
- * replacement. Deterministic given the same seed.
- *
- * The sampler is weighted but not greedy — picking by priority alone would
- * always pick the top-N, which overfits. Biological replay shows both
- * preferential-for-reward AND stochastic-exploration characteristics; we
- * keep the stochastic element so adjacent survivors aren't always ignored.
- */
-export declare function sampleForReplay(survivors: MemoryEntry[], count: number, now: Date, seed?: number): MemoryEntry[];
-//# sourceMappingURL=replay.d.ts.map