hippo-memory 2.0.0 → 2.1.0

package/dist/store/sqlite/store.js

@@ -9,11 +9,21 @@ import { planningFallacyEvidenceAt } from '../planning-fallacy-evidence.js';
 import { recordTokenUse } from '../token-ledger.js';
 import { loadAmbientCandidates, loadContextCandidates } from '../candidates.js';
 import { loadEntriesByIds, loadFreshRawMemories } from '../entry-reads.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 { 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';
@@ -22,25 +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 { 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 },
+        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),
@@ -57,7 +81,15 @@ export function sqliteSyncStore(hippoRoot) {
         lastRecall: sqliteLastRecall(hippoRoot),
         auditMaintenance: sqliteAuditMaintenance(hippoRoot),
         lessonWrites: sqliteLessonWrites(hippoRoot),
-        close() { },
+        sessions: sqliteSessions(hippoRoot),
+        cards: sqliteCards(hippoRoot),
+        goals: sqliteGoals(hippoRoot),
+        conflicts: sqliteConflicts(hippoRoot),
+        dormant: sqliteDormant(hippoRoot),
+        reports: sqliteReports(hippoRoot),
+        close() {
+            flushStatsMirrors(hippoRoot);
+        },
     };
 }
 function sqliteBaseReads(hippoRoot) {
@@ -140,7 +172,25 @@ 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 {
@@ -161,9 +211,20 @@ export function sqliteStore(hippoRoot) {
         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,
@@ -181,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),
@@ -193,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) {
@@ -259,6 +323,13 @@ function sqliteKeyWrites(hippoRoot) {
         },
     };
 }
+function sqliteKeyGrants(hippoRoot) {
+    return {
+        changeScopeGrant(change) {
+            onHandle(hippoRoot, (db) => changeScopeGrantAt(db, change));
+        },
+    };
+}
 function sqliteKeyAudit(hippoRoot) {
     return {
         revokeApiKey(revoke) {
@@ -279,7 +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 })
+            : [],
     };
 }
 //# 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

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

@@ -1,23 +1,31 @@
-// hippo.db as serve() runs it by default: the methods in the op table answer from worker threads, the rest still run on the calling thread.
+// hippo.db as serve() runs it by default: the methods in the op table answer from worker threads, the rest still run on
+// the calling thread.
 import { existsSync } from 'node:fs';
 import { getHippoDbPath } from '../../db/index.js';
-import { currentDeadline, currentRequestId } from '../../util/request-scope.js';
+import { currentDeadline, currentRequestId, currentSignal } from '../../util/request-scope.js';
 import { createSqliteExecutor } from './executor.js';
 import { sqliteStore } from './store.js';
 import { vectorCopiesOf, vectorViewsOf } from './vector-pack.js';
-import { WORKER_OPS } from './worker-ops.js';
+import { WORKER_OPS, } from './worker-ops.js';
 const offLoopStores = new WeakSet();
