hippo-memory 1.71.0 → 2.0.0

package/dist/api/auto-sleep.d.ts

@@ -1,5 +1,7 @@
 import type { HippoConfig } from '../core/config.js';
 export declare const autoSleepInFlight: Set<string>;
+/** Runs one auto-sleep consolidation of `hippoRoot`: the HTTP server passes one that runs it off its event loop, in a child process. */
+export type AutoSleepRunner = (hippoRoot: string) => Promise<void>;
 export interface AutoSleepDue {
     enabled: boolean;
     count: number;
@@ -8,6 +10,7 @@ export interface AutoSleepDue {
 }
 /** Counts only when enabled: the count opens the store. */
 export declare function autoSleepDue(hippoRoot: string, tenantId: string, config: HippoConfig['autoSleep']): AutoSleepDue;
-/** One run per store at a time; `allowed` is the caller's own gate. Consolidation is host-wide, so only the host tenant may start it. */
-export declare function startAutoSleepIfDue(hippoRoot: string, tenantId: string, config: HippoConfig['autoSleep'], allowed: boolean): void;
+/** One run per store at a time; `allowed` is the caller's own gate. Consolidation is host-wide, so only the host tenant may start it.
+ * Without `run`, it runs in process. */
+export declare function startAutoSleepIfDue(hippoRoot: string, tenantId: string, config: HippoConfig['autoSleep'], allowed: boolean, run?: AutoSleepRunner): void;
 //# sourceMappingURL=auto-sleep.d.ts.map

package/dist/api/auto-sleep.js

@@ -11,8 +11,9 @@ export function autoSleepDue(hippoRoot, tenantId, config) {
     const count = enabled ? countCreatedSinceLastSleep(hippoRoot, tenantId) : 0;
     return { enabled, count, threshold, due: enabled && count >= threshold };
 }
-/** One run per store at a time; `allowed` is the caller's own gate. Consolidation is host-wide, so only the host tenant may start it. */
-export function startAutoSleepIfDue(hippoRoot, tenantId, config, allowed) {
+/** One run per store at a time; `allowed` is the caller's own gate. Consolidation is host-wide, so only the host tenant may start it.
+ * Without `run`, it runs in process. */
+export function startAutoSleepIfDue(hippoRoot, tenantId, config, allowed, run) {
     if (!allowed ||
         !config.enabled ||
         tenantId !== resolveTenantId({}) ||
@@ -23,7 +24,10 @@ export function startAutoSleepIfDue(hippoRoot, tenantId, config, allowed) {
     // Fire-and-forget (never block the response); an unhandled rejection would kill the server, so log it.
     // Its own scope: the call's closes a handle the sleep still holds across its pauses, but the caller's lock wait carries over.
     const busyWaitMs = scopedBusyWait();
-    outsideRequestStores(() => runWithRequestStores(() => consolidate(hippoRoot), { busyWaitMs }))
+    const started = run
+        ? run(hippoRoot)
+        : outsideRequestStores(() => runWithRequestStores(() => consolidate(hippoRoot), { busyWaitMs }));
+    started
         .catch((err) => {
         log.error(`auto-sleep consolidate failed (tenant ${tenantId}): ${errorMessage(err)}`, errorFields(err));
     })

package/dist/api/availability.js

@@ -1,10 +1,9 @@
-import { DAY_MS } from '../util/time.js';
+import { DAY_MS, HOUR_MS } from '../util/time.js';
 export const DEFAULT_RECENCY_WINDOW_MS = DAY_MS;
 export const DEFAULT_RECENT_FRACTION_THRESHOLD = 0.7;
 export const DEFAULT_MIN_RETURNED = 3;
 export const DEFAULT_MIN_POOL = 10;
 export const DEFAULT_MIN_OLDER_PASSED_OVER = 3;
-const MS_PER_HOUR = 60 * 60 * 1000;
 function median(nums) {
     if (nums.length === 0)
         return 0;
@@ -43,7 +42,7 @@ export function detectAvailabilityBias(opts) {
     if (olderCandidatesPassedOver < minOlderPassedOver)
         return null;
     const pct = Math.round(recentFraction * 100);
-    const windowHours = Math.round(recencyWindowMs / MS_PER_HOUR);
+    const windowHours = Math.round(recencyWindowMs / HOUR_MS);
     const summary = `Availability bias risk: ${recentCount} of ${topK.length} returned results are from the ` +
         `last ${windowHours}h (${pct}%), but ${olderCandidatesPassedOver} older matched memories ` +
         `were passed over. Returned median age ${topKMedianAgeDays.toFixed(1)}d vs pool median ` +

package/dist/api/cards.d.ts

@@ -0,0 +1,42 @@
+import type { Card, CardComment, CardRun, CardStatus } from '../core/card.js';
+import type { HandoffOutcome } from '../core/handoff.js';
+import { type CardDetail } from '../store/card-detail.js';
+import type { Context } from './types.js';
+/** Create a card in the caller's tenant. Throws on an empty title or an unknown dependency. */
+export declare function cardCreate(ctx: Context, input: {
+    title: string;
+    repo?: string;
+    contract?: string;
+    budget?: number;
+    dependsOn?: string[];
+}): Card;
+/** One card by id, or null when the caller's tenant has none. */
+export declare function cardLoad(ctx: Context, id: string): Card | null;
+/** The card with its dependencies, runs, comments and latest handoff, or null when unknown. */
+export declare function cardDetail(ctx: Context, id: string): CardDetail | null;
+/** The caller's cards, newest-updated first, optionally filtered to one status. */
+export declare function cardList(ctx: Context, opts?: {
+    status?: CardStatus;
+}): Card[];
+/** Every run of a card, newest first. */
+export declare function cardRuns(ctx: Context, id: string): CardRun[];
+/** Claim a ready or blocked card for a runtime; null when it cannot be claimed. */
+export declare function cardClaim(ctx: Context, id: string, runtime: string, sessionId?: string): (Card & {
+    runId: number;
+}) | null;
+/** Extend a live run's lease; null when the run is not live. */
+export declare function cardHeartbeat(ctx: Context, id: string, runId: number): Card | null;
+/** Block a running card with a reason; null when it is not running. */
+export declare function cardBlock(ctx: Context, id: string, reason: string, runId?: number): Card | null;
+/** Move a running card to review; null when it is not running. */
+export declare function cardReview(ctx: Context, id: string, runId?: number): Card | null;
+/** Complete a card in review and promote the children it unblocks; null when not in review. */
+export declare function cardComplete(ctx: Context, id: string, outcome: HandoffOutcome, runId?: number): {
+    card: Card;
+    promotedChildren: string[];
+} | null;
+/** Return every card with an expired lease to ready; yields the reclaimed ids. */
+export declare function cardReclaimExpired(ctx: Context): string[];
+/** Add a comment to a card. Throws on an empty body. */
+export declare function cardComment(ctx: Context, cardId: string, author: string, body: string): CardComment;
+//# sourceMappingURL=cards.d.ts.map

package/dist/api/cards.js

@@ -0,0 +1,52 @@
+// The agent work board: create, claim, review and complete cards, scoped to the caller's tenant.
+import { addCardComment, blockCard, claimCard, completeCard, createCard, heartbeatCard, listCards, loadCard, loadCardRuns, reclaimExpiredCards, reviewCard, } from '../store/cards.js';
+import { loadCardDetail } from '../store/card-detail.js';
+/** Create a card in the caller's tenant. Throws on an empty title or an unknown dependency. */
+export function cardCreate(ctx, input) {
+    return createCard(ctx.hippoRoot, ctx.tenantId, input);
+}
+/** One card by id, or null when the caller's tenant has none. */
+export function cardLoad(ctx, id) {
+    return loadCard(ctx.hippoRoot, ctx.tenantId, id);
+}
+/** The card with its dependencies, runs, comments and latest handoff, or null when unknown. */
+export function cardDetail(ctx, id) {
+    return loadCardDetail(ctx.hippoRoot, ctx.tenantId, id);
+}
+/** The caller's cards, newest-updated first, optionally filtered to one status. */
+export function cardList(ctx, opts = {}) {
+    return listCards(ctx.hippoRoot, ctx.tenantId, opts);
+}
+/** Every run of a card, newest first. */
+export function cardRuns(ctx, id) {
+    return loadCardRuns(ctx.hippoRoot, ctx.tenantId, id);
+}
+/** Claim a ready or blocked card for a runtime; null when it cannot be claimed. */
+export function cardClaim(ctx, id, runtime, sessionId) {
+    return claimCard(ctx.hippoRoot, ctx.tenantId, id, runtime, sessionId);
+}
+/** Extend a live run's lease; null when the run is not live. */
+export function cardHeartbeat(ctx, id, runId) {
+    return heartbeatCard(ctx.hippoRoot, ctx.tenantId, id, runId);
+}
+/** Block a running card with a reason; null when it is not running. */
+export function cardBlock(ctx, id, reason, runId) {
+    return blockCard(ctx.hippoRoot, ctx.tenantId, id, reason, runId);
+}
+/** Move a running card to review; null when it is not running. */
+export function cardReview(ctx, id, runId) {
+    return reviewCard(ctx.hippoRoot, ctx.tenantId, id, runId);
+}
+/** Complete a card in review and promote the children it unblocks; null when not in review. */
+export function cardComplete(ctx, id, outcome, runId) {
+    return completeCard(ctx.hippoRoot, ctx.tenantId, id, outcome, runId);
+}
+/** Return every card with an expired lease to ready; yields the reclaimed ids. */
+export function cardReclaimExpired(ctx) {
+    return reclaimExpiredCards(ctx.hippoRoot, ctx.tenantId);
+}
+/** Add a comment to a card. Throws on an empty body. */
+export function cardComment(ctx, cardId, author, body) {
+    return addCardComment(ctx.hippoRoot, ctx.tenantId, cardId, author, body);
+}
+//# sourceMappingURL=cards.js.map

package/dist/api/conflicts.d.ts

@@ -0,0 +1,28 @@
+import type { MemoryConflict } from '../store/rows.js';
+import type { CallerProject } from './prompt-hook.js';
+import { type Context } from './types.js';
+import type { TenantReach } from './memories.js';
+export interface ResolveMemoryConflictOpts {
+    /** One of the conflict's two memories; the other is the loser. */
+    keepId: string;
+    /** Delete the loser instead of halving its half-life. */
+    forget?: boolean;
+    /** Tombstone the loser's value as well, which removes it whatever `forget` says. */
+    rejectLoser?: boolean;
+    /** Kept on the tombstone; a conflict-context reason when unset. */
+    reason?: string;
+}
+export interface ResolveMemoryConflictResult {
+    conflictId: number;
+    keptId: string;
+    loserId: string;
+}
+/** Keeps `keepId` and weakens, deletes or rejects the other side of an open conflict in the caller's tenant, auditing as `ctx.actor`.
+ *  NotFound: missing, untouchable or no longer live. Conflict: already resolved. BadRequest: `keepId` outside the pair. */
+export declare function resolveMemoryConflict(ctx: Context, conflictId: number, opts: ResolveMemoryConflictOpts): ResolveMemoryConflictResult;
+/** Open conflicts whose two rows the caller may touch; with `project`, only pairs it could also recall:
+ *  its repo or user-global, and no scope it was not asked for. */
+export declare function listOpenConflicts(ctx: Context, project?: CallerProject): MemoryConflict[];
+/** Conflicts with `status` ('*' for any) in reach, with no scope filter: the host's own view, so the host admin only. */
+export declare function listConflicts(ctx: Context, status: string, reach?: TenantReach): MemoryConflict[];
+//# sourceMappingURL=conflicts.d.ts.map

package/dist/api/conflicts.js

@@ -0,0 +1,61 @@
+// Conflict resolution for every front end, so the reach, status, pair and liveness checks live in one place.
+// SHORTCUT: hippo.db only, since the store port has no conflict calls; a conflicts group when a served store needs them.
+import { BadRequestError, ConflictError, NotFoundError } from '../core/api-errors.js';
+import { listMemoryConflicts, listTouchableConflicts, resolveConflict } from '../store/conflicts.js';
+import { loadEntriesByIds } from '../store/entry-reads.js';
+import { chunked } from '../util/chunked.js';
+import { passesScopeFilterForRecall, personalScopeOf } from '../core/recall-scope.js';
+import { classifyOriginProject } from '../core/project-identity.js';
+import { isQuarantineScope } from '../trust/quarantine.js';
+import { requireHostAdmin } from './types.js';
+function isLive(entry) {
+    return !entry.superseded_by && (entry.kind === 'raw' || entry.kind === 'distilled') && !isQuarantineScope(entry.scope);
+}
+/** Keeps `keepId` and weakens, deletes or rejects the other side of an open conflict in the caller's tenant, auditing as `ctx.actor`.
+ *  NotFound: missing, untouchable or no longer live. Conflict: already resolved. BadRequest: `keepId` outside the pair. */
+export function resolveMemoryConflict(ctx, conflictId, opts) {
+    // Read with every status, so a resolved conflict answers 409 while one holding another person's personal row stays a 404.
+    const conflict = listTouchableConflicts(ctx.hippoRoot, '*', ctx.tenantId, ctx.actor).find((c) => c.id === conflictId);
+    if (!conflict)
+        throw new NotFoundError(`conflict not found: ${conflictId}`);
+    if (conflict.status !== 'open')
+        throw new ConflictError(`conflict ${conflictId} is already resolved`);
+    const pair = [conflict.memory_a_id, conflict.memory_b_id];
+    if (!pair.includes(opts.keepId))
+        throw new BadRequestError(`keep must be one of the two memories in conflict ${conflictId}: ${pair.join(', ')}`);
+    if (loadEntriesByIds(ctx.hippoRoot, pair, ctx.tenantId).filter(isLive).length < pair.length) {
+        throw new NotFoundError(`conflict ${conflictId} names a memory that is superseded, archived or quarantined`);
+    }
+    const resolved = resolveConflict(ctx.hippoRoot, { conflictId, keepId: opts.keepId, forgetLoser: opts.forget === true, tenantId: ctx.tenantId }, {
+        rejectLoserValue: opts.rejectLoser === true,
+        reason: opts.reason,
+        rejectedBy: ctx.actor.subject,
+    });
+    // Every check passed above, so null here is another resolver getting there first.
+    if (resolved === null)
+        throw new ConflictError(`conflict ${conflictId} is already resolved`);
+    return { conflictId, keptId: opts.keepId, loserId: resolved.loserId };
+}
+/** Open conflicts whose two rows the caller may touch; with `project`, only pairs it could also recall:
+ *  its repo or user-global, and no scope it was not asked for. */
+export function listOpenConflicts(ctx, project) {
+    const touchable = listTouchableConflicts(ctx.hippoRoot, 'open', ctx.tenantId, ctx.actor);
+    if (!project)
+        return touchable;
+    const own = personalScopeOf(ctx.actor);
+    const ids = [...new Set(touchable.flatMap((c) => [c.memory_a_id, c.memory_b_id]))];
+    // loadEntriesByIds reads at most one chunk of ids per call.
+    const rows = new Map(chunked(ids).flatMap((chunk) => loadEntriesByIds(ctx.hippoRoot, chunk, ctx.tenantId)).map((row) => [row.id, row]));
+    const shown = (id) => {
+        const row = rows.get(id);
+        return row !== undefined && classifyOriginProject(row.origin_project, project) !== 'cross-project'
+            && passesScopeFilterForRecall(row.scope ?? null, undefined, own);
+    };
+    return touchable.filter((c) => shown(c.memory_a_id) && shown(c.memory_b_id));
+}
+/** Conflicts with `status` ('*' for any) in reach, with no scope filter: the host's own view, so the host admin only. */
+export function listConflicts(ctx, status, reach = {}) {
+    requireHostAdmin(ctx, 'Listing conflicts past the scope check');
+    return listMemoryConflicts(ctx.hippoRoot, status, reach.everyTenant ? undefined : ctx.tenantId);
+}
+//# sourceMappingURL=conflicts.js.map

package/dist/api/context-auto.js

@@ -1,4 +1,5 @@
 import { execFileSync } from 'child_process';
+import { errorFields, log } from '../util/log.js';
 const MAX_DIFF_TERMS = 10;
 const SKIPPED_PATH_TERMS = ['src', 'dist', 'test', 'tests', 'node_modules', 'index'];
 // stderr is dropped because git's warnings (line-ending notices, for one) would otherwise become query terms.
@@ -23,8 +24,9 @@ export function autoDetectContext() {
             return branch.replace(/[-_/]/g, ' ');
         }
     }
-    catch {
-        // Not a git repo or git missing: no query, so the caller lists by strength.
+    catch (err) {
+        // Not a git repo, git missing or a timeout: no query, so the caller lists by strength.
+        log.debug('auto context: no git-derived query', errorFields(err));
     }
     return '';
 }

package/dist/api/context-render.js

@@ -1,6 +1,7 @@
 // The strings a context block prints. The budget prices these same strings, so selection and print cannot drift.
+import { MINUTE_MS } from '../util/time.js';
 import { calculateStrength, confidenceFacets, confidenceLabel } from '../core/memory.js';
-import { evalNow } from '../core/ablation.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import { estimateTokens } from '../util/token-text.js';
 import { renderAmbientSummary } from '../core/ambient.js';
 import { formatHandoffEvidenceLine } from '../core/handoff.js';
@@ -56,7 +57,7 @@ export function sessionTrailText(events) {
 // Each trail event is capped only in the compact-resume block, so other trail prints keep full content.
 export const COMPACT_RESUME_EVENT_CONTENT_CAP = 400;
 // A snapshot older than this was not written for this compaction (pre-compact skipped), so restoring it is stale, not a resume.
-export const COMPACT_RESUME_MAX_AGE_MS = 15 * 60_000;
+export const COMPACT_RESUME_MAX_AGE_MS = 15 * MINUTE_MS;
 /** The block compact-resume hands the model; events arrive already capped. */
 export function compactResumeText(snapshot, events) {
     return [
@@ -71,7 +72,7 @@ export function compactResumeText(snapshot, events) {
 export function contextHeading(heading, entries, tokens) {
     return `## ${heading} (${entries} entries, ${tokens} tokens)\n`;
 }
-export function contextLine(item, framing, showStrength, now, strengthPct = Math.round(calculateStrength(item.entry) * 100)) {
+export function contextLine(item, framing, showStrength, now, strengthPct = Math.round(calculateStrength(item.entry, undefined, { ablation: strengthAblation() }) * 100)) {
     const e = item.entry;
     const tagStr = e.tags.length > 0 ? ` [${e.tags.join(', ')}]` : '';
     const strengthStr = showStrength ? ` (${strengthPct}%)` : '';

package/dist/api/context-select.js

@@ -5,19 +5,18 @@ import { calculateStrength } from '../core/memory.js';
 import { auditQueryFields, recordAuditEvent } from '../store/audit.js';
 import { isWorthSurfacing } from '../core/memory-quality.js';
 import { rankBothStores } from '../sharing/search-both.js';
-import { evalNow } from '../core/ablation.js';
-import { hybridSearch } from '../search/hybrid.js';
-import { physicsSearch } from '../search/physics-search.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
+import { searchByEngine } from '../search/engine.js';
 import { DEFAULT_LOCAL_BUMP } from '../core/search-types.js';
 import { compareScoredResults } from '../core/compare.js';
-import { scopeMatch } from '../sharing/scope.js';
+import { scopeMatch } from '../core/active-scope.js';
 import { scopeBoostFor } from '../search/boosts.js';
 import { promptTokens, contentTokens, gatePromptRecall, } from '../core/prompt-recall.js';
 const GLOBAL_DISCOUNT = 1 / DEFAULT_LOCAL_BUMP;
 // Share and promote copy a memory to the global store under a new id, so equal content is the only link.
 // A pinned copy wins, then the stronger one after the ranking's own global discount; a tie keeps the local copy.
 export function oneCopyPerMemory(local, global, now) {
-    const score = (e, isGlobal) => calculateStrength(e, now) * (isGlobal ? GLOBAL_DISCOUNT : 1);
+    const score = (e, isGlobal) => calculateStrength(e, now, { ablation: strengthAblation() }) * (isGlobal ? GLOBAL_DISCOUNT : 1);
     const best = new Map();
     const offer = (entry, isGlobal) => {
         const held = best.get(entry.content);
@@ -77,7 +76,7 @@ function rankPinned(plan, pinnedLocal, pinnedGlobal, nowP) {
         const scopeBoost = scopeBoostFor(scopeMatch(entry.tags, plan.activeScope));
         return {
             entry,
-            score: calculateStrength(entry, nowP) * (isGlobal ? GLOBAL_DISCOUNT : 1) * scopeBoost,
+            score: calculateStrength(entry, nowP, { ablation: strengthAblation() }) * (isGlobal ? GLOBAL_DISCOUNT : 1) * scopeBoost,
             tokens: plan.price(entry, isGlobal),
             isGlobal,
         };
@@ -200,7 +199,7 @@ function backfillRecent(plan, options) {
         .slice(0, plan.includeRecent)
         .map(({ entry, isGlobal }) => ({
         entry,
-        score: calculateStrength(entry, nowP) * (isGlobal ? GLOBAL_DISCOUNT : 1),
+        score: calculateStrength(entry, nowP, { ablation: strengthAblation() }) * (isGlobal ? GLOBAL_DISCOUNT : 1),
         tokens: plan.price(entry, isGlobal),
         isGlobal,
     }));
@@ -213,7 +212,7 @@ export function selectStrongest(plan, left, pools) {
     const localRanked = localPool
         .map((e) => ({
         entry: e,
-        score: calculateStrength(e, now),
+        score: calculateStrength(e, now, { ablation: strengthAblation() }),
         tokens: plan.price(e, plan.primaryIsGlobal),
         isGlobal: plan.primaryIsGlobal,
     }))
@@ -221,7 +220,7 @@ export function selectStrongest(plan, left, pools) {
     const globalRanked = globalPool
         .map((e) => ({
         entry: e,
-        score: calculateStrength(e, now) * GLOBAL_DISCOUNT,
+        score: calculateStrength(e, now, { ablation: strengthAblation() }) * GLOBAL_DISCOUNT,
         tokens: plan.price(e, true),
         isGlobal: true,
     }))
@@ -279,26 +278,13 @@ async function searchLocalRows(ctx, plan, options) {
     const localCost = cost && ((r) => price(r.entry, primaryIsGlobal));
     const vectorCandidates = contextVectorSpec(ctx, plan, admit);
     const store = plan.local.store;
-    const ctxResults = usePhysicsCtx
-        ? await physicsSearch(query, localEntries, {
-            budget: left,
-            minResults,
-            cost: localCost,
-            hippoRoot: ctx.hippoRoot,
-            physicsConfig: ctxConfig.physics,
-            scope: plan.activeScope,
-            vectorCandidates,
-            store,
-        })
-        : await hybridSearch(query, localEntries, {
-            budget: left,
-            minResults,
-            cost: localCost,
-            hippoRoot: ctx.hippoRoot,
-            scope: plan.activeScope,
-            vectorCandidates,
-            store,
-        });
+    const ctxResults = await searchByEngine({ root: ctx.hippoRoot, store }, query, localEntries, usePhysicsCtx ? ctxConfig.physics : null, {
+        budget: left,
+        minResults,
+        cost: localCost,
+        scope: plan.activeScope,
+        vectorCandidates,
+    });
     return ctxResults.map((r) => ({
         entry: r.entry,
         score: r.score,

package/dist/api/context.js

@@ -1,26 +1,25 @@
 // Ambient context injection: the admission policy and getContext.
-import { isInitialized } from '../store/open.js';
 import { DEFAULT_SEARCH_CANDIDATE_LIMIT } from '../store/rows.js';
 import { freshActiveSnapshot, SNAPSHOT_AMBIENT_MAX_AGE_MS } from '../store/sessions.js';
 import { estimateTokens } from '../util/token-text.js';
 import { markRetrieved, COMPACTION_MEMORY_TAG } from '../core/memory.js';
 import { isWorthSurfacing } from '../core/memory-quality.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
-import { evalNow } from '../core/ablation.js';
+import { evalNow, strengthAblation } from '../core/ablation.js';
 import { dropHeldCopies } from '../util/same-text.js';
 import { BadRequestError } from '../core/api-errors.js';
 import { isSharedStore, loadConfig } from '../core/config.js';
-import { rethrowIfSqliteBlocked } from '../db/index.js';
+import { rethrowIfSqliteBlocked } from '../util/sqlite-blocked.js';
 import { errorMessage, log } from '../util/log.js';
-import { resolveProjectIdentity, classifyOriginProject, isGlobalStoreRoot, projectId, projectNames } from '../core/project-identity.js';
+import { resolveProjectIdentity, classifyOriginProject, isGlobalStoreRoot, isInitialized, projectId, projectNames, } from '../core/project-identity.js';
 import { promptTokens } from '../core/prompt-recall.js';
 import { detectSecret } from '../util/secret-detect.js';
 import { isSessionDigestRow } from '../core/session-digest-row.js';
 import { addAmbientTallies, ambientStateFromTallies } from '../core/ambient.js';
-import { requireGroup, sqliteStore, storeFor } from '../store/index.js';
-import { passesScopeFilterForRecall, assertScopeRequestAllowed, personalScopeOf } from '../store/recall-scope.js';
+import { hasGroup, requireGroup, sqliteStore } from '../store/index.js';
+import { storeFor } from '../store/sqlite/store.js';
+import { passesScopeFilterForRecall, assertScopeRequestAllowed, personalScopeOf } from '../core/recall-scope.js';
 import { finiteOr, selectBySearch, selectPinned, selectStrongest, } from './context-select.js';
-import { andThen, onStore } from './on-store.js';
 import { strengthenOf } from './recall-record.js';
 import { ownerOrSubject } from './types.js';
 export { oneCopyPerMemory } from './context-select.js';
@@ -55,7 +54,7 @@ function sourceOf(store) {
 // The pinned-only branch needs pins and recent-N candidates, not the corpus.
 async function loadAmbientEntries(source, tenantId, options) {
     const { pinnedOnly, recent, admit, recheck, window, recall, onQualityDrop } = options;
-    const ownTenant = (e) => e.tenantId === tenantId;
+    const ownTenant = (e) => e.tenant_id === tenantId;
     if (!pinnedOnly) {
         const rows = 'query' in window
             ? await source.store.searchRecallEntries(window.query, {
@@ -140,7 +139,7 @@ function warnIsolationIgnored(hippoRoot) {
 }
 /** Which stores this read can draw on, and what kind the primary one is. */
 function storesInReach(ctx, opts, local) {
-    const other = local.store.kind !== 'sqlite' ? local.store : undefined;
+    const other = hasGroup(local.store, 'localFiles') ? undefined : local.store;
     // Global memories do not establish a project boundary for task state.
     const hasLocal = other !== undefined || isInitialized(ctx.hippoRoot);
     const globalRoot = getGlobalRoot();
@@ -222,7 +221,11 @@ function openBlockBudget(plan, opts, budget) {
     if (!pinnedOnly)
         obs?.queried(plan.query);
     return cost
-        ? Math.max(0, blockBudget - cost.fixed(blockBudget, { cross: plan.includeCrossProject, promptRecall: promptRecallPending, ambient: !pinnedOnly && config.ambient.enabled }))
+        ? Math.max(0, blockBudget - cost.fixed(blockBudget, {
+            cross: plan.includeCrossProject,
+            promptRecall: promptRecallPending,
+            ambient: !pinnedOnly && config.ambient.enabled,
+        }))
         : blockBudget;
 }
 const NO_TASK_STATE = { snapshot: null, handoff: null, events: [] };
@@ -360,7 +363,7 @@ async function traceEmptyContext(ctx, opts, plan) {
     };
     // The empty reply is already decided, so a lost trace is logged and the call still answers.
     try {
-        await onStore(ctx, (port) => port.finishRecall({ goalLog: [], audit: [], trace }));
+        await storeFor(ctx).finishRecall({ goalLog: [], audit: [], trace });
     }
     catch (error) {
         rethrowIfSqliteBlocked(error);
@@ -370,7 +373,7 @@ async function traceEmptyContext(ctx, opts, plan) {
 /** Strengthens and marks the returned rows, then writes the trace and index together. */
 async function recordRetrieval(ctx, opts, plan, selected, activeSnapshot) {
     const toUpdate = selected.map((s) => s.entry);
-    const updatedEntries = markRetrieved(toUpdate);
+    const updatedEntries = markRetrieved(toUpdate, undefined, { ablation: strengthAblation() });
     const retrievedIds = updatedEntries.map((u) => u.id);
     const trace = {
         tenantId: ctx.tenantId,
@@ -384,11 +387,13 @@ async function recordRetrieval(ctx, opts, plan, selected, activeSnapshot) {
         })),
     };
     const writes = { goalLog: [], audit: [], trace, strengthen: strengthenOf(ctx, retrievedIds) };
-    // hippo.db keeps the ids as its last recall, which feeds only outcomeForLastRecall, and it alone reads a second root.
-    await onStore(ctx, (port, local) => andThen(local.finishLastRecall(writes, plan.hasGlobal ? plan.globalRoot : undefined), (traceId) => {
-        plan.obs?.traced(traceId);
-        return port.bumpRecallStats(selected.length);
-    }));
+    // The last recall feeds only outcomeForLastRecall, so a store that keeps none still finishes the recall without one.
+    const store = storeFor(ctx);
+    const traceId = store.lastRecall
+        ? await store.lastRecall.finishRecall(writes, plan.hasGlobal ? plan.globalRoot : undefined)
+        : await store.finishRecall(writes).then(() => null);
+    plan.obs?.traced(traceId);
+    await store.bumpRecallStats(selected.length);
     // Replace selectedItems entries with markRetrieved-updated copies so
     // the returned ContextResult reflects post-recall state.
     const items = selected.map((s) => ({
@@ -399,7 +404,13 @@ async function recordRetrieval(ctx, opts, plan, selected, activeSnapshot) {
     return { items, ambientState: plan.config.ambient.enabled ? await readAmbientState(ctx, plan) : undefined };
 }
 async function readAmbientState(ctx, plan) {
-    const filter = { exactScope: plan.exactScope, ownScope: plan.ownScope, project: plan.originProject, currentProject: projectNames(plan.currentProject), now: evalNow() };
+    const filter = {
+        exactScope: plan.exactScope,
+        ownScope: plan.ownScope,
+        project: plan.originProject,
+        currentProject: projectNames(plan.currentProject),
+        now: evalNow(),
+    };
     const sources = [
         ...(plan.hasLocal ? [plan.local.reads] : []),
         ...(plan.hasGlobal && !plan.primaryIsGlobal ? [sourceOf(sqliteStore(plan.globalRoot)).reads] : []),

package/dist/api/continuity.d.ts

@@ -0,0 +1,47 @@
+import type { HandoffOutcome, SessionHandoff } from '../core/handoff.js';
+import type { SessionEvent, TaskSnapshot } from '../store/rows.js';
+import { appendSessionEvent, listSessionEvents, saveActiveTaskSnapshot } from '../store/sessions.js';
+import { wmClear, wmFlush, wmPush, wmRead, type WorkingMemoryItem } from '../store/working-memory.js';
+import type { Context } from './types.js';
+/** What a snapshot save carries. */
+export type SnapshotSaveInput = Parameters<typeof saveActiveTaskSnapshot>[2];
+/** What a session event append carries. */
+export type SessionEventAppendInput = Parameters<typeof appendSessionEvent>[2];
+/** What a session event listing filters on. */
+export type SessionEventListOpts = NonNullable<Parameters<typeof listSessionEvents>[2]>;
+/** Save the caller's active task snapshot. */
+export declare function snapshotSave(ctx: Context, input: SnapshotSaveInput): TaskSnapshot;
+/** Clear the caller's active task snapshot; false when there was none. */
+export declare function snapshotClear(ctx: Context, status: string): boolean;
+/** The caller's active task snapshot, or null. */
+export declare function snapshotLoad(ctx: Context): TaskSnapshot | null;
+/** Append a session event in the caller's tenant. */
+export declare function sessionEventAppend(ctx: Context, event: SessionEventAppendInput): SessionEvent;
+/** List the caller's session events. */
+export declare function sessionEventList(ctx: Context, opts: SessionEventListOpts): SessionEvent[];
+export interface LatestContinuity {
+    snapshot: TaskSnapshot | null;
+    events: SessionEvent[];
+}
+/** The active snapshot plus recent events for `sessionId`, falling back to the snapshot's own session. */
+export declare function continuityLatest(ctx: Context, opts: {
+    sessionId?: string;
+    limit: number;
+}): LatestContinuity;
+/** Stamp the outcome on the caller's handoff for `sessionId`; returns the rows stamped. */
+export declare function handoffStampOutcome(ctx: Context, sessionId: string, outcome: HandoffOutcome): number;
+/** Save a session handoff in the caller's tenant. */
+export declare function handoffSave(ctx: Context, handoff: Omit<SessionHandoff, 'updatedAt'>): SessionHandoff;
+/** The caller's latest handoff, optionally for one session. */
+export declare function handoffLatest(ctx: Context, sessionId?: string): SessionHandoff | null;
+/** The caller's handoff by id, or null. */
+export declare function handoffById(ctx: Context, id: number): SessionHandoff | null;
+/** Push a working memory entry in the caller's tenant; returns its row id. */
+export declare function workingMemoryPush(ctx: Context, opts: Omit<Parameters<typeof wmPush>[1], 'tenantId'>): number;
+/** The caller's working memory entries, most important first. */
+export declare function workingMemoryRead(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmRead>[1]>, 'tenantId'>): WorkingMemoryItem[];
+/** Delete the caller's working memory entries; returns the count. */
+export declare function workingMemoryClear(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmClear>[1]>, 'tenantId'>): number;
+/** Flush the caller's working memory at session end; returns the count. */
+export declare function workingMemoryFlush(ctx: Context, opts: Omit<NonNullable<Parameters<typeof wmFlush>[1]>, 'tenantId'>): number;
+//# sourceMappingURL=continuity.d.ts.map

package/dist/api/continuity.js

@@ -0,0 +1,66 @@
+// Where-you-left-off ops: task snapshot, session events, handoffs and working memory.
+import { appendSessionEvent, clearActiveTaskSnapshot, listSessionEvents, loadActiveTaskSnapshot, saveActiveTaskSnapshot, } from '../store/sessions.js';
+import { loadHandoffById, loadLatestHandoff, saveSessionHandoff, stampHandoffOutcome } from '../store/handoffs.js';
+import { wmClear, wmFlush, wmPush, wmRead } from '../store/working-memory.js';
+/** Save the caller's active task snapshot. */
+export function snapshotSave(ctx, input) {
+    return saveActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, input);
+}
+/** Clear the caller's active task snapshot; false when there was none. */
+export function snapshotClear(ctx, status) {
+    return clearActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, status);
+}
+/** The caller's active task snapshot, or null. */
+export function snapshotLoad(ctx) {
+    return loadActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId);
+}
+/** Append a session event in the caller's tenant. */
+export function sessionEventAppend(ctx, event) {
+    return appendSessionEvent(ctx.hippoRoot, ctx.tenantId, event);
+}
+/** List the caller's session events. */
+export function sessionEventList(ctx, opts) {
+    return listSessionEvents(ctx.hippoRoot, ctx.tenantId, opts);
+}
+/** The active snapshot plus recent events for `sessionId`, falling back to the snapshot's own session. */
+export function continuityLatest(ctx, opts) {
+    const snapshot = loadActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId);
+    const events = listSessionEvents(ctx.hippoRoot, ctx.tenantId, {
+        session_id: opts.sessionId || snapshot?.session_id || undefined,
+        limit: opts.limit,
+    });
+    return { snapshot, events };
+}
+/** Stamp the outcome on the caller's handoff for `sessionId`; returns the rows stamped. */
+export function handoffStampOutcome(ctx, sessionId, outcome) {
+    return stampHandoffOutcome(ctx.hippoRoot, ctx.tenantId, sessionId, outcome);
+}
+/** Save a session handoff in the caller's tenant. */
+export function handoffSave(ctx, handoff) {
+    return saveSessionHandoff(ctx.hippoRoot, ctx.tenantId, handoff);
+}
+/** The caller's latest handoff, optionally for one session. */
+export function handoffLatest(ctx, sessionId) {
+    return loadLatestHandoff(ctx.hippoRoot, ctx.tenantId, sessionId);
+}
+/** The caller's handoff by id, or null. */
+export function handoffById(ctx, id) {
+    return loadHandoffById(ctx.hippoRoot, ctx.tenantId, id);
+}
+/** Push a working memory entry in the caller's tenant; returns its row id. */
+export function workingMemoryPush(ctx, opts) {
+    return wmPush(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+}
+/** The caller's working memory entries, most important first. */
+export function workingMemoryRead(ctx, opts) {
+    return wmRead(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+}
+/** Delete the caller's working memory entries; returns the count. */
+export function workingMemoryClear(ctx, opts) {
+    return wmClear(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+}
+/** Flush the caller's working memory at session end; returns the count. */
+export function workingMemoryFlush(ctx, opts) {
+    return wmFlush(ctx.hippoRoot, { ...opts, tenantId: ctx.tenantId });
+}
+//# sourceMappingURL=continuity.js.map