hippo-memory 1.72.0 → 2.1.0

package/dist/store/sqlite/reports-group.js

@@ -0,0 +1,33 @@
+// hippo.db's Reports group: the tenant reports and listings the status verbs print.
+import { withReadSnapshot } from '../../db/index.js';
+import { strengthTalliesAt } from '../candidates.js';
+import { countOpenConflictsAt } from '../conflicts.js';
+import { countAllEntries, loadEntriesPage } from '../entry-reads.js';
+import { onHandle, openStore } from '../open.js';
+import { failureLogSummary, tokenUseSummary } from '../usage-reports.js';
+export function sqliteReports(hippoRoot) {
+    return {
+        tokenUse: (tenantId, sinceIso) => tokenUseSummary(hippoRoot, tenantId, sinceIso),
+        failures: (tenantId, sinceIso) => failureLogSummary(hippoRoot, tenantId, sinceIso),
+        memoryStatus(tenantId, now, atRiskBelow) {
+            // One snapshot, so the tallies and the conflict count never straddle another process's write.
+            return onHandle(hippoRoot, (db) => withReadSnapshot(db, () => ({
+                ...strengthTalliesAt(db, tenantId, now, atRiskBelow),
+                openConflicts: countOpenConflictsAt(db, tenantId),
+            })), openStore);
+        },
+        entriesPage: (tenantId, page) => loadEntriesPage(hippoRoot, tenantId ?? undefined, page),
+        countEntries: () => countAllEntries(hippoRoot),
+    };
+}
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export function servedReports(sync) {
+    return {
+        tokenUse: async (tenantId, sinceIso) => sync.tokenUse(tenantId, sinceIso),
+        failures: async (tenantId, sinceIso) => sync.failures(tenantId, sinceIso),
+        memoryStatus: async (tenantId, now, atRiskBelow) => sync.memoryStatus(tenantId, now, atRiskBelow),
+        entriesPage: async (tenantId, page) => sync.entriesPage(tenantId, page),
+        countEntries: async () => sync.countEntries(),
+    };
+}
+//# sourceMappingURL=reports-group.js.map

package/dist/store/sqlite/request-scope.d.ts

@@ -0,0 +1,6 @@
+export type RequestPreset = 'cli' | 'hook' | 'server';
+/** Runs `fn` with one store handle per store, closed with it, at the root's lock wait. */
+export declare function runSqliteRequest<T>(fn: () => T | Promise<T>, preset: RequestPreset): Promise<T>;
+/** A scope of its own: the caller closes a handle the work holds across its pauses; the lock wait carries over. */
+export declare function runDetachedSqliteRequest<T>(fn: () => T | Promise<T>): Promise<T>;
+//# sourceMappingURL=request-scope.d.ts.map

package/dist/store/sqlite/request-scope.js

@@ -0,0 +1,18 @@
+// The request-scope plumbing the composition roots (cli, server, stdio MCP) run their requests in.
+import { HOOK_DB_WAIT_MS, outsideRequestStores, runWithRequestStores, scopedBusyWait, SERVER_DB_WAIT_MS, } from '../../db/index.js';
+/** Lock wait per root; a hook also skips later writes once one wait runs out, so it never stalls its host. */
+const PRESETS = {
+    cli: {},
+    hook: { busyWaitMs: HOOK_DB_WAIT_MS, failFastWhenBusy: true },
+    server: { busyWaitMs: SERVER_DB_WAIT_MS },
+};
+/** Runs `fn` with one store handle per store, closed with it, at the root's lock wait. */
+export function runSqliteRequest(fn, preset) {
+    return runWithRequestStores(fn, PRESETS[preset]);
+}
+/** A scope of its own: the caller closes a handle the work holds across its pauses; the lock wait carries over. */
+export function runDetachedSqliteRequest(fn) {
+    const busyWaitMs = scopedBusyWait();
+    return outsideRequestStores(() => runWithRequestStores(fn, { busyWaitMs }));
+}
+//# sourceMappingURL=request-scope.js.map

package/dist/store/sqlite/sessions-group.d.ts

@@ -0,0 +1,6 @@
+import type { Sessions } from '../port-groups.js';
+import type { Sync } from '../port.js';
+export declare function sqliteSessions(hippoRoot: string): Sync<Sessions>;
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export declare function servedSessions(sync: Sync<Sessions>): Sessions;
+//# sourceMappingURL=sessions-group.d.ts.map

package/dist/store/sqlite/sessions-group.js

