hippo-memory 1.72.0 → 2.0.0

package/dist/api/recall.js

@@ -5,9 +5,8 @@ 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 { storeFor } from '../store/sqlite/store.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';
@@ -64,23 +63,28 @@ function shownBand(opts, result) {
 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' ? loadConfig(ctx.hippoRoot).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) {
@@ -112,8 +116,8 @@ async function retrieveFromStore(ctx, opts, windowSize, show, own) {
     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);
+    const searchOpts = { budget: Infinity, vectorCandidates: recallVectorSpec(ctx, opts, own) };
+    let ranked = await searchByEngine({ root: ctx.hippoRoot, store }, opts.query, pool, physicsFor(ctx, opts), 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 = [];
@@ -125,27 +129,26 @@ async function retrieveFromStore(ctx, opts, windowSize, show, own) {
     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 });
     // Rows the vector arm added count as candidates too.
     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);
     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({
+    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 })),
+    };
+    await finishBandRecall(store, ctx, opts, {
         goalLog: [...rankedLog, ...writes.goalLog],
-        audit: [...(opts.leadingAudit ?? []), ...writes.audit, shownRow, ...shown.audit],
-        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),
-    });
+        audit: [...writes.audit, shownRow, ...shown.audit],
+        trace,
+    }, shown.ids);
     return result;
 }
 /** Contract preflight: throws before any store-touching work. */

package/dist/api/remember-local.d.ts

@@ -1,4 +1,5 @@
 import type { ConfidenceLevel, Layer, MemoryEntry, MemoryKind } from '../core/memory.js';
