hippo-memory 1.72.0 → 2.1.0

package/dist/api/{recall.js → recall/recall.js}

@@ -1,26 +1,25 @@
 // Read path: retrieve, the one recall entry.
-import { envRequireSessionScopedFreshTail } from '../util/env.js';
-import { DEFAULT_SEARCH_CANDIDATE_LIMIT } from '../store/rows.js';
-import { recallScopeFilter } from '../store/search-rows.js';
-import { estimateTokens } from '../util/token-text.js';
-import { formatHandoffEvidenceLine } from '../core/handoff.js';
-import { boostByGoals } from '../search/goal-boost.js';
-import { storeFor } from '../store/index.js';
-import { hybridSearch } from '../search/hybrid.js';
-import { physicsSearch } from '../search/physics-search.js';
-import { churnStaleFactor } from '../search/boosts.js';
-import { compareEntryIdentity } from '../core/compare.js';
-import { dropHeldCopies, duplicateKey, storedTextKeys } from '../util/same-text.js';
-import { isSharedStore, loadConfig } from '../core/config.js';
-import { classifyOriginProject, projectNames } from '../core/project-identity.js';
-import { decidePlanningFallacy, detectPlanningClaim } from '../predictions/planning-fallacy.js';
-import { detectAnchoring, hashQueryText, biasHintEnabled } from './recall-history.js';
-import { detectAvailabilityBias } from './availability.js';
-import { passesScopeFilterForRecall, assertScopeRequestAllowed, personalScopeOf } from '../core/recall-scope.js';
-import { ownerOrSubject, RecallContractError } from './types.js';
-import { anchoringRows, availabilityRows, callerOf, recallAuditMetadata, recallAuditRow, strengthenOf } from './recall-record.js';
-import { retrieveWithCliCore } from './recall-core.js';
-import { recallLead, recordShownRecall } from './recall-finish.js';
+import { envRequireSessionScopedFreshTail } from '../../util/env.js';
+import { DEFAULT_SEARCH_CANDIDATE_LIMIT } from '../../store/rows.js';
+import { recallScopeFilter } from '../../store/search-rows.js';
+import { estimateTokens } from '../../util/token-text.js';
+import { formatHandoffEvidenceLine } from '../../core/handoff.js';
+import { boostByGoals } from '../../search/goal-boost.js';
+import { searchByEngine } from '../../search/engine.js';
+import { churnStaleFactor } from '../../search/boosts.js';
+import { compareEntryIdentity } from '../../core/compare.js';
+import { dropHeldCopies, duplicateKey, storedTextKeys } from '../../util/same-text.js';
+import { isSharedStore } from '../../core/config.js';
+import { configOf } from '../config-of.js';
+import { classifyOriginProject, projectNames } from '../../core/project-identity.js';
+import { decidePlanningFallacy, detectPlanningClaim } from '../../predictions/planning-fallacy.js';
+import { detectAnchoring, hashQueryText, biasHintEnabled } from './finish.js';
+import { detectAvailabilityBias } from '../availability.js';
+import { passesScopeFilterForRecall, assertScopeRequestAllowed, personalScopeOf } from '../../core/recall-scope.js';
+import { ownerOrSubject, RecallContractError } from '../types.js';
+import { anchoringRows, availabilityRows, callerOf, recallAuditMetadata, recallAuditRow, strengthenOf, } from './finish.js';
+import { retrieveWithCliCore } from './request.js';
+import { recallLead, recordShownRecall } from './finish.js';
 const DEFAULT_RECALL_LIMIT = 10;
 function recallOrigin(opts) {
     return opts.project ? projectNames(opts.project) : undefined;
@@ -28,8 +27,8 @@ function recallOrigin(opts) {
 function inCallerProject(entry, opts) {
     return !opts.project || classifyOriginProject(entry.origin_project, opts.project) !== 'cross-project';
 }
-/** The one recall entry: ranks with the ranker `opts` names, then writes the recall, and records it in full for a surface that sets `recordAs`.
- *  Only the CLI core ranker writes last_retrieval_ids (contract lock). */
+/** The one recall entry: ranks with the ranker `opts` names, then writes the recall, and records it in full for a
+ * surface that sets `recordAs`. Only the CLI core ranker writes last_retrieval_ids (contract lock). */
 export async function retrieve(ctx, opts) {
     assertScopeRequestAllowed(ctx.actor, opts.scope);
     if (opts.cliCore)
@@ -39,7 +38,7 @@ export async function retrieve(ctx, opts) {
     const own = personalScopeOf(ctx.actor) ?? undefined;
     if (opts.showRanked)
         return retrieveFromStore(ctx, opts, windowSize, opts.showRanked, own);
-    const store = storeFor(ctx);
+    const store = ctx.store;
     const how = opts.recordAs;
     if (!how)
         return retrieveBand(ctx, store, opts, windowSize, own);
@@ -47,7 +46,8 @@ export async function retrieve(ctx, opts) {
     await recordShownRecall(ctx, store, how, shownBand(opts, result));
     return result;
 }
-/** What the band ranker hands to the record: the rows it returns, and the continuity block the reply carries beside them. */
+/** What the band ranker hands to the record: the rows it returns,
+ * and the continuity block the reply carries beside them. */
 function shownBand(opts, result) {
     return {
         query: opts.query,
@@ -57,30 +57,40 @@ function shownBand(opts, result) {
         items: result.results.length,
         tokens: result.tokens + (result.continuityTokens ?? 0),
         ledgerSessionId: opts.sessionId ?? null,
-        written: true, // a failed audit write throws out of the band ranker, so this point is never reached without the rows
+        // A failed audit write throws out of the band ranker, so this point is never reached without the rows.
+        written: true,
     };
 }
 /** The default ranker: the SQL BM25 band, reordered by hybrid or physics search when `mode` asks. */
 async function retrieveBand(ctx, store, opts, windowSize, own) {
     let candidates = await store.searchRecallEntries(opts.query, recallSearchArgs(ctx, opts, windowSize, own));
     if (opts.mode === 'hybrid' || opts.mode === 'physics') {
-        const searchOpts = { budget: Infinity, hippoRoot: ctx.hippoRoot, scope: opts.scope ?? null, vectorCandidates: recallVectorSpec(ctx, opts, own), store };
-        const ranked = await rankPool(ctx, opts, candidates, searchOpts);
+        const searchOpts = {
+            budget: Infinity,
+            scope: opts.scope ?? null,
+            vectorCandidates: recallVectorSpec(ctx, opts, own),
+        };
+        const ranked = await searchByEngine({ root: ctx.hippoRoot, store }, opts.query, candidates, physicsFor(ctx, opts), searchOpts);
         const rankedIds = new Set(ranked.map((r) => r.entry.id));
         candidates = [...ranked.map((r) => r.entry), ...candidates.filter((e) => !rankedIds.has(e.id))];
     }
     const plan = planRecall(ctx, opts, candidates, own);
-    const { result, writes } = composeRecall(ctx, opts, { windowSize, all: candidates, plan, reads: await readRecall(store, ctx, opts, plan) });
+    const reads = await readRecall(store, ctx, opts, plan);
+    const { result, writes } = composeRecall(ctx, opts, { windowSize, all: candidates, plan, reads });
+    await finishBandRecall(store, ctx, opts, writes, result.results.map((r) => r.id));
+    return result;
+}
+/** The one recall write: the caller's leading audit rows go first, and the ids shown are the ones strengthened. */
+async function finishBandRecall(store, ctx, opts, writes, shownIds) {
     await store.finishRecall({
-        ...writes, audit: [...(opts.leadingAudit ?? []), ...writes.audit], strengthen: strengthenOf(ctx, result.results.map((r) => r.id))
+        ...writes,
+        audit: [...(opts.leadingAudit ?? []), ...writes.audit],
+        strengthen: strengthenOf(ctx, shownIds),
     });
-    return result;
 }
-/** The ranked pool: physics when `mode` says so, hybrid otherwise; each caller supplies its own search options. */
-function rankPool(ctx, opts, pool, searchOpts) {
-    return opts.mode === 'physics'
-        ? physicsSearch(opts.query, pool, { ...searchOpts, physicsConfig: loadConfig(ctx.hippoRoot).physics })
-        : hybridSearch(opts.query, pool, searchOpts);
+/** `mode` names the engine: physics with the store's config, hybrid otherwise. */
+function physicsFor(ctx, opts) {
+    return opts.mode === 'physics' ? configOf(ctx).physics : null;
 }
 /** The recall load's arguments: exact scope, current rows only, the caller's project and personal scope. */
 function recallSearchArgs(ctx, opts, limit, own) {
@@ -106,47 +116,63 @@ function recallVectorSpec(ctx, opts, own) {
 }
 // Tag, pin and recency boosts can lift a row from deep in the BM25 order, so MCP ranks a wide lexical window.
 const SHOW_RANKED_LEXICAL_WINDOW = 1000;
-/** `retrieve` under `showRanked`: physics when `mode` says so, hybrid otherwise, over a wide lexical window plus the nearest vectors. */
+/** `retrieve` under `showRanked`: physics when `mode` says so, hybrid
+ * otherwise, over a wide lexical window plus the nearest vectors. */
 async function retrieveFromStore(ctx, opts, windowSize, show, own) {
-    const store = storeFor(ctx);
+    const store = ctx.store;
     const loaded = await store.searchRecallEntries(opts.query, recallSearchArgs(ctx, opts, Math.max(windowSize, SHOW_RANKED_LEXICAL_WINDOW), own));
     const pool = loaded.filter((e) => passesScopeFilterForRecall(e.scope ?? null, opts.scope, own));
     // No scope option: the scope boost follows HIPPO_SCOPE and the skill env, as MCP recall always ranked.
-    const searchOpts = { budget: Infinity, hippoRoot: ctx.hippoRoot, vectorCandidates: recallVectorSpec(ctx, opts, own), store };
-    let ranked = await rankPool(ctx, opts, pool, searchOpts);
-    // One goal read serves both boosts; the ranked list's log rows come first, so its scores win the log's first-write.
-    const goals = opts.sessionId && !opts.goalTag ? await store.activeGoals({ sessionId: opts.sessionId, tenantId: ctx.tenantId }) : null;
-    let rankedLog = [];
-    if (goals && opts.sessionId) {
-        const boost = boostByGoals(ranked, goals, { sessionId: opts.sessionId, tenantId: ctx.tenantId, limit: ranked.length });
-        ranked = boost.results;
-        rankedLog = boost.log;
-    }
+    const searchOpts = { budget: Infinity, vectorCandidates: recallVectorSpec(ctx, opts, own) };
+    const searched = await searchByEngine({ root: ctx.hippoRoot, store }, opts.query, pool, physicsFor(ctx, opts), searchOpts);
+    const { ranked, goals, rankedLog } = await boostRankedByGoals(ctx, opts, searched);
     const window = ranked.slice(0, windowSize).map((r) => r.entry);
     const bandOpts = { ...opts, suppressRecallTrace: true };
     const plan = planRecall(ctx, bandOpts, window, own);
-    const { result, writes } = composeRecall(ctx, bandOpts, {
-        windowSize, all: window, plan, reads: await readRecall(store, ctx, bandOpts, plan, goals), auditBand: false
+    const reads = await readRecall(store, ctx, bandOpts, plan, goals);
+    const { result, writes } = composeRecall(ctx, bandOpts, { windowSize, all: window, plan, reads, auditBand: false });
+    const shown = show({ ranked, pool: withVectorCandidates(pool, ranked), droppedByScope: loaded.length - pool.length }, result);
+    const { shownRow, trace } = shownAuditAndTrace(ctx, opts, shown.ids, ranked);
+    await finishBandRecall(store, ctx, opts, {
+        goalLog: [...rankedLog, ...writes.goalLog],
+        audit: [...writes.audit, shownRow, ...shown.audit],
+        trace,
+    }, shown.ids);
+    return result;
+}
+// One goal read serves both boosts; the ranked list's log rows come first, so its scores win the log's first-write.
+async function boostRankedByGoals(ctx, opts, ranked) {
+    const noLog = [];
+    const goals = opts.sessionId && !opts.goalTag
+        ? await ctx.store.activeGoals({ sessionId: opts.sessionId, tenantId: ctx.tenantId })
+        : null;
+    if (!goals || !opts.sessionId)
+        return { ranked, goals, rankedLog: noLog };
+    const boost = boostByGoals(ranked, goals, {
+        sessionId: opts.sessionId,
+        tenantId: ctx.tenantId,
+        limit: ranked.length,
     });
-    // Rows the vector arm added count as candidates too.
+    return { ranked: boost.results, goals, rankedLog: boost.log };
+}
+// Rows the vector arm added count as candidates too.
+function withVectorCandidates(pool, ranked) {
     const inPool = new Set(pool.map((e) => e.id));
-    const candidates = [...pool, ...ranked.map((r) => r.entry).filter((e) => !inPool.has(e.id))];
-    const shown = show({ ranked, pool: candidates, droppedByScope: loaded.length - pool.length }, result);
+    return [...pool, ...ranked.map((r) => r.entry).filter((e) => !inPool.has(e.id))];
+}
+function shownAuditAndTrace(ctx, opts, shownIds, ranked) {
     const scores = new Map(ranked.map((r) => [r.entry.id, r.score]));
-    const shownRow = recallAuditRow(callerOf(ctx), 'recall', undefined, recallAuditMetadata(opts.query, shown.ids.length));
-    await store.finishRecall({
-        goalLog: [...rankedLog, ...writes.goalLog],
-        audit: [...(opts.leadingAudit ?? []), ...writes.audit, shownRow, ...shown.audit],
-        trace: opts.suppressRecallTrace ? undefined : {
+    const shownRow = recallAuditRow(callerOf(ctx), 'recall', undefined, recallAuditMetadata(opts.query, shownIds.length));
+    const trace = opts.suppressRecallTrace
+        ? undefined
+        : {
             tenantId: ctx.tenantId,
             sessionId: opts.sessionId ?? null,
             pipeline: 'mcp',
             query: opts.query,
-            results: shown.ids.map((id) => ({ memoryId: id, score: scores.get(id) ?? 0 })),
-        },
-        strengthen: strengthenOf(ctx, shown.ids),
-    });
-    return result;
+            results: shownIds.map((id) => ({ memoryId: id, score: scores.get(id) ?? 0 })),
+        };
+    return { shownRow, trace };
 }
 /** Contract preflight: throws before any store-touching work. */
 function recallWindowSize(opts) {
@@ -190,16 +216,22 @@ async function readRecall(store, ctx, opts, plan, goals) {
     const parentIds = plan.overflow.size > 0 ? [...plan.overflow.keys()] : null;
     const continuity = opts.includeContinuity ? { key: continuityKey(ctx, opts) } : null;
     return {
-        goals: goals !== undefined ? goals : plan.goalBoost ? await store.activeGoals({ sessionId: plan.goalBoost.sessionId, tenantId }) : null,
+        goals: goals !== undefined
+            ? goals
+            : plan.goalBoost
+                ? await store.activeGoals({ sessionId: plan.goalBoost.sessionId, tenantId })
+                : null,
         parents: parentIds ? await store.entriesByIds(parentIds, tenantId) : [],
-        freshRaws: freshCount > 0 ? await store.freshRawEntries(freshCount, tenantId, opts.freshTailSessionId, recallOrigin(opts) ?? null) : [],
+        freshRaws: freshCount > 0
+            ? await store.freshRawEntries(freshCount, tenantId, opts.freshTailSessionId, recallOrigin(opts) ?? null)
+            : [],
         continuity: continuity ? await store.continuity(tenantId, CONTINUITY_EVENT_LIMIT, continuity.key) : undefined,
         planning: plan.claim ? await store.planningFallacyEvidence(tenantId, plan.claim.classQueryTokens) : null,
     };
 }
 // On a shared store the tenant's newest row is another developer's; no project keys to nothing, so the block is empty.
 function continuityKey(ctx, opts) {
-    if (!isSharedStore(ctx.hippoRoot))
+    if (!(ctx.reach ? ctx.reach.shared : isSharedStore(ctx.hippoRoot)))
         return null;
     return { owner: ownerOrSubject(ctx.actor), project: opts.project ? projectNames(opts.project) : [] };
 }
@@ -210,7 +242,9 @@ function composeRecall(ctx, opts, options) {
     const rankedOut = bands.rankedOut;
     const continuity = reads.continuity ? scopeContinuity(reads.continuity, opts, plan.own) : undefined;
     // Query-derived, so MCP and CLI read this one hint instead of recomputing; HIPPO_AUTODEBIAS=off disables it.
-    const planning = plan.claim && reads.planning ? decidePlanningFallacy(plan.claim, reads.planning, ctx.tenantId, ctx.actor.subject) : null;
+    const planning = plan.claim && reads.planning
+        ? decidePlanningFallacy(plan.claim, reads.planning, ctx.tenantId, ctx.actor.subject)
+        : null;
     const { anchoringHint, suppressedByInterference } = detectRecallAnchoring(opts, rankedOut[0]?.id ?? null);
     const availabilityHint = detectRecallAvailability(opts, bands.baseSlice, window.entries);
     const result = {
@@ -239,7 +273,9 @@ function composeRecall(ctx, opts, options) {
     if (availabilityHint)
         result.availabilityHint = availabilityHint;
     const who = callerOf(ctx);
-    const audit = auditBand ? [recallAuditRow(who, 'recall', undefined, recallAuditMetadata(opts.query, rankedOut.length))] : [];
+    const audit = auditBand
+        ? [recallAuditRow(who, 'recall', undefined, recallAuditMetadata(opts.query, rankedOut.length))]
+        : [];
     if (planning?.audit)
         audit.push(planning.audit);
     audit.push(...anchoringRows(who, anchoringHint), ...availabilityRows(who, availabilityHint));
@@ -294,7 +330,11 @@ function rankBands(opts, plan, reads) {
     const summaryRanked = substituted.map((s) => summaryItem(s, opts));
     const freshRanked = (opts.freshTailCount ?? 0) > 0
         ? freshTailBand(opts, {
-            recent: reads.freshRaws, baseRanked, summaryRanked, shownEntries: opts.keepHeldCopies ? [] : [...baseSlice, ...substituted.map((s) => s.entry)], own,
+            recent: reads.freshRaws,
+            baseRanked,
+            summaryRanked,
+            shownEntries: opts.keepHeldCopies ? [] : [...baseSlice, ...substituted.map((s) => s.entry)],
+            own,
         })
         : [];
     return {
@@ -309,7 +349,10 @@ function rankBands(opts, plan, reads) {
 // When the overflow holds 2+ children of one level-2 summary, that summary stands in for them, capped at 30% of
 // `limit`. Each one is tenant-scoped and re-checked against the scope filter; drillDown recovers the children.
 function substituteOverflow(opts, overflowByParent, parents, limit, own) {
-    const eligibleParents = parents.filter((p) => (p.dag_level ?? 0) === 2 && !p.superseded_by && passesScopeFilterForRecall(p.scope ?? null, opts.scope, own) && inCallerProject(p, opts));
+    const eligibleParents = parents.filter((p) => (p.dag_level ?? 0) === 2 &&
+        !p.superseded_by &&
+        passesScopeFilterForRecall(p.scope ?? null, opts.scope, own) &&
+        inCallerProject(p, opts));
     const maxSub = Math.max(1, Math.ceil(limit * SUMMARY_SUB_FRACTION));
     // Most overflowed children first; compareEntryIdentity only breaks a tie, which used to fall to scan order.
     eligibleParents.sort((a, b) => {
@@ -322,7 +365,8 @@ function substituteOverflow(opts, overflowByParent, parents, limit, own) {
         childIds: (overflowByParent.get(p.id) ?? []).map((e) => e.id),
     }));
 }
-/** Overflowed leaf rows by summary parent, kept only for a parent with 2+ of them that is not already in the base band. */
+/** Overflowed leaf rows by summary parent, kept only for a
+ * parent with 2+ of them that is not already in the base band. */
 function overflowGroups(window, limit) {
     // The goal boost only re-scores the base band, so its ids are known before the boost runs.
     const baseIds = new Set(window.baseSlice.map((e) => e.id));

package/dist/api/recall/render.d.ts

@@ -0,0 +1,39 @@
+import type { SearchResult } from '../../core/search-types.js';
+import { type AnchoringHint, type RingBuffer } from './finish.js';
+import { type AvailabilityHint } from '../availability.js';
+import type { RecallSuppressionSummary } from './types.js';
+/** A token allowance that sections pay from in print order; one that does not fit is refused whole. */
+export declare function tokenPurse(allowance: number): {
+    pays(tokens: number): boolean;
+    left: () => number;
+};
+/** Renders `count` rows, then drops the lowest-ranked one until the text fits `budget` or only `floor` rows remain. */
+export declare function shrinkToFit<R>(count: number, floor: number, budget: number, render: (kept: number) => R, textOf: (rendered: R) => string): R;
+/** The clause strings of the cutoff text; each surface frames them in its own line or section. */
+export declare function cutoffClauses(s: RecallSuppressionSummary): string[];
+export type SuppressionCounts = Omit<RecallSuppressionSummary, 'suppressedByInterference'>;
+export interface RecallHints {
+    readonly anchoring: AnchoringHint | null;
+    readonly availability: AvailabilityHint | null;
+}
+export declare function suppressionSummary(counts: SuppressionCounts, anchoring: AnchoringHint | null): RecallSuppressionSummary;
+export interface HintInputs {
+    readonly list: SearchResult[];
+    /** The candidate pool for availability bias; null when that hint is switched off. */
+    readonly pool: ReadonlyArray<{
+        id: string;
+        created: string;
+    }> | null;
+    readonly anchorRing: RingBuffer | null;
+    readonly queryHash: number;
+}
+/** Availability needs a pool only when its env switch is on, so callers skip building one otherwise. */
+export declare function availabilityPool<E extends {
+    id: string;
+    created: string;
+}>(entries: () => ReadonlyArray<E>): Array<{
+    id: string;
+    created: string;
+}> | null;
+export declare function detectRecallHints({ list, pool, anchorRing, queryHash }: HintInputs): RecallHints;
+//# sourceMappingURL=render.d.ts.map

package/dist/api/recall/render.js

@@ -0,0 +1,60 @@
+// Recall text pieces the CLI and MCP presenters share, so the budget loop, cutoff wording and hints cannot drift apart.
+import { estimateTokens } from '../../util/token-text.js';
+import { detectAnchoring, biasHintEnabled, snapshotRing, } from './finish.js';
+import { detectAvailabilityBias } from '../availability.js';
+/** A token allowance that sections pay from in print order; one that does not fit is refused whole. */
+export function tokenPurse(allowance) {
+    let left = allowance;
+    return {
+        pays(tokens) {
+            if (tokens > left)
+                return false;
+            left -= tokens;
+            return true;
+        },
+        left: () => left,
+    };
+}
+/** Renders `count` rows, then drops the lowest-ranked one until the text fits `budget` or only `floor` rows remain. */
+export function shrinkToFit(count, floor, budget, render, textOf) {
+    let kept = count;
+    let rendered = render(kept);
+    // The hints, cutoff and heading vary with the list, so the whole text is re-measured after each drop.
+    while (kept > floor && estimateTokens(textOf(rendered)) > budget) {
+        kept--;
+        rendered = render(kept);
+    }
+    return rendered;
+}
+/** The clause strings of the cutoff text; each surface frames them in its own line or section. */
+export function cutoffClauses(s) {
+    const clauses = [];
+    // The residual covers rank, budget and limit drops alike, and fires with no --limit at all.
+    if (s.droppedByBudget > 0)
+        clauses.push(`${s.droppedByBudget} not shown (rank, budget or limit)`);
+    if (s.droppedPreRank > 0)
+        clauses.push(`${s.droppedPreRank} filtered pre-rank`);
+    if (s.summarySubstitutionsAdded > 0)
+        clauses.push(`${s.summarySubstitutionsAdded} summary substitutions added`);
+    if (s.freshTailAdded > 0)
+        clauses.push(`${s.freshTailAdded} fresh-tail added`);
+    if (s.suppressedByInterference > 0)
+        clauses.push(`${s.suppressedByInterference} suppressed by interference`);
+    return clauses;
+}
+export function suppressionSummary(counts, anchoring) {
+    // A query_repeat is a re-ask, not competition.
+    return { ...counts, suppressedByInterference: anchoring?.reason === 'memory_dominance' ? 1 : 0 };
+}
+/** Availability needs a pool only when its env switch is on, so callers skip building one otherwise. */
+export function availabilityPool(entries) {
+    return biasHintEnabled('availability') ? entries().map((e) => ({ id: e.id, created: e.created })) : null;
+}
+export function detectRecallHints({ list, pool, anchorRing, queryHash }) {
+    const anchoring = anchorRing ? detectAnchoring(snapshotRing(anchorRing), queryHash, list[0]?.entry.id ?? null) : null;
+    const availability = pool
+        ? detectAvailabilityBias({ topK: list.map((r) => ({ id: r.entry.id, created: r.entry.created })), pool })
+        : null;
+    return { anchoring, availability };
+}
+//# sourceMappingURL=render.js.map

package/dist/api/{recall-request.d.ts → recall/request.d.ts}

@@ -1,7 +1,8 @@
-import { BadRequestError } from '../core/api-errors.js';
-import { type JsonValue } from '../util/json.js';
-import type { ContextOpts } from './context-types.js';
-import type { RecallOpts } from './recall-types.js';
+import { BadRequestError } from '../../core/api-errors.js';
+import { type JsonValue } from '../../util/json.js';
+import type { ContextOpts } from '../context-types.js';
+import { type StoreContext } from '../types.js';
+import type { CliCoreRanker, RecallOpts, RecallResult } from './types.js';
 /** A recall or context input the caller must fix; MCP answers it with an isError result, HTTP with a 400. */
 export declare class RecallRequestError extends BadRequestError {
     constructor(message: string);
@@ -28,5 +29,6 @@ export type ParsedContextRequest = Pick<ContextOpts, 'q' | 'budget' | 'limit' |
 /** Checks in a fixed order, so the first bad input is the one reported. */
 export declare function parseRecallRequest(params: RequestParams): ParsedRecallRequest;
 export declare function parseContextRequest(params: RequestParams): ParsedContextRequest;
+export declare function retrieveWithCliCore(ctx: StoreContext, opts: RecallOpts, core: CliCoreRanker): Promise<RecallResult>;
 export {};
-//# sourceMappingURL=recall-request.d.ts.map
+//# sourceMappingURL=request.d.ts.map