hippo-memory 1.69.0 → 1.71.0

package/dist/recall-history.d.ts

@@ -1,131 +0,0 @@
-/**
- * Anchoring detector (recall-recurrence), pure module.
- *
- * Implements two detection rules:
- *   query_repeat: same queryHash within recentRepeatWindow returned
- *     same topMemoryId (caller is re-asking the same question).
- *   memory_dominance: same topMemoryId across >= minDominance distinct
- *     queryHashes (memory acts as a fixed-point anchor regardless of what
- *     the agent asks).
- *
- * Each pipeline (api.recall via
- * HTTP, cmdRecall, MCP hippo_recall) owns its OWN ring buffer Map keyed
- * by (tenant, session). No cross-pipeline sharing (the typical multi-
- * process deployment makes IPC ring-sharing impractical; per-pipeline
- * is correct because each pipeline has its own top-1 ranking anyway).
- *
- * AnchoringHint + PlanningFallacyHint are independent
- * signals; both can fire on the same recall.
- */
-export type AnchoringReason = 'query_repeat' | 'memory_dominance';
-export interface AnchoringHint {
-    reason: AnchoringReason;
-    /** The memory ID that is anchoring the agent's reasoning. */
-    memoryId: string;
-    /** For 'memory_dominance': how many distinct queries in the recent window
-     *  had this memory as their top-1 result. Always >= 3 when emitted. */
-    queryCount?: number;
-    /** Human-readable summary surfaced to the agent. */
-    summary: string;
-    /** Discriminator for hint origin; reserved for future variants. */
-    source: 'j1-recurrence';
-}
-export interface RecallHistoryEntry {
-    /** Hash of the queryText that produced this entry (see hashQueryText). */
-    queryHash: number;
-    /** Top-1 memory id this recall surfaced; null if zero results. */
-    topMemoryId: string | null;
-    /** ISO-8601 timestamp; advisory, not used by the detection rules. */
-    ts: string;
-    /** Memory id of the AnchoringHint that fired on this recall, if any.
-     *  Used by the cooldown logic to prevent re-emitting the same hint on
-     *  consecutive recalls within the dominance window. Caller-written
-     *  AFTER detectAnchoring returns; reads next time detectAnchoring runs. */
-    anchoredOn?: string;
-}
-export type RecallHistorySnapshot = readonly RecallHistoryEntry[];
-export interface DetectAnchoringOpts {
-    /** memory_dominance threshold: number of distinct queryHashes that must have returned
-     *  the same topMemoryId. Default 3. */
-    minDominance?: number;
-    /** query_repeat window: how many recent history entries to scan for query repeat.
-     *  Default 5. */
-    recentRepeatWindow?: number;
-    /** Cooldown: if the immediately-prior fire (per `anchoredOn`) was for
-     *  the same topMemoryId within this many history entries, suppress.
-     *  Default 3. */
-    cooldown?: number;
-}
-/**
- * Normalize + hash a query text into a 32-bit integer.
- * Lowercase → strip non-alphanumeric → split → drop empty + short tokens →
- * sort tokens → join → FNV-1a 32-bit.
- *
- * Token sort + dedup means semantically-equivalent queries with reordered
- * words collide intentionally ("semantically-distinct" is approximated by
- * textual normalization, not embeddings).
- *
- * Deterministic across processes; stable across Node + V8 versions.
- */
-export declare function hashQueryText(query: string): number;
-/**
- * Detect anchoring patterns in the recall history against the current
- * recall's (queryHash, topMemoryId).
- *
- * Rule precedence: memory_dominance wins on tie. When both rules fire on the
- * same recall, return only memory_dominance, the stronger signal (a memory
- * dominating multiple DIFFERENT queries is a fixed-point anchor; query_repeat
- * alone is just a literal re-ask).
- *
- * Cooldown: if the immediately-prior recall fired a hint on the SAME
- * topMemoryId within `cooldown=3` history entries, suppress. Prevents
- * spam when the agent repeatedly recalls within the dominance window.
- * Cooldown is per-memory, not per-rule: if memory_dominance fired on M
- * (cooldown engaged for M), and the next recall has top=N + repeated query,
- * query_repeat fires on N (different memory, not in cooldown).
- *
- * @returns AnchoringHint when a pattern fires; null otherwise.
- */
-export declare function detectAnchoring(history: RecallHistorySnapshot, currentQueryHash: number, currentTopMemoryId: string | null, opts?: DetectAnchoringOpts): AnchoringHint | null;
-/**
- * Bounded FIFO ring of RecallHistoryEntry. Newest entries pushed via
- * append; oldest evicted when the ring is full. The class is intentionally
- * a thin wrapper around an array so snapshotRing returns a readonly view
- * without copying on the hot path.
- */
-export declare class RingBuffer {
-    private entries;
-    append(entry: RecallHistoryEntry): void;
-    snapshot(): RecallHistorySnapshot;
-    size(): number;
-}
-/**
- * Build the (tenant, session) key for a per-session ring Map. Uses a NUL
- * (`\x00`) byte as delimiter because tenant ids and session ids are
- * validated elsewhere to reject NUL chars — guarantees collision-free
- * concatenation regardless of what `:` or other delimiters might appear
- * inside either field (notably API-key-derived subjects can contain `:`).
- */
-export declare function buildSessionKey(tenantId: string, sessionId: string): string;
-/**
- * Get-or-create a RingBuffer for a session key. Caps total tracked keys
- * at `maxSessions` (default 1000) with LRU eviction — when the cap is
- * hit, deletes the oldest-inserted key before inserting the new one.
- * Map iteration order preserves insertion order per ECMA-262 spec, so
- * "oldest" = first key returned by Map.prototype.keys().
- */
-export declare function getOrCreateRing(map: Map<string, RingBuffer>, key: string, maxSessions?: number): RingBuffer;
-/**
- * Append a recall to a ring. The `anchoredOn` argument carries the
- * memoryId of the AnchoringHint that fired on THIS recall (or undefined
- * if no hint). detectAnchoring reads it next time for cooldown gating.
- */
-export declare function appendRecall(ring: RingBuffer, queryHash: number, topMemoryId: string | null, anchoredOn?: string): void;
-/** Snapshot a ring as a readonly RecallHistorySnapshot. */
-export declare function snapshotRing(ring: RingBuffer): RecallHistorySnapshot;
-/**
- * Whether a recall bias hint is enabled. Reads the env at call time, so
- * `HIPPO_ANCHORING=off` or `HIPPO_AVAILABILITY=off` disables only that kind.
- */
-export declare function biasHintEnabled(kind: 'anchoring' | 'availability'): boolean;
-//# sourceMappingURL=recall-history.d.ts.map