@@ -0,0 +1,46 @@
+// hippo.db's Sessions group: snapshots, session events, handoffs, working memory and session-owner binding.
+import { loadHandoffById, loadLatestHandoff, saveSessionHandoff, stampHandoffOutcome, writeSessionEndHandoff, } from '../handoffs.js';
+import { appendSessionEvent, clearActiveTaskSnapshot, closeTaskSnapshotsForSession, listSessionEvents, loadActiveTaskSnapshot, loadFreshActiveTaskSnapshot, saveActiveTaskSnapshot, sessionOwnerOrBind, } from '../sessions.js';
+import { wmClear, wmPush, wmRead } from '../working-memory.js';
+export function sqliteSessions(hippoRoot) {
+    return {
+        saveSnapshot: (tenantId, snapshot, key) => saveActiveTaskSnapshot(hippoRoot, tenantId, snapshot, key ?? undefined),
+        loadSnapshot: (tenantId, key) => loadActiveTaskSnapshot(hippoRoot, tenantId, key ?? undefined),
+        loadFreshSnapshot: (tenantId, opts, key) => loadFreshActiveTaskSnapshot(hippoRoot, tenantId, opts, key ?? undefined),
+        clearSnapshot: (tenantId, clearedStatus) => clearActiveTaskSnapshot(hippoRoot, tenantId, clearedStatus),
+        closeSessionSnapshots: (tenantId, sessionId, status, key) => closeTaskSnapshotsForSession(hippoRoot, tenantId, sessionId, status, key ?? undefined),
+        appendEvent: (tenantId, event) => appendSessionEvent(hippoRoot, tenantId, event),
+        listEvents: (tenantId, { sessionId, task, limit }) => listSessionEvents(hippoRoot, tenantId, { session_id: sessionId, task, limit }),
+        saveHandoff: (tenantId, handoff, key) => saveSessionHandoff(hippoRoot, tenantId, handoff, key ?? undefined),
+        latestHandoff: (tenantId, sessionId, filter, key) => loadLatestHandoff(hippoRoot, tenantId, sessionId ?? undefined, filter, key ?? undefined),
+        handoffById: (tenantId, id) => loadHandoffById(hippoRoot, tenantId, id),
+        stampHandoffOutcome: (tenantId, sessionId, outcome) => stampHandoffOutcome(hippoRoot, tenantId, sessionId, outcome),
+        writeSessionEndHandoff: (tenantId, request) => writeSessionEndHandoff(hippoRoot, { ...request, tenantId }),
+        pushWorkingMemory: (tenantId, item) => wmPush(hippoRoot, { ...item, tenantId }),
+        readWorkingMemory: (tenantId, filter) => wmRead(hippoRoot, { ...filter, tenantId }),
+        clearWorkingMemory: (tenantId, filter) => wmClear(hippoRoot, { ...filter, tenantId }),
+        bindSessionOwner: (tenantId, sessionId, owner, retentionMs) => sessionOwnerOrBind(hippoRoot, { tenantId, sessionId, owner, retentionMs }),
+    };
+}
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export function servedSessions(sync) {
+    return {
+        saveSnapshot: async (tenantId, snapshot, key) => sync.saveSnapshot(tenantId, snapshot, key),
+        loadSnapshot: async (tenantId, key) => sync.loadSnapshot(tenantId, key),
+        loadFreshSnapshot: async (tenantId, opts, key) => sync.loadFreshSnapshot(tenantId, opts, key),
+        clearSnapshot: async (tenantId, clearedStatus) => sync.clearSnapshot(tenantId, clearedStatus),
+        closeSessionSnapshots: async (tenantId, sessionId, status, key) => sync.closeSessionSnapshots(tenantId, sessionId, status, key),
+        appendEvent: async (tenantId, event) => sync.appendEvent(tenantId, event),
+        listEvents: async (tenantId, opts) => sync.listEvents(tenantId, opts),
+        saveHandoff: async (tenantId, handoff, key) => sync.saveHandoff(tenantId, handoff, key),
+        latestHandoff: async (tenantId, sessionId, filter, key) => sync.latestHandoff(tenantId, sessionId, filter, key),
+        handoffById: async (tenantId, id) => sync.handoffById(tenantId, id),
+        stampHandoffOutcome: async (tenantId, sessionId, outcome) => sync.stampHandoffOutcome(tenantId, sessionId, outcome),
+        writeSessionEndHandoff: async (tenantId, request) => sync.writeSessionEndHandoff(tenantId, request),
+        pushWorkingMemory: async (tenantId, item) => sync.pushWorkingMemory(tenantId, item),
+        readWorkingMemory: async (tenantId, filter) => sync.readWorkingMemory(tenantId, filter),
+        clearWorkingMemory: async (tenantId, filter) => sync.clearWorkingMemory(tenantId, filter),
+        bindSessionOwner: async (tenantId, sessionId, owner, retentionMs) => sync.bindSessionOwner(tenantId, sessionId, owner, retentionMs),
+    };
+}
+//# sourceMappingURL=sessions-group.js.map