-/** 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 function runsOffLoop(store) {
     return offLoopStores.has(store);
 }
 function send(executor, op, args, mode) {
     const deadline = currentDeadline();
-    const call = executor.call(op, args, { mode, requestId: currentRequestId(), deadlineAt: deadline?.at });
+    const call = executor.call(op, args, {
+        mode,
+        requestId: currentRequestId(),
+        deadlineAt: deadline?.at,
+        signal: currentSignal(),
+    });
     // The request's own timer then waits for this call's answer, which names what became of a write.
     return deadline ? deadline.track(call) : call;
 }
-/** `inProcess` with each method the op table places on a worker answered from one, so a new method of a group needs its tag and no body here. */
+/** `inProcess` with each method the op table places on a worker answered from one, so a new method of a group needs its
+ * tag and no body here. */
 function onWorkers(executor, group, places, inProcess) {
     const moved = Object.entries(places).flatMap(([method, place]) => (place === 'server' ? [] : [[
             method,
@@ -25,23 +33,25 @@ function onWorkers(executor, group, places, inProcess) {
         ]]));
     return { ...inProcess, ...Object.fromEntries(moved) };
 }
-// The two reads that return vectors: the worker answers with one moved buffer, and the port's Map is rebuilt here. No ids reads nothing, as in process.
+// The two reads that return vectors: the worker answers with one moved buffer, and the port's Map is rebuilt here. No
+// ids reads nothing, as in process.
 function vectorGroups(executor, inProcess) {
     const { vectors, vectorViews } = WORKER_OPS;
     const pack = (op, ids, mode) => send(executor, op, [ids], mode);
     return {
         vectors: {
             ...onWorkers(executor, 'vectors', vectors, inProcess),
-            storedVectors: async (ids) => (ids.length === 0 ? new Map() : vectorCopiesOf(await pack('vectors.storedVectors', ids, vectors.storedVectors))),
+            storedVectors: async (ids) => ids.length === 0 ? new Map() : vectorCopiesOf(await pack('vectors.storedVectors', ids, vectors.storedVectors)),
         },
         vectorViews: {
-            storedVectorViews: async (ids) => (ids.length === 0
+            storedVectorViews: async (ids) => ids.length === 0
                 ? new Map()
-                : vectorViewsOf(await pack('vectorViews.storedVectorViews', ids, vectorViews.storedVectorViews))),
+                : vectorViewsOf(await pack('vectorViews.storedVectorViews', ids, vectorViews.storedVectorViews)),
         },
     };
 }
-// A probe must not create the store, and a worker's first job sets it up, so a root with no hippo.db is ready before any thread starts.
+// A probe must not create the store, and a worker's first job sets it up, so a root with no hippo.db is ready before
+// any thread starts.
 function probing(hippoRoot, served) {
     return {
         ping: async () => {
@@ -50,11 +60,11 @@ function probing(hippoRoot, served) {
         },
     };
 }
-/** `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 function workerSqliteStore(hippoRoot, executor = createSqliteExecutor(hippoRoot)) {
     const inProcess = sqliteStore(hippoRoot);
-    const { keyAudit, keyWrites, vectorWrites, entryWrites, contextReads, predictions, dagReads, auditLog, quarantine, graphReads, objects } = WORKER_OPS;
+    const { keyAudit, keyWrites, vectorWrites, entryWrites, contextReads, predictions, dagReads, auditLog, quarantine, graphReads, objects, } = WORKER_OPS;
     const store = {
         ...inProcess,
         ...onWorkers(executor, 'base', WORKER_OPS.base, inProcess),

package/dist/store/summaries.d.ts

@@ -1,20 +1,25 @@
-import type { MemoryEntry } from '../core/memory.js';
-/** Host-wide loader for L2 topic summaries without an L3 parent, for consolidate phase 1.9 (buildEntityProfiles); SQL-level filter, since in-memory
- * `survivors` lacks L2s created by phase 1.7. Entries carry tenantId so per-cluster writes stay tenant-scoped. */
+import { type MemoryEntry } from '../core/memory.js';
+/** Host-wide loader for L2 topic summaries without an L3 parent, for consolidate phase 1.9 (buildEntityProfiles);
+ * SQL-level filter, since in-memory `survivors` lacks L2s created by phase 1.7. Entries carry tenantId so per-cluster
+ * writes stay tenant-scoped. */
 export declare function loadAllL2Summaries(hippoRoot: string): MemoryEntry[];
-/** Dirty summaries across all tenants, newest change first (latest_at DESC NULLS LAST, id ASC), at most `limit` (all when omitted)
- * so HIPPO_DAG_REBUILD_CAP reads only the most recently changed. Each entry carries its tenantId so later writes stay tenant-scoped. */
+/** Dirty summaries across all tenants, newest change first (latest_at DESC NULLS LAST, id ASC), at most `limit` (all
+ * when omitted) so HIPPO_DAG_REBUILD_CAP reads only the most recently changed. Each entry carries its tenantId so later
+ * writes stay tenant-scoped. */
 export declare function loadAllDirtySummaries(hippoRoot: string, limit?: number): MemoryEntry[];
-/** Live (non-archived) children of a DAG summary, so a rebuild regenerates from the CURRENT child set; tenant-scoped as defence in depth. */
+/** Live (non-archived) children of a DAG summary, so a rebuild regenerates from the CURRENT child set; tenant-scoped as
+ * defence in depth. */
 export declare function loadChildrenOfSummary(hippoRoot: string, summaryId: string, tenantId: string): MemoryEntry[];
-/** loadChildrenOfSummary for many summaries in one IN query per tenant chunk; the map key is `${tenantId}\u0000${summaryId}`, each list in created order. */
+/** loadChildrenOfSummary for many summaries in one IN query per tenant chunk; the map key is
+ * `${tenantId}\u0000${summaryId}`, each list in created order. */
 export declare function loadChildrenOfSummaries(hippoRoot: string, summaries: ReadonlyArray<{
     id: string;
     tenant_id: string;
 }>): Map<string, MemoryEntry[]>;
 /** Key into the map loadChildrenOfSummaries returns. */
 export declare function childrenKey(tenantId: string, summaryId: string): string;
-/** Patch applied by applyRebuildResult; `bumpRebuildCount` is false for the zero-child case, true for a normal rebuild. */
+/** Patch applied by applyRebuildResult; `bumpRebuildCount` is false for the zero-child case, true for a normal
+ * rebuild. */
 export interface RebuildPatch {
     content: string;
     descendant_count: number;
@@ -24,13 +29,15 @@ export interface RebuildPatch {
     zeroChildren: boolean;
     actor: string;
 }
-/** Apply a rebuild result to a dirty summary in one write scope (UPDATE plus syncFtsRow); `AND summary_dirty = 1` makes a concurrent race-loser a no-op.
- * Returns `{ changed, refused }`: `refused` only when a tombstone hit suppressed the content write while the metadata UPDATE still landed. */
+/** Apply a rebuild result to a dirty summary in one write scope (UPDATE plus syncFtsRow); `AND summary_dirty = 1` makes
+ * a concurrent race-loser a no-op. Returns `{ changed, refused }`: `refused` only when a tombstone hit suppressed the
+ * content write while the metadata UPDATE still landed. */
 export declare function applyRebuildResult(hippoRoot: string, summary: MemoryEntry, patch: RebuildPatch): {
     changed: boolean;
     refused: boolean;
 };
-/** Clear summary_dirty on a new summary after buildDag's child-link loop (each member's writeEntry marks the parent dirty, so the same cycle would rebuild it).
- * Idempotent (no-op, no audit if not dirty); audit source='buildDag-clean' distinguishes it from the rebuild's. */
+/** Clear summary_dirty on a new summary after buildDag's child-link loop (each member's writeEntry marks the parent
+ * dirty, so the same cycle would rebuild it). Idempotent (no-op, no audit if not dirty); audit source='buildDag-clean'
+ * distinguishes it from the rebuild's. */
 export declare function clearSummaryDirtyAfterBuild(hippoRoot: string, summaryId: string, tenantId: string, actor?: string, source?: string): void;
 //# sourceMappingURL=summaries.d.ts.map