package/dist/recall-history.js

@@ -1,227 +0,0 @@
-/**
- * Anchoring detector (recall-recurrence), pure module.
- *
- * Implements two detection rules:
- *   query_repeat: same queryHash within recentRepeatWindow returned
- *     same topMemoryId (caller is re-asking the same question).
- *   memory_dominance: same topMemoryId across >= minDominance distinct
- *     queryHashes (memory acts as a fixed-point anchor regardless of what
- *     the agent asks).
- *
- * Each pipeline (api.recall via
- * HTTP, cmdRecall, MCP hippo_recall) owns its OWN ring buffer Map keyed
- * by (tenant, session). No cross-pipeline sharing (the typical multi-
- * process deployment makes IPC ring-sharing impractical; per-pipeline
- * is correct because each pipeline has its own top-1 ranking anyway).
- *
- * AnchoringHint + PlanningFallacyHint are independent
- * signals; both can fire on the same recall.
- */
-import { envAnchoringOff, envAvailabilityOff } from './env.js';
-const DEFAULT_MIN_DOMINANCE = 3;
-const DEFAULT_RECENT_REPEAT_WINDOW = 5;
-const DEFAULT_COOLDOWN = 3;
-// ---------------------------------------------------------------------------
-// Query text normalization + hashing
-// ---------------------------------------------------------------------------
-/**
- * Normalize + hash a query text into a 32-bit integer.
- * Lowercase → strip non-alphanumeric → split → drop empty + short tokens →
- * sort tokens → join → FNV-1a 32-bit.
- *
- * Token sort + dedup means semantically-equivalent queries with reordered
- * words collide intentionally ("semantically-distinct" is approximated by
- * textual normalization, not embeddings).
- *
- * Deterministic across processes; stable across Node + V8 versions.
- */
-export function hashQueryText(query) {
-    if (!query)
-        return 0;
-    // Tokens are deduped before join so `foo foo bar` and `foo bar` count as one query for memory_dominance.
-    // Unicode classes (\p{L} letter, \p{N} number, \p{M} combining mark; needs /u) keep
-    // non-Latin queries from collapsing to an empty token set and colliding at hash 0.
-    const normalized = query
-        .toLowerCase()
-        .replace(/[^\p{L}\p{N}\p{M}\s]/gu, ' ')
-        .split(/\s+/)
-        .filter((t) => t.length > 0);
-    // Drop tokens under 3 chars (filler words) so `a login bug` and `login bug` hash
-    // alike; matches the >=3 filter in src/forward-claim-detector.ts.
-    const filtered = normalized.filter((t) => t.length >= 3);
-    // Fall back to all tokens when the filter empties the query (CJK 2-char words,
-    // acronyms like `AI`) so distinct short queries do not all hash to fnv1a32('').
-    const tokens = filtered.length > 0 ? filtered : normalized;
-    const deduped = Array.from(new Set(tokens)).sort();
-    return fnv1a32(deduped.join(' '));
-}
-function fnv1a32(text) {
-    // FNV-1a 32-bit. Offset basis 2166136261, prime 16777619.
-    let hash = 2166136261;
-    for (let i = 0; i < text.length; i++) {
-        hash ^= text.charCodeAt(i);
-        // 32-bit multiply via Math.imul — handles overflow correctly.
-        hash = Math.imul(hash, 16777619);
-    }
-    // Coerce to unsigned 32-bit for stable comparison.
-    return hash >>> 0;
-}
-// ---------------------------------------------------------------------------
-// Anchoring detection
-// ---------------------------------------------------------------------------
-/**
- * Detect anchoring patterns in the recall history against the current
- * recall's (queryHash, topMemoryId).
- *
- * Rule precedence: memory_dominance wins on tie. When both rules fire on the
- * same recall, return only memory_dominance, the stronger signal (a memory
- * dominating multiple DIFFERENT queries is a fixed-point anchor; query_repeat
- * alone is just a literal re-ask).
- *
- * Cooldown: if the immediately-prior recall fired a hint on the SAME
- * topMemoryId within `cooldown=3` history entries, suppress. Prevents
- * spam when the agent repeatedly recalls within the dominance window.
- * Cooldown is per-memory, not per-rule: if memory_dominance fired on M
- * (cooldown engaged for M), and the next recall has top=N + repeated query,
- * query_repeat fires on N (different memory, not in cooldown).
- *
- * @returns AnchoringHint when a pattern fires; null otherwise.
- */
-export function detectAnchoring(history, currentQueryHash, currentTopMemoryId, opts = {}) {
-    if (currentTopMemoryId === null)
-        return null;
-    const minDominance = opts.minDominance ?? DEFAULT_MIN_DOMINANCE;
-    const recentRepeatWindow = opts.recentRepeatWindow ?? DEFAULT_RECENT_REPEAT_WINDOW;
-    const cooldown = opts.cooldown ?? DEFAULT_COOLDOWN;
-    // Cooldown gate: was the most-recent hint (across the last `cooldown`
-    // entries) for THIS memory? If yes, suppress regardless of rule.
-    const cooldownSlice = history.slice(-cooldown);
-    for (const entry of cooldownSlice) {
-        if (entry.anchoredOn === currentTopMemoryId) {
-            return null;
-        }
-    }
-    // memory_dominance check FIRST (wins on tie). Count distinct queryHashes in history
-    // where topMemoryId === currentTopMemoryId (excluding null tops).
-    const matchingQueryHashes = new Set();
-    for (const entry of history) {
-        if (entry.topMemoryId === currentTopMemoryId) {
-            matchingQueryHashes.add(entry.queryHash);
-        }
-    }
-    // Include current query in the count.
-    matchingQueryHashes.add(currentQueryHash);
-    const queryCount = matchingQueryHashes.size;
-    if (queryCount >= minDominance) {
-        return {
-            reason: 'memory_dominance',
-            memoryId: currentTopMemoryId,
-            queryCount,
-            summary: `Memory ${currentTopMemoryId} has been the top result for ${queryCount} distinct queries in this session and may be anchoring your reasoning.`,
-            source: 'j1-recurrence',
-        };
-    }
-    // query_repeat check: is currentQueryHash present in the last `recentRepeatWindow`
-    // entries AND was that entry's topMemoryId === currentTopMemoryId?
-    const r1Slice = history.slice(-recentRepeatWindow);
-    for (const entry of r1Slice) {
-        if (entry.queryHash === currentQueryHash && entry.topMemoryId === currentTopMemoryId) {
-            return {
-                reason: 'query_repeat',
-                memoryId: currentTopMemoryId,
-                summary: `Same query phrasing as a recent recall returned the same top result (${currentTopMemoryId}); you may be re-asking the same question.`,
-                source: 'j1-recurrence',
-            };
-        }
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// RingBuffer + caller-side state helpers
-// ---------------------------------------------------------------------------
-const MAX_HISTORY = 10;
-const DEFAULT_MAX_SESSIONS = 1000;
-/**
- * Bounded FIFO ring of RecallHistoryEntry. Newest entries pushed via
- * append; oldest evicted when the ring is full. The class is intentionally
- * a thin wrapper around an array so snapshotRing returns a readonly view
- * without copying on the hot path.
- */
-export class RingBuffer {
-    entries = [];
-    append(entry) {
-        this.entries.push(entry);
-        if (this.entries.length > MAX_HISTORY) {
-            this.entries.shift();
-        }
-    }
-    snapshot() {
-        return this.entries;
-    }
-    size() {
-        return this.entries.length;
-    }
-}
-/**
- * Build the (tenant, session) key for a per-session ring Map. Uses a NUL
- * (`\x00`) byte as delimiter because tenant ids and session ids are
- * validated elsewhere to reject NUL chars — guarantees collision-free
- * concatenation regardless of what `:` or other delimiters might appear
- * inside either field (notably API-key-derived subjects can contain `:`).
- */
-export function buildSessionKey(tenantId, sessionId) {
-    return `${tenantId}\x00${sessionId}`;
-}
-/**
- * Get-or-create a RingBuffer for a session key. Caps total tracked keys
- * at `maxSessions` (default 1000) with LRU eviction — when the cap is
- * hit, deletes the oldest-inserted key before inserting the new one.
- * Map iteration order preserves insertion order per ECMA-262 spec, so
- * "oldest" = first key returned by Map.prototype.keys().
- */
-export function getOrCreateRing(map, key, maxSessions = DEFAULT_MAX_SESSIONS) {
-    const existing = map.get(key);
-    if (existing) {
-        // LRU touch: delete + re-insert to move to back of iteration order.
-        map.delete(key);
-        map.set(key, existing);
-        return existing;
-    }
-    if (map.size >= maxSessions) {
-        const oldest = map.keys().next().value;
-        if (oldest !== undefined)
-            map.delete(oldest);
-    }
-    const ring = new RingBuffer();
-    map.set(key, ring);
-    return ring;
-}
-/**
- * Append a recall to a ring. The `anchoredOn` argument carries the
- * memoryId of the AnchoringHint that fired on THIS recall (or undefined
- * if no hint). detectAnchoring reads it next time for cooldown gating.
- */
-export function appendRecall(ring, queryHash, topMemoryId, anchoredOn) {
-    const entry = {
-        queryHash,
-        topMemoryId,
-        ts: new Date().toISOString(),
-    };
-    if (anchoredOn !== undefined)
-        entry.anchoredOn = anchoredOn;
-    ring.append(entry);
-}
-/** Snapshot a ring as a readonly RecallHistorySnapshot. */
-export function snapshotRing(ring) {
-    return ring.snapshot();
-}
-/**
- * Whether a recall bias hint is enabled. Reads the env at call time, so
- * `HIPPO_ANCHORING=off` or `HIPPO_AVAILABILITY=off` disables only that kind.
- */
-export function biasHintEnabled(kind) {
-    return kind === 'anchoring'
-        ? !envAnchoringOff()
-        : !envAvailabilityOff();
-}
-//# sourceMappingURL=recall-history.js.map

package/dist/recall-scope.d.ts

@@ -1,138 +0,0 @@
-/**
- * Recall-side scope predicates, in a leaf module so shared.ts (which api.ts
- * imports) can apply the same default-deny rule to searchBothHybrid's internal
- * candidate loads without an import cycle. api.ts imports
- * these for its own call sites AND re-exports them for back-compat
- * (`api.isPrivateScope`, test imports of `passesScopeFilterForRecall`).
- */
-import { ForbiddenError } from './api-errors.js';
-/**
- * Literal scopes excluded from recall by default-deny when the
- * caller passes no `scope`. The SQL clause in `loadSearchRows` and the JS
- * helper `passesScopeFilterForRecall` (src/api.ts) both read from this
- * constant. Adding a deny scope is a one-place change.
- *
- * Regex-based denies (e.g. `<source>:private:*`) stay in
- * `passesScopeFilterForRecall` as a separate JS step — they don't translate
- * cleanly to SQL.
- *
- * Invariant: never empty. An empty array would silently allow quarantine
- * scopes through both paths (SQL clause omitted, JS check vacuous). The
- * module-load assertion below pins this loudly.
- */
-export declare const RECALL_DEFAULT_DENY_SCOPES: readonly ["unknown:legacy"];
-/**
- * @internal Runtime guard against a future maintainer blanking a
- * load-bearing literal array. Extracted from the inline guard so the throw
- * path is directly testable. `as const` arrays widen via `readonly T[]` at
- * the call site so the empty case is reachable at runtime.
- */
-export declare function assertNonEmpty<T>(arr: readonly T[], name: string): void;
-/**
- * Source-agnostic private-scope detector. A scope string is treated
- * as private when it has the shape `<lowercase-source>:private:<rest>`.
- *
- * Examples that match:
- *   slack:private:Cabc, github:private:owner/repo, jira:private:PROJ-1
- * Examples that DO NOT match:
- *   slack:public:Cgeneral, acme:public:my-private-channel, null, '',
- *   'unknown:legacy', 'private' (alone), 'private:foo' (no source prefix).
- *
- * Used by api.recall, mcp/server.ts (hippo_recall + hippo_context),
- * cli.ts (cmdRecall + cmdExplain + continuity), shared.ts (searchBothHybrid
- * recall mode). Keep these in sync — the export is the single source of
- * truth so connector work cannot drift.
- */
-export declare const PRIVATE_SCOPE_RE: RegExp;
-/** True when `scope` matches the `<source>:private:*` shape. */
-export declare function isPrivateScope(scope: string | null | undefined): boolean;
-export declare const PERSONAL_SCOPE_PREFIX = "personal:private:";
-export declare const PERSONAL_OWNER_MAX: number;
-/** True for a `personal:private:<owner>` scope, any case, so a case variant is never mistaken for a team scope. */
-export declare function isPersonalScope(scope: string | null | undefined): boolean;
-/** The caller's own personal scope, or null when it has no owner that can hold one. */
-export declare function personalScopeOf(actor: {
-    owner?: string;
-} | undefined): string | null;
-/** Refuses a client-sent `personal:` scope: only the server stamps one, from the caller's owner. */
-export declare function assertClientScope(scope: string | null | undefined): void;
-/** True when `actor` may change or delete a row in `scope`: any non-personal scope, or its own personal one. */
-export declare function canTouchScope(actor: {
-    owner?: string;
-}, scope: string | null): boolean;
-/** canTouchScope for a caller known by its own personal scope, as a store method receives it. */
-export declare function ownScopeTouches(ownScope: string | null, scope: string | null): boolean;
-/**
- * Recall-side scope filter — the canonical JS half of the recall default-deny
- * rule (the SQL half lives in `loadSearchRows` via `loadRecallSearchEntries`).
- *
- * - When `requested` is set and non-empty: exact match required.
- * - When `requested` is undefined/empty: default-deny on any
- *   `<source>:private:*` scope and on the `RECALL_DEFAULT_DENY_SCOPES`
- *   quarantine buckets. `null` and public scopes pass, and so does `ownScope`, the caller's own personal scope.
- */
-export declare function passesScopeFilterForRecall(scope: string | null, requested: string | undefined, ownScope?: string | null): boolean;
-export interface SqlFragment {
-    sql: string;
-    params: string[];
-}
-/** SQL twin of the no-request arm of passesScopeFilterForRecall; `ownScope` is bound and compared with `=`, so `%` or `_` in an owner match nothing extra. */
-export declare function scopeAdmitSql(col: '' | 'm.', ownScope?: string | null): SqlFragment;
-/** SQL twin of canTouchScope, which is also canReadScope for an admin: every row but another person's personal one. LIKE folds ASCII case as isPersonalScope's /i does. */
-export declare function touchableScopeSql(col: '' | 'm.', ownScope?: string | null): SqlFragment;
-/**
- * The CLI `--scope` variant of the recall filter (JS half of the
- * SQL 'default-deny-or-exact' mode in loadSearchRows).
- *
- * The CLI flag predates the envelope column as a TAG-boost ranking hint
- * (`scope:<v>` tags, HIPPO_SCOPE, detectScope()), so an explicit `--scope X`
- * UNLOCKS envelope scope X in addition to the default-admitted set — it does
- * NOT narrow the result to X (that would return zero rows for every
- * tag-scoped workflow, whose envelope scope is NULL). api.recall keeps the
- * narrowing 'exact' semantics via `passesScopeFilterForRecall`.
- *
- * Note the unlock applies to whatever scope was explicitly named — including
- * a private scope or a quarantine bucket (`--scope unknown:legacy`). That is
- * deliberate owner access, identical in reach to api.recall's exact-match
- * for the same input; only NON-requested private/quarantine scopes stay
- * denied. A named personal scope never unlocks: the CLI has no caller identity to check it against.
- */
-export declare function passesCliRecallScopeFilter(scope: string | null, requested: string | undefined): boolean;
-/**
- * Thrown when a caller requests a scope its role may not read. The HTTP layer
- * maps it to 403.
- */
-export declare class ScopeForbiddenError extends ForbiddenError {
-    readonly scope: string;
-    constructor(scope: string);
-}
-/**
- * True for scopes that default-deny hides: `<source>:private:*` and the
- * quarantine buckets. Naming one explicitly is what unlocks it, so naming one
- * is the act that needs authorization.
- */
-export declare function isRestrictedScope(scope: string | null | undefined): boolean;
-/** The identity a scope check runs against: a role, any scope grants, and the person who owns the key. */
-export interface ScopeActor {
-    role: 'admin' | 'member';
-    scopes?: readonly string[];
-    owner?: string;
-}
-/** Personal rows answer to their owner alone: role, key grants and resolver scopes never open one. Else admin reads all; a member needs an exact grant on a restricted scope. */
-export declare function canReadScope(actor: ScopeActor, scope: string): boolean;
-/** Authorize an explicitly requested scope before any read honours it (member scope grants). */
-export declare function assertScopeRequestAllowed(actor: ScopeActor, requested: string | undefined): void;
-/** Scope a derived row keeps from one source: the restricted scope itself, else null. */
-export declare function derivationScope(scope: string | null | undefined): string | null;
-/** The one derivation scope shared by every source, or `{ ok: false }` when
- *  two disagree, so the caller skips the derived row instead of under-scoping it. */
-export declare function commonDerivationScope(scopes: readonly (string | null | undefined)[]): {
-    ok: true;
-    scope: string | null;
-} | {
-    ok: false;
-};
-/** Map-partition key for consolidate/dag/dedup producers: tenant + derivation scope + origin project,
- *  so a derived row never blends two restricted scopes, a mixed pair, or two projects. */
-export declare function derivationPartitionKey(tenantId: string, scope: string | null | undefined, origin: string | null | undefined): string;
-//# sourceMappingURL=recall-scope.d.ts.map

package/dist/refine-llm.d.ts

@@ -1,61 +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 { MemoryEntry } from './memory.js';
-export interface RefineOptions {
-    apiKey: string;
-    model?: string;
-    limit?: number;
-    dryRun?: boolean;
-    /** Ignore the llm-refined tag and re-refine everything eligible. */
-    all?: boolean;
-    /** Injected for testing — defaults to the real fetch. */
-    fetcher?: typeof fetch;
-    /**
-     * Tenant scope. When provided, refineStore only scans consolidated
-     * entries belonging to this tenant, and parent lookups are scoped to the
-     * same tenant. Cross-tenant parents return null from readEntry and are
-     * silently skipped (refine still produces output from merged content).
-     * Undefined preserves pre-1.12.1 host-wide scan behaviour.
-     */
-    tenantId?: string;
-}
-export interface RefineResult {
-    scanned: number;
-    refined: number;
-    skipped: number;
-    failed: number;
-    details: Array<{
-        id: string;
-        status: 'refined' | 'skipped' | 'failed';
-        reason?: string;
-    }>;
-}
-/**
- * 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 declare function refineSemanticMemory(merged: string, sources: MemoryEntry[], opts: {
-    apiKey: string;
-    model?: string;
-    fetcher?: typeof fetch;
-}): Promise<string | null>;
-/**
- * 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 declare function refineStore(hippoRoot: string, opts: RefineOptions): Promise<RefineResult>;
-//# sourceMappingURL=refine-llm.d.ts.map