package/dist/store/sqlite/store.d.ts

@@ -1,23 +1,27 @@
-import type { HippoStore, RecallWrites, StoreGroups, Sync } from '../port.js';
-/** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
-export declare function storeFor(ctx: {
+import { type StoreWith } from '../narrow.js';
+import { type HippoStore, type StoreGroup, type StoreGroups, type StoreReach, type Sync } from '../port.js';
+/** `ctx` with its store filled (the one it carries, else hippo.db under its root) and its groups proven,
+ * so a public entry given a store without them still answers 501. */
+export declare function withStoreGroups<C extends {
     readonly hippoRoot: string;
     readonly store?: HippoStore;
-}): HippoStore;
-/** Not on the synchronous store: the nearest-row scan yields to the event loop, so this group answers only through Promises. */
+}, G extends StoreGroup>(ctx: C, ...groups: readonly [G, ...G[]]): C & {
+    readonly store: StoreWith<G>;
+};
+/** Not on the synchronous store: the nearest-row scan yields to
+ * the event loop, so this group answers only through Promises. */
 type AsyncOnly = 'vectors';
-/** The port as hippo.db answers it: each call runs to its end and returns the value, so no write scope spans an await. */
-export type SqliteSyncStore = Sync<Omit<HippoStore, AsyncOnly>>;
-/** The built-in store: hippo.db under the port's own method names, each call on its own short-lived handles, so close has nothing to release. */
-export declare function sqliteSyncStore(hippoRoot: string): SqliteSyncStore & Sync<Omit<StoreGroups, AsyncOnly>>;
-/** `sqliteSyncStore` as a served store: each method runs at once and answers through a Promise, so a throw rejects as another store's would. */
+/** The port as hippo.db answers it: each call runs to its end
+ * and returns the value, so no write scope spans an await. */
+export type SqliteSyncStore = Sync<Omit<HippoStore, AsyncOnly | 'localFiles'>> & Pick<HippoStore, 'localFiles'>;
+/** The built-in store: hippo.db under the port's own method names, each call on its own short-lived handles, so close
+ * has nothing to release. */
+export declare function sqliteSyncStore(hippoRoot: string): SqliteSyncStore & Sync<Omit<StoreGroups, AsyncOnly | 'localFiles'>> & Pick<StoreGroups, 'localFiles'>;
+/** The composition roots reach the request scope through the adapter's one entry. */
+export { runDetachedSqliteRequest, runSqliteRequest } from './request-scope.js';
+/** What a call on `store` reaches, probed as the api's own context plan did (`shared` is the transport's flag). */
+export declare function sqliteReach(hippoRoot: string, store: HippoStore, shared?: boolean): StoreReach;
+/** `sqliteSyncStore` as a served store: each method runs at once and answers through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function sqliteStore(hippoRoot: string): HippoStore & StoreGroups;
-/** What a finished recall wrote after its audit rows: the trace's id, null when none was asked or its write failed, and the ids strengthened. */
-interface RecallFinish {
-    readonly traceId: number | null;
-    readonly strengthened: ReadonlySet<string>;
-}
-/** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
-export declare function finishRecallAt(hippoRoot: string, writes: RecallWrites): RecallFinish;
-export {};
 //# sourceMappingURL=store.d.ts.map

package/dist/store/sqlite/store.js

@@ -4,17 +4,27 @@ import { listApiKeyRows, readApiKeyRecord } from '../auth.js';
 import { existsSync } from 'node:fs';
 import { appendAuditEvent, listAuditEventsAfter, queryAuditEvents } from '../audit.js';
 import { getHippoDbPath, withWriteScope } from '../../db/index.js';
-import { activeGoalsWithPolicies, localGoalRecallRows, writeGoalRecallLog } from '../goals.js';
+import { activeGoalsWithPolicies } from '../goals.js';
 import { planningFallacyEvidenceAt } from '../planning-fallacy-evidence.js';
-import { writeRecallTrace } from '../recall-trace.js';
 import { recordTokenUse } from '../token-ledger.js';
 import { loadAmbientCandidates, loadContextCandidates } from '../candidates.js';
 import { loadEntriesByIds, loadFreshRawMemories } from '../entry-reads.js';
-import { strengthenRetrievedInOwnTx } from '../entry-writes.js';
+import { sqliteAgentImport } from './agent-import.js';
+import { servedCards, sqliteCards } from './cards-group.js';
+import { servedConflicts, sqliteConflicts } from './conflicts-group.js';
+import { servedDormant, sqliteDormant } from './dormant-group.js';
+import { servedGoals, sqliteGoals } from './goals-group.js';
+import { servedReports, sqliteReports } from './reports-group.js';
+import { servedSessions, sqliteSessions } from './sessions-group.js';
 import { servedConnectorEvents, sqliteConnectorEvents } from './connector-events-group.js';
 import { servedConnectorWrites, sqliteConnectorWrites } from './connector-writes-group.js';
+import { sqliteConsolidation } from './consolidation-group.js';
+import { sqliteLearning } from './learning-group.js';
+import { sqlitePromotion } from './promotion-group.js';
 import { sqliteDagReads } from './dag-reads-group.js';
 import { sqliteEntryWrites } from './entry-writes-group.js';
+import { servedAuditMaintenance, servedLessonWrites, sqliteAuditMaintenance, sqliteLessonWrites, } from './maintenance-groups.js';
+import { finishRecallAt, servedLastRecall, sqliteLastRecall } from './last-recall-group.js';
 import { servedGraphReads, sqliteGraphReads } from './graph-reads-group.js';
 import { servedObjects, sqliteObjects } from './objects-group.js';
 import { servedPredictions, sqlitePredictions } from './predictions-group.js';
@@ -22,24 +32,39 @@ import { servedQuarantine, sqliteQuarantine } from './quarantine-group.js';
 import { sqliteVectorReads } from './vector-reads-group.js';
 import { loadLatestHandoff } from '../handoffs.js';
 import { updateStats } from '../index-and-stats.js';
+import { flushStatsMirrors } from '../mirrors.js';
 import { auditHighIdAt, revokeKeyAt } from '../key-audit.js';
-import { createKeyAt, createSelfKeyAt } from '../key-writes.js';
+import { changeScopeGrantAt, createKeyAt, createSelfKeyAt } from '../key-writes.js';
 import { onHandle } from '../open.js';
-import { loadRecallSearchEntries } from '../search-rows.js';
+import { narrowStore } from '../narrow.js';
+import { hasGroup, } from '../port.js';
+import { isSharedStore } from '../../core/config.js';
+import { isGlobalStoreRoot, isInitialized, resolveGlobalRootDir } from '../../core/project-identity.js';
+import { loadRecallEntries } from '../search-rows.js';
 import { listSessionEvents, loadActiveTaskSnapshot } from '../sessions.js';
 import { entriesWithoutVectorAt, loadStoredVectorViews, writeVectorsAt } from '../vector-index.js';
-/** The store a request runs on: the served one, else hippo.db under its root, as the CLI and SDK callers have it. */
-export function storeFor(ctx) {
-    return ctx.store ?? sqliteStore(ctx.hippoRoot);
+/** `ctx` with its store filled (the one it carries, else hippo.db under its root) and its groups proven,
+ * so a public entry given a store without them still answers 501. */
+export function withStoreGroups(ctx, ...groups) {
+    return { ...ctx, store: narrowStore(ctx.store ?? sqliteStore(ctx.hippoRoot), ...groups) };
 }
-/** The built-in store: hippo.db under the port's own method names, each call on its own short-lived handles, so close has nothing to release. */
+/** The built-in store: hippo.db under the port's own method names, each call on its own short-lived handles, so close
+ * has nothing to release. */
 export function sqliteSyncStore(hippoRoot) {
     return {
         kind: 'sqlite',
+        localFiles: {
+            hippoRoot,
+            consolidation: sqliteConsolidation(hippoRoot),
+            agentImport: sqliteAgentImport,
+            promotion: sqlitePromotion(hippoRoot),
+            learning: sqliteLearning(hippoRoot),
+        },
         ...sqliteBaseReads(hippoRoot),
         ...sqliteRecallWrites(hippoRoot),
         keyAudit: sqliteKeyAudit(hippoRoot),
         keyWrites: sqliteKeyWrites(hippoRoot),
+        keyGrants: sqliteKeyGrants(hippoRoot),
         vectorViews: sqliteVectorViews(hippoRoot),
         vectorWrites: sqliteVectorWrites(hippoRoot),
         entryWrites: sqliteEntryWrites(hippoRoot),
@@ -53,7 +78,18 @@ export function sqliteSyncStore(hippoRoot) {
         connectorEvents: sqliteConnectorEvents(hippoRoot),
         objects: sqliteObjects(hippoRoot),
         readiness: sqliteReadiness(hippoRoot),
-        close() { },
+        lastRecall: sqliteLastRecall(hippoRoot),
+        auditMaintenance: sqliteAuditMaintenance(hippoRoot),
+        lessonWrites: sqliteLessonWrites(hippoRoot),
+        sessions: sqliteSessions(hippoRoot),
+        cards: sqliteCards(hippoRoot),
+        goals: sqliteGoals(hippoRoot),
+        conflicts: sqliteConflicts(hippoRoot),
+        dormant: sqliteDormant(hippoRoot),
+        reports: sqliteReports(hippoRoot),
+        close() {
+            flushStatsMirrors(hippoRoot);
+        },
     };
 }
 function sqliteBaseReads(hippoRoot) {
@@ -62,7 +98,7 @@ function sqliteBaseReads(hippoRoot) {
             return onHandle(hippoRoot, (db) => readApiKeyRecord(db, keyId));
         },
         searchRecallEntries(query, args) {
-            return loadRecallSearchEntries(hippoRoot, query, args.limit, args.tenantId, args.requestedScope, args.explicitScopeMode, args.includeSuperseded, args.originProjects, args.ownScope);
+            return loadRecallEntries(hippoRoot, query, args);
         },
         entriesByIds(ids, tenantId) {
             return loadEntriesByIds(hippoRoot, ids, tenantId);
@@ -136,11 +172,30 @@ function sqliteReadiness(hippoRoot) {
         },
     };
 }
-/** `sqliteSyncStore` as a served store: each method runs at once and answers through a Promise, so a throw rejects as another store's would. */
+/** The composition roots reach the request scope through the adapter's one entry. */
+export { runDetachedSqliteRequest, runSqliteRequest } from './request-scope.js';
+/** What a call on `store` reaches, probed as the api's own context plan did (`shared` is the transport's flag). */
+export function sqliteReach(hippoRoot, store, shared) {
+    const other = hasGroup(store, 'localFiles') ? undefined : store;
+    const sharedStore = shared === true || isSharedStore(hippoRoot);
+    const globalRoot = resolveGlobalRootDir();
+    const canReadGlobal = !sharedStore && other === undefined && isInitialized(globalRoot);
+    const reach = {
+        hasLocal: other !== undefined || isInitialized(hippoRoot),
+        isGlobal: isGlobalStoreRoot(hippoRoot),
+        shared: sharedStore,
+    };
+    if (!canReadGlobal)
+        return reach;
+    return { ...reach, global: { root: globalRoot, store: narrowStore(sqliteStore(globalRoot), 'contextReads') } };
+}
+/** `sqliteSyncStore` as a served store: each method runs at once and answers through a Promise, so a throw rejects as
+ * another store's would. */
 export function sqliteStore(hippoRoot) {
     const sync = sqliteSyncStore(hippoRoot);
     return {
         ...servedBaseMethods(sync),
+        localFiles: sync.localFiles,
         vectors: sqliteVectorReads(hippoRoot),
         vectorViews: { storedVectorViews: async (ids) => sync.vectorViews.storedVectorViews(ids) },
         ...servedKeyGroups(sync),
@@ -153,9 +208,23 @@ export function sqliteStore(hippoRoot) {
         connectorEvents: servedConnectorEvents(sync.connectorEvents),
         objects: servedObjects(sqliteObjects(hippoRoot)),
         readiness: { ping: async () => sync.readiness.ping() },
+        lastRecall: servedLastRecall(sync.lastRecall),
+        auditMaintenance: servedAuditMaintenance(sync.auditMaintenance),
+        lessonWrites: servedLessonWrites(sync.lessonWrites),
+        ...servedSessionAndAdminGroups(sync),
         close: async () => sync.close(),
     };
 }
+function servedSessionAndAdminGroups(sync) {
+    return {
+        sessions: servedSessions(sync.sessions),
+        cards: servedCards(sync.cards),
+        goals: servedGoals(sync.goals),
+        conflicts: servedConflicts(sync.conflicts),
+        dormant: servedDormant(sync.dormant),
+        reports: servedReports(sync.reports),
+    };
+}
 function servedBaseMethods(sync) {
     return {
         kind: sync.kind,
@@ -173,7 +242,7 @@ function servedBaseMethods(sync) {
     };
 }
 function servedKeyGroups(sync) {
-    const { keyAudit, keyWrites } = sync;
+    const { keyAudit, keyWrites, keyGrants } = sync;
     return {
         keyAudit: {
             revokeApiKey: async (revoke) => keyAudit.revokeApiKey(revoke),
@@ -185,6 +254,9 @@ function servedKeyGroups(sync) {
             createSelfApiKey: async (mint) => keyWrites.createSelfApiKey(mint),
             listApiKeys: async (query) => keyWrites.listApiKeys(query),
         },
+        keyGrants: {
+            changeScopeGrant: async (change) => keyGrants.changeScopeGrant(change),
+        },
     };
 }
 function servedEntryGroups(sync) {
@@ -251,6 +323,13 @@ function sqliteKeyWrites(hippoRoot) {
         },
     };
 }
+function sqliteKeyGrants(hippoRoot) {
+    return {
+        changeScopeGrant(change) {
+            onHandle(hippoRoot, (db) => changeScopeGrantAt(db, change));
+        },
+    };
+}
 function sqliteKeyAudit(hippoRoot) {
     return {
         revokeApiKey(revoke) {
@@ -271,26 +350,9 @@ function continuityAt(hippoRoot, tenantId, eventLimit, key) {
     return {
         activeSnapshot,
         sessionHandoff: sessionId ? loadLatestHandoff(hippoRoot, tenantId, sessionId, {}, key ?? undefined) : null,
-        recentSessionEvents: sessionId ? listSessionEvents(hippoRoot, tenantId, { session_id: sessionId, limit: eventLimit }) : [],
+        recentSessionEvents: sessionId
+            ? listSessionEvents(hippoRoot, tenantId, { session_id: sessionId, limit: eventLimit })
+            : [],
     };
 }
-/** sqliteStore's finishRecall, for the synchronous recall that cannot await the port. */
-export function finishRecallAt(hippoRoot, writes) {
-    return onHandle(hippoRoot, (db) => {
-        const traceAndStrengthen = () => ({
-            traceId: writes.trace ? writeRecallTrace(db, writes.trace) : null,
-            strengthened: writes.strengthen ? strengthenRetrievedInOwnTx(db, writes.strengthen.ids, writes.strengthen.opts) : new Set(),
-        });
-        // Alone, the fail-soft trace and strengthen keep their own scopes so a busy lock loses them, never the read.
-        if (writes.goalLog.length === 0 && writes.audit.length === 0)
-            return traceAndStrengthen();
-        // Inside this scope both run as savepoints, so one recall commits once and a failed trace or strengthen still unwinds alone.
-        return withWriteScope(db, 'finish_recall', () => {
-            writeGoalRecallLog(db, localGoalRecallRows(db, writes.goalLog));
-            for (const event of writes.audit)
-                appendAuditEvent(db, event);
-            return traceAndStrengthen();
-        });
-    });
-}
 //# sourceMappingURL=store.js.map

package/dist/store/sqlite/vector-pack.js

@@ -1,4 +1,5 @@
-// Vectors from a store worker as one buffer: it moves to the server thread with no copy, where a Map of typed arrays is copied value by value.
+// Vectors from a store worker as one buffer: it moves to the server thread with no copy, where a Map of typed arrays is
+// copied value by value.
 /** A pack on the thread that built it, so the reply that carries it knows which buffer to move. */
 export class PackedVectors {
     ids;

package/dist/store/sqlite/vector-reads-group.js

@@ -1,4 +1,5 @@
-// hippo.db's vector reads. Async only: the nearest-row scan yields between chunks, so a store worker awaits these where it runs every other method to its end.
+// hippo.db's vector reads. Async only: the nearest-row scan yields between chunks, so a store worker awaits these where
+// it runs every other method to its end.
 import { loadPhysicsState } from '../../db/physics-state.js';
 import { onHandle } from '../open.js';
 import { loadVectorCandidateEntries } from '../search-rows.js';

package/dist/store/sqlite/worker-jobs.d.ts

@@ -1,5 +1,6 @@
 import type { MessagePort } from 'node:worker_threads';
 import { type WorkerInit } from './worker-ops.js';
-/** Answers the thread's jobs until 'stop', which closes the connection so the thread ends with no handle on the store's files. */
+/** Answers the thread's jobs until 'stop', which closes the connection so the thread ends with no handle on the store's
+ * files. */
 export declare function serveJobs(port: MessagePort, init: WorkerInit): void;
 //# sourceMappingURL=worker-jobs.d.ts.map

package/dist/store/sqlite/worker-jobs.js

@@ -4,11 +4,12 @@ import { loadStoredVectorViews } from '../vector-index.js';
 import { requestScopes } from '../../util/request-scope.js';
 import { initStore } from '../open.js';
 import { watchCommits } from './commit-watch.js';
+import { flushStatsMirrors } from '../mirrors.js';
 import { encodeError } from './error-codec.js';
 import { sqliteSyncStore } from './store.js';
 import { PackedVectors, packVectors } from './vector-pack.js';
 import { sqliteVectorReads } from './vector-reads-group.js';
-import { STORE_SETUP_OP, WORKER_OPS } from './worker-ops.js';
+import { STORE_SETUP_OP, WORKER_OPS, } from './worker-ops.js';
 /** Every method the op table can name: the synchronous store, and the vector reads, which answer only through Promises.
  *  The two reads that return vectors answer with a pack, which worker-store.ts turns back into the port's Map. */
 function workerOps(hippoRoot) {
@@ -48,7 +49,9 @@ class WorkerStores extends RequestStores {
                 watchCommits(db, () => Atomics.store(flag, 0, this.jobId));
         }
         // The connection set its own value from this thread's state, where no checkpointer ever runs.
-        if (hippoRoot === this.#init.hippoRoot && this.walPages !== undefined && this.#walPagesOn.get(db) !== this.walPages) {
+        if (hippoRoot === this.#init.hippoRoot &&
+            this.walPages !== undefined &&
+            this.#walPagesOn.get(db) !== this.walPages) {
             db.exec(`PRAGMA wal_autocheckpoint = ${this.walPages}`);
             this.#walPagesOn.set(db, this.walPages);
         }
@@ -63,7 +66,8 @@ function runsOnWorker(group, method) {
     return Object.hasOwn(places, method) && places[method] !== 'server';
 }
 function methodsOf(ops, group) {
-    // SAFETY: every group is an object of methods, and the server thread sent the arguments the port's own signature for the one called took.
+    // SAFETY: every group is an object of methods, and the server thread sent the arguments the port's own signature for
+    // the one called took.
     return (group === 'base' ? ops : ops[group]);
 }
 /** Runs `op`; only a method the op table places on a worker can run. */
@@ -80,7 +84,7 @@ async function answer(ops, stores, hippoRoot, job) {
     stores.walPages = job.walPages;
     stores.jobId = job.id;
     try {
-        const value = await requestScopes.run(stores, () => (job.op === STORE_SETUP_OP ? initStore(hippoRoot) : runOp(ops, job.op, job.args)));
+        const value = await requestScopes.run(stores, () => job.op === STORE_SETUP_OP ? initStore(hippoRoot) : runOp(ops, job.op, job.args));
         return { id: job.id, ok: true, value, auditFailures: auditWriteFailureCount() - failuresBefore };
     }
     catch (err) {
@@ -93,18 +97,26 @@ function post(port, reply) {
     }
     catch (err) {
         // A result that cannot be copied to the server thread must still answer, or its caller would wait for ever.
-        port.postMessage({ id: reply.id, ok: false, error: encodeError(err), auditFailures: reply.auditFailures });
+        port.postMessage({
+            id: reply.id,
+            ok: false,
+            error: encodeError(err),
+            auditFailures: reply.auditFailures,
+        });
     }
 }
-/** Answers the thread's jobs until 'stop', which closes the connection so the thread ends with no handle on the store's files. */
+/** Answers the thread's jobs until 'stop', which closes the connection so the thread ends with no handle on the store's
+ * files. */
 export function serveJobs(port, init) {
     const ops = workerOps(init.hippoRoot);
     const stores = new WorkerStores(init);
-    // A thread is sent one job at a time, so only 'stop' can arrive while a vector scan yields, and it waits for that job's reply.
+    // A thread is sent one job at a time, so only 'stop' can arrive while a vector scan yields, and it waits for that
+    // job's reply.
     let last = Promise.resolve();
     port.on('message', (message) => {
         if (message === 'stop') {
             void last.then(() => {
+                flushStatsMirrors(init.hippoRoot);
                 stores.close();
                 port.close();
             });

package/dist/store/sqlite/worker-ops.d.ts

@@ -7,8 +7,9 @@ export type OpPlace = OpMode | 'server';
 export type OpPlaces<G> = {
     readonly [M in keyof G]: OpPlace;
 };
-/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit row) and bumpRecallStats
- * (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
+/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit
+ * row) and bumpRecallStats (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs
+ * that open's setup before any reader serves. */
 export declare const WORKER_OPS: {
     readonly base: {
         readonly findApiKey: "read";
@@ -92,12 +93,14 @@ export declare const WORKER_OPS: {
         readonly policiesInForce: "read";
         readonly activeSkillsByName: "read";
         readonly briefReceipts: "read";
+        readonly objectIdByMemory: "read";
     };
     readonly readiness: {
         readonly ping: "read";
     };
 };
-/** Sent by the executor itself and by no store method: the writer runs the store's open-time setup once, before any reader is sent a job. */
+/** Sent by the executor itself and by no store method: the writer runs the store's open-time setup once, before any
+ * reader is sent a job. */
 export declare const STORE_SETUP_OP = "setup";
 export type WorkerGroup = keyof typeof WORKER_OPS;
 /** The base methods the op table names. */
@@ -107,7 +110,8 @@ export interface WorkerInit {
     readonly mode: OpMode;
     /** Lock wait of the thread's connection. */
     readonly busyWaitMs: number;
-    /** One shared integer the writer sets to a job's id before that job may commit; the server thread reads it when the job passes its deadline. */
+    /** One shared integer the writer sets to a job's id before that job may commit; the server thread reads it when the
+     * job passes its deadline. */
     readonly commitFlag?: SharedArrayBuffer;
 }
 export interface Job {
@@ -120,7 +124,8 @@ export interface Job {
     /** wal_autocheckpoint as the server thread has it: a worker cannot see the checkpointer start or stop. */
     readonly walPages: number;
 }
-/** Both kinds carry the audit rows the job failed to write, since the count `/health` reports lives on the server thread. */
+/** Both kinds carry the audit rows the job failed to write,
+ * since the count `/health` reports lives on the server thread. */
 export type Reply = {
     readonly id: number;
     readonly ok: true;

package/dist/store/sqlite/worker-ops.js

@@ -1,5 +1,6 @@
-/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit row) and bumpRecallStats
- * (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs that open's setup before any reader serves. */
+/** Store methods answered by a worker, base ones under `base`. Tagged by effect, not name: predictionBaserate (audit
+ * row) and bumpRecallStats (stats.json) are writes. A read that opens through `openStore` is a read: the writer runs
+ * that open's setup before any reader serves. */
 export const WORKER_OPS = {
     base: {
         findApiKey: 'read',
@@ -83,11 +84,13 @@ export const WORKER_OPS = {
         policiesInForce: 'read',
         activeSkillsByName: 'read',
         briefReceipts: 'read',
+        objectIdByMemory: 'read',
     },
     readiness: {
         ping: 'read',
     },
 };
-/** Sent by the executor itself and by no store method: the writer runs the store's open-time setup once, before any reader is sent a job. */
+/** Sent by the executor itself and by no store method: the writer runs the store's open-time setup once, before any
+ * reader is sent a job. */
 export const STORE_SETUP_OP = 'setup';
 //# sourceMappingURL=worker-ops.js.map

package/dist/store/sqlite/worker-store.d.ts

@@ -1,8 +1,9 @@
 import type { HippoStore, StoreGroups } from '../port.js';
 import { type SqliteExecutor } from './executor.js';
-/** Whether `store` answers its `loop: 'off'` routes from worker threads, so a hippo.db open on the server thread inside one is a defect. */
+/** Whether `store` answers its `loop: 'off'` routes from worker threads, so a hippo.db open on the server thread inside
+ * one is a defect. */
 export declare function runsOffLoop(store: HippoStore): boolean;
-/** `sqliteStore` with the worker-backed methods in place of its in-process ones; close() closes `executor` and resolves once its threads have exited.
- *  `executor` defaults to threads of the store's own, with the server's lock wait. */
+/** `sqliteStore` with the worker-backed methods in place of its in-process ones; close() closes `executor` and resolves
+ * once its threads have exited. `executor` defaults to threads of the store's own, with the server's lock wait. */
 export declare function workerSqliteStore(hippoRoot: string, executor?: SqliteExecutor): HippoStore & StoreGroups;
 //# sourceMappingURL=worker-store.d.ts.map