+import { type EmbedOutcome } from '../search/embed-memories.js';
 import type { HippoDbContext } from './types.js';
 /** One write by a caller in this process, every field already parsed and checked by it. */
 export interface LocalRememberInput {
@@ -23,10 +24,12 @@ export interface StartedWeak {
     readonly reason: string;
     readonly strength: number;
 }
-/** `stored` carries the row as the store holds it after the write; `skipped` is the gate dropping the write, with nothing stored or counted. */
+/** `stored` carries the row as the store holds it after the write, and `embedding`, which settles with whether the row reached the vector index
+ *  (a caller may ignore it; a failure is also logged). `skipped` is the gate dropping the write, with nothing stored or counted. */
 export type LocalRememberOutcome = {
     readonly status: 'stored';
     readonly entry: MemoryEntry;
+    readonly embedding: Promise<EmbedOutcome>;
     readonly startedWeak?: StartedWeak;
 } | {
     readonly status: 'skipped';
@@ -34,7 +37,7 @@ export type LocalRememberOutcome = {
     readonly score: number;
 };
 /** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A refused value throws as `remember` does. */
-export declare function rememberLocally(ctx: HippoDbContext, input: LocalRememberInput): LocalRememberOutcome;
+export declare function rememberLocally(ctx: HippoDbContext, input: LocalRememberInput): Promise<LocalRememberOutcome>;
 /** What a caller asks of fact extraction. The key comes from the caller, which read it from its own environment. */
 export interface FactExtractionRequest {
     /** The caller asked for extraction (`--extract`); the store's config can turn it on without that. */

package/dist/api/remember-local.js

@@ -7,7 +7,7 @@ import { loadNewestEntries, schemaFitInStore } from '../store/candidates.js';
 import { embedMemory } from '../search/embed-memories.js';
 import { loadAllEntries, readEntry } from '../store/entry-reads.js';
 import { updateStats } from '../store/index-and-stats.js';
-import { errorMessage } from '../util/log.js';
+import { errorMessage, log } from '../util/log.js';
 import { remember } from './remember.js';
 const WEAK_HALF_LIFE_FACTOR = 0.5;
 /** The gate's verdict on one write, or null where it does not judge: the store has it off, or the write is pinned or forced. */
@@ -34,14 +34,23 @@ function storedEntry(ctx, id) {
         throw new Error(`memory ${id} was written but cannot be read back`);
     return entry;
 }
+/** Best-effort and slow (a model load or a network call), so the caller is not held for it; a row left out of the index is logged. */
+function indexInBackground(hippoRoot, entry) {
+    return embedMemory(hippoRoot, entry).then((outcome) => {
+        if (outcome === 'failed') {
+            log.warn(`memory ${entry.id} is stored but not in the vector index, so recall by meaning will miss it; run 'hippo embed' to index it`);
+        }
+        return outcome;
+    });
+}
 /** One local write on hippo.db: gate, write, read-back, counter, then the embedding, started and never awaited. A refused value throws as `remember` does. */
-export function rememberLocally(ctx, input) {
+export async function rememberLocally(ctx, input) {
     const schemaFit = schemaFitInStore(ctx.hippoRoot, ctx.tenantId, input.content, input.fitTags ?? input.tags);
     const verdict = salienceVerdict(ctx, input);
     if (verdict?.decision === 'skip')
         return { status: 'skipped', reason: verdict.reason, score: verdict.score };
     const startedWeak = verdict?.decision === 'start_weak' ? { reason: verdict.reason, strength: verdict.score } : undefined;
-    const { id } = remember(ctx, {
+    const { id } = await remember(ctx, {
         content: input.content,
         kind: input.kind,
         scope: input.scope,
@@ -59,9 +68,8 @@ export function rememberLocally(ctx, input) {
     });
     const entry = storedEntry(ctx, id);
     updateStats(ctx.hippoRoot, { remembered: 1 });
-    // Best-effort and slow (a model load or a network call), so the caller is not held for it.
-    void embedMemory(ctx.hippoRoot, entry);
-    return startedWeak ? { status: 'stored', entry, startedWeak } : { status: 'stored', entry };
+    const embedding = indexInBackground(ctx.hippoRoot, entry);
+    return startedWeak ? { status: 'stored', entry, embedding, startedWeak } : { status: 'stored', entry, embedding };
 }
 /** Extracts facts from a row just stored and stores them beside it. Best-effort: a failure is named in the result, never thrown. */
 export async function extractRememberedFacts(ctx, entry, request) {

package/dist/api/remember.d.ts

@@ -1,6 +1,6 @@
 import type { ConnectorEvent } from '../store/port.js';
 import { type ConfidenceLevel, type Layer, type MemoryKind, type TraceOutcome } from '../core/memory.js';
-import type { Context, StoreReply } from './types.js';
+import type { Context } from './types.js';
 /** Row fields the caller's own process decides, as the CLI does from its flags and its salience gate. */
 export interface RememberLocal {
     layer?: Layer;
@@ -42,6 +42,9 @@ export interface RememberResult {
     id: string;
     kind: MemoryKind;
     tenantId: string;
+    /** The row as written, so a caller can show it without reading it back. */
+    halfLifeDays: number;
+    tags: string[];
     /** Set only when untrusted content was flagged and quarantined instead of stored under its requested scope. */
     quarantined?: {
         reason: string;
@@ -55,5 +58,5 @@ export interface RememberResult {
 }
 /** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
  *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
-export declare function remember<C extends Context>(ctx: C, opts: RememberOpts): StoreReply<C, RememberResult>;
+export declare function remember(ctx: Context, opts: RememberOpts): Promise<RememberResult>;
 //# sourceMappingURL=remember.d.ts.map

package/dist/api/remember.js

@@ -8,7 +8,8 @@ import { vetSecrets } from '../util/secret-detect.js';
 import { assertCallerProject } from '../core/project-identity.js';
 import { BadRequestError } from '../core/api-errors.js';
 import { assertClientScope, personalScopeOf } from '../core/recall-scope.js';
-import { andThen, notPorted, onStore } from './on-store.js';
+import { requireGroup } from '../store/index.js';
+import { storeFor } from '../store/sqlite/store.js';
 /** The scope a write lands in: the caller's own personal scope when asked for, else the client's, which may not be a personal one. */
 function rememberScope(ctx, opts) {
     if (!opts.personal) {
@@ -60,7 +61,7 @@ function weakened(entry, weaken) {
 }
 function rememberResult(ctx, prepared, written) {
     const { entry, detection, warnings } = prepared;
-    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId };
+    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId, halfLifeDays: entry.half_life_days, tags: [...entry.tags] };
     if (detection.flagged)
         result.quarantined = { reason: detection.reason ?? 'unknown' };
     if (warnings.length > 0)
@@ -75,17 +76,18 @@ function quarantineOf({ requestedScope, detection }) {
 }
 /** Store one memory: the store's entryWrites group writes the row and its one remember audit row, under the caller's subject.
  *  A write that carries a connector event or untrusted content goes through connectorWrites, which commits its companion rows with it. */
-export function remember(ctx, opts) {
-    return onStore(ctx, (port) => {
-        const entryWrites = port.entryWrites ?? notPorted(port, 'entryWrites');
-        const prepared = prepareRemember(ctx, opts);
-        // A store writes origin_project as given, so the served folder's fallback is stamped here.
-        const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
-        if (opts.untrusted !== true && opts.event === undefined)
-            return andThen(entryWrites.writeEntry(write), () => rememberResult(ctx, prepared));
-        const connectorWrites = port.connectorWrites ?? notPorted(port, 'connectorWrites');
-        const written = connectorWrites.writeConnectorEntry({ ...write, event: opts.event, quarantine: quarantineOf(prepared) });
-        return andThen(written, (outcome) => rememberResult(ctx, prepared, outcome));
-    });
+export async function remember(ctx, opts) {
+    const store = storeFor(ctx);
+    const entryWrites = requireGroup(store, 'entryWrites');
+    const prepared = prepareRemember(ctx, opts);
+    // A store writes origin_project as given, so the served folder's fallback is stamped here.
+    const write = { entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject };
+    if (opts.untrusted !== true && opts.event === undefined) {
+        await entryWrites.writeEntry(write);
+        return rememberResult(ctx, prepared);
+    }
+    const connectorWrites = requireGroup(store, 'connectorWrites');
+    const written = await connectorWrites.writeConnectorEntry({ ...write, event: opts.event, quarantine: quarantineOf(prepared) });
+    return rememberResult(ctx, prepared, written);
 }
 //# sourceMappingURL=remember.js.map

package/dist/api/session-end.d.ts

@@ -19,4 +19,28 @@ export declare function closeEndedSession(ctx: Context, close: SessionClose): vo
 export declare function bookSessionRereads(ctx: Context, transcriptPath: string | undefined, sessionId: string | null): Promise<string[]>;
 /** The block a compaction lost: the fresh task snapshot and its session trail, or null with none or another session's snapshot. */
 export declare function compactResumeBlock(ctx: Context, payloadSessionId: string | null): string | null;
+/** What one session-end run needs from its host; the host owns sleep, transcript reading and capture, this module owns the order. */
+export interface SessionEndWork<Scan> {
+    mode: 'turn' | 'full';
+    hippoRoot: string;
+    tenantId: string;
+    sessionId: string | null;
+    transcriptPath: string | undefined;
+    /** Builds the call context for one store root. */
+    contextFor: (root: string) => Context;
+    /** The store the run captures into: the project store, else global. */
+    storeRoot: () => string;
+    /** One line to the session-end log; `startFresh` restarts the file. */
+    log: (line: string, opts?: {
+        startFresh?: boolean;
+    }) => void;
+    sleep: () => Promise<void>;
+    readScan: (log: (line: string) => void) => Scan | null;
+    capture: (store: string, scan: Scan | null) => void;
+    digest: (scan: Scan | null, log: (line: string) => void) => void;
+    workingState: (log: (line: string) => void) => ReturnType<SessionClose['workingState']>;
+    evidence: () => HandoffEvidence;
+}
+/** Books re-reads, sleeps, captures, digests and closes one ended session, in that order. */
+export declare function sessionEndWork<Scan>(w: SessionEndWork<Scan>): Promise<void>;
 //# sourceMappingURL=session-end.d.ts.map

package/dist/api/session-end.js

@@ -29,7 +29,7 @@ function writeEndHandoff(ctx, sessionId, close) {
             close.log('skip: no snapshot or transcript for session');
             return;
         }
-        const handoff = writeSessionEndHandoff(ctx.hippoRoot, ctx.tenantId, sessionId, close.evidence(), derived, undefined, { inPlace: close.turn });
+        const handoff = writeSessionEndHandoff(ctx.hippoRoot, { tenantId: ctx.tenantId, sessionId, evidence: close.evidence(), derived, inPlace: close.turn });
         close.log(handoff ? `wrote handoff for session ${sessionId}` : `skip: kept the existing handoff for session ${sessionId}`);
     }
     catch (err) {
@@ -98,4 +98,34 @@ export function compactResumeBlock(ctx, payloadSessionId) {
     }
     return compactResumeText(snapshot, events);
 }
+/** Books re-reads, sleeps, captures, digests and closes one ended session, in that order. */
+export async function sessionEndWork(w) {
+    const rereadLog = await bookSessionRereads(w.contextFor(w.hippoRoot), w.transcriptPath, w.sessionId)
+        .catch((err) => [`re-read count failed: ${errorMessage(err)}`]);
+    // Sleep starts the log file afresh, so the lines go in after it; on exit too, in case sleep exits the process.
+    const flushRereadLog = () => { for (const line of rereadLog.splice(0))
+        w.log(line); };
+    process.once('exit', flushRereadLog);
+    // A folder with neither a project nor a global store must not get one made.
+    const store = w.storeRoot();
+    if (!isInitialized(store)) {
+        w.log('skip: no hippo store for this folder or globally', { startFresh: true });
+        flushRereadLog();
+        return;
+    }
+    await w.sleep();
+    flushRereadLog();
+    const scan = w.readScan((line) => w.log(line));
+    w.capture(store, scan);
+    w.digest(scan, (line) => w.log(line));
+    // Only this session's snapshot, and only after sleep and capture.
+    const closeLog = (line) => w.log(line);
+    closeEndedSession(w.contextFor(store), {
+        sessionId: w.sessionId,
+        turn: w.mode === 'turn',
+        workingState: () => (w.transcriptPath ? w.workingState(closeLog) : null),
+        evidence: w.evidence,
+        log: closeLog,
+    });
+}
 //# sourceMappingURL=session-end.js.map

package/dist/api/sleep-run.js

@@ -52,7 +52,8 @@ async function runSleepPhases(ctx, opts, phases, counts) {
     const consolidateResult = await phases.consolidate(ctx.hippoRoot, { dryRun });
     counts.consolidation = consolidateResult.semanticCreated + consolidateResult.merged;
     const result = sleepResultFrom(consolidateResult, dryRun);
-    // One read after consolidation serves dedup, the audit and ambient: dedup reports every row it deletes, so later phases subtract instead of reading again.
+    // Consolidate's own read predates its writes, so it cannot stand in for this one.
+    // One read after consolidation serves dedup, the audit and ambient: dedup reports every row it deletes, so later phases subtract.
     const loaded = { entries: phases.loadAllEntries(ctx.hippoRoot), backing: memoriesBackingObjects(ctx.hippoRoot) };
     // Phase 2: Dedup (post-consolidate near-duplicate cleanup).
     const dedupResult = phases.deduplicateStore(ctx.hippoRoot, { dryRun, actor: ctx.actor.subject, loaded });
@@ -60,7 +61,7 @@ async function runSleepPhases(ctx, opts, phases, counts) {
     if (dedupResult.removed > 0)
         result.deduped = dedupSummary(dedupResult);
     // Phase 3: Quality audit (remove junk, report warnings; a dry run skips rows earlier phases would remove).
-    const audited = runQualityAudit(ctx, phases, { dryRun, consolidateResult, dedupResult, result, loaded });
+    const audited = await runQualityAudit(ctx, phases, { dryRun, consolidateResult, dedupResult, result, loaded });
     counts.auditDeleted = audited.removed;
     if (dryRun)
         return result;
@@ -117,7 +118,7 @@ function dedupSummary(dedupResult) {
     };
 }
 /** `removed` counts audit errors deleted (or that would be under dryRun); `remaining` is what the audit read, less the rows it deleted. */
-function runQualityAudit(ctx, phases, options) {
+async function runQualityAudit(ctx, phases, options) {
     const { dryRun, consolidateResult, dedupResult, result, loaded } = options;
     // The load followed consolidation, so only a dry run still holds the rows consolidation would remove; dedup's pairs are gone or would be.
     const planned = new Set([...(dryRun ? consolidateResult.removedIds ?? [] : []), ...dedupResult.pairs.map((p) => p.removed)]);
@@ -127,7 +128,7 @@ function runQualityAudit(ctx, phases, options) {
         return { removed: 0, remaining: allEntries };
     const errors = auditOut.issues.filter((i) => i.severity === 'error');
     const warnings = auditOut.issues.filter((i) => i.severity === 'warning');
-    const gone = dryRun ? errors.map((issue) => issue.memoryId) : removeAuditErrors(ctx, 'sleep-audit', errors);
+    const gone = dryRun ? errors.map((issue) => issue.memoryId) : await removeAuditErrors(ctx, 'sleep-audit', errors);
     const removed = gone.length;
     const deleted = new Set(gone);
     if (removed > 0 || warnings.length > 0) {

package/dist/api/sleep.js

@@ -1,10 +1,11 @@
 // The sleep cycle: decay, consolidation, dedupe, graph extraction and the other maintenance passes.
 import { runSleep } from './sleep-run.js';
+import { requireGroup } from '../store/index.js';
+import { storeFor } from '../store/sqlite/store.js';
 /** Sleeps the WHOLE hippoRoot, every tenant, so /v1/sleep stays loopback-only; SQLite only; never auto-deletes pinned, raw, kept or object-backing rows. */
 export async function sleep(ctx, opts = {}) {
-    if (ctx.store && ctx.store.kind !== 'sqlite') {
-        throw new Error(`sleep supports only the sqlite store, not '${ctx.store.kind}'`);
-    }
+    // Sleep reopens hippo.db by folder, here and in its child process.
+    requireGroup(storeFor(ctx), 'localFiles');
     return runSleep(ctx, opts);
 }
 //# sourceMappingURL=sleep.js.map

package/dist/api/tokens.js

@@ -1,6 +1,6 @@
 // Token-use and failure reports.
 import { rethrowIfSqliteBlocked } from '../util/sqlite-blocked.js';
-import { storeFor } from '../store/index.js';
+import { storeFor } from '../store/sqlite/store.js';
 import { failureLogSummary, tokenUseSummary } from '../store/usage-reports.js';
 import { errorMessage, log } from '../util/log.js';
 import { DAY_MS } from '../util/time.js';

package/dist/api/types.d.ts

@@ -10,7 +10,7 @@ export interface Actor {
     scopes?: readonly string[];
     /** An auth resolver vouched for this caller, so its admin role stops at its own tenant. */
     viaAuthResolver?: true;
-    /** The host's operator (CLI, stdio MCP, keyless loopback, host-tenant admin key): may act beyond its tenant. */
+    /** The host's operator (CLI, stdio MCP, keyless loopback set to admin, host-tenant admin key): may act beyond its tenant. */
     hostAdmin?: true;
     owner?: string;
 }
@@ -23,12 +23,6 @@ export interface Context {
 export type HippoDbContext = Context & {
     store?: undefined;
 };
-export type StoreReply<C extends Context, R> = C extends {
-    readonly store: HippoStore;
-} ? Promise<R> : C extends {
-    readonly hippoRoot: string;
-    readonly store?: undefined;
-} ? R : R | Promise<R>;
 /** Builds process-local Actor values (admin and host admin) for CLI and CLI-run connector Contexts; Bearer-authed callers build Actor from the api_keys row
  * instead. */
 export declare function adminActor(subject: string): Actor;

package/dist/capture/command.js

@@ -164,7 +164,7 @@ export function captureExtractedItems(targetRoot, options, extracted, keys) {
                 continue;
             }
             const entry = captureEntry(item, options, baseHalfLifeDays);
-            if (wouldReject(entry.tenantId ?? 'default', entry.id, entry.content)) {
+            if (wouldReject(entry.tenant_id ?? 'default', entry.id, entry.content)) {
                 console.log(`  [reject] (${item.category}) ${item.content.slice(0, 80)} - matches a rejected value`);
                 tally.rejected++;
                 continue;

package/dist/capture/compaction-spool.d.ts

@@ -22,8 +22,6 @@ export interface SpoolFs {
         flag?: 'wx';
     }): void;
 }
-/** Test-only seam, so a test can make one fs call fail; null restores the real fs. */
-export declare function _setSpoolFsForTests(next: SpoolFs | null): void;
 export interface SpooledCompaction {
     tenantId: string;
     payload: PostCompactPayload;
@@ -32,7 +30,7 @@ export interface SpooledCompaction {
 }
 /** Records one spooled compaction; it calls `recorded` once the store holds the summary, so the file is done even if a later step throws. */
 export type SpoolImporter = (spooled: SpooledCompaction, recorded: () => void) => void;
-export declare function spool(hippoRoot: string, tenantId: string, payload: PostCompactPayload, text: CompactionText, at: Date): void;
+export declare function spool(hippoRoot: string, tenantId: string, payload: PostCompactPayload, text: CompactionText, at: Date, fsx?: SpoolFs): void;
 /** null when the text is not a spooled compaction. */
 export declare function parseSpooled(text: string, fallbackTenantId: string): SpooledCompaction | null;
 export interface SpoolCounts {
@@ -41,7 +39,7 @@ export interface SpoolCounts {
     bad: number;
 }
 /** What doctor reports, read only: files a replay should have taken by now, claims and tmp files a dead process left, and `.bad` files. */
-export declare function spoolCounts(hippoRoot: string, now: Date, waitingAfterMs: number): SpoolCounts;
+export declare function spoolCounts(hippoRoot: string, now: Date, waitingAfterMs: number, fsx?: SpoolFs): SpoolCounts;
 /** One replayer at a time holds `replay.lock`, so only one process claims a file even where Windows lets two renames of it both land. */
-export declare function importSpool(hippoRoot: string, tenantId: string, log: Log, deadline: number, importOne: SpoolImporter): number;
+export declare function importSpool(hippoRoot: string, tenantId: string, log: Log, deadline: number, importOne: SpoolImporter, fsx?: SpoolFs): number;
 //# sourceMappingURL=compaction-spool.d.ts.map