hippo-memory 2.0.0 → 2.1.0

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

@@ -1,6 +1,7 @@
 import type { BriefReceipt, Incident, ObjectByKind, ObjectKind, Policy, SavableKind, Skill } from '../../core/object-types.js';
 import { type IncidentOpen, type IncidentOpenRefusal, type IncidentResolve, type ObjectClose, type ObjectListQuery, type ObjectRefusal, type Objects, type ObjectSave, type PoliciesInForceQuery } from '../port.js';
-/** The group with each answer as its value; spelled out because `Sync<Objects>` would widen each method's kind to every kind. */
+/** The group with each answer as its value; spelled out because
+ * `Sync<Objects>` would widen each method's kind to every kind. */
 export interface SyncObjects {
     listObjects<K extends ObjectKind>(tenantId: string, kind: K, query: ObjectListQuery<K>): ObjectByKind[K][];
     objectById<K extends ObjectKind>(tenantId: string, kind: K, id: number): ObjectByKind[K] | null;
@@ -11,10 +12,10 @@ export interface SyncObjects {
     policiesInForce(tenantId: string, query: PoliciesInForceQuery): Policy[];
     activeSkillsByName(tenantId: string, limit: number): Skill[];
     briefReceipts(tenantId: string, tag: string, limit: number): BriefReceipt[];
+    objectIdByMemory<K extends ObjectKind>(tenantId: string, kind: K, status: ObjectByKind[K]['status'], memoryId: string): number | null;
 }
 export declare function sqliteObjects(hippoRoot: string): SyncObjects;
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function servedObjects(sync: SyncObjects): Objects;
-/** The newest object in `status` that a memory mirrors, for the CLI flags that name an object by its memory id. */
-export declare function objectIdByMemory<K extends ObjectKind>(hippoRoot: string, tenantId: string, kind: K, status: ObjectByKind[K]['status'], memoryId: string): number | null;
 //# sourceMappingURL=objects-group.d.ts.map

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

@@ -4,13 +4,13 @@ import { getMeta, withWriteScopeOr } from '../../db/index.js';
 import { escapeLike } from '../../util/escape.js';
 import { keysetAfter } from '../../util/keyset.js';
 import { chunked } from '../../util/chunked.js';
-import { calculateStrength, deriveHalfLife } from '../../core/memory.js';
+import { calculateStrength, deriveHalfLife, LEGACY_TYPED_HALF_LIFE } from '../../core/memory.js';
 import { scopeAdmitSql } from '../rule-sql.js';
 import { stampOriginProject, upsertEntryRow } from '../entry-row.js';
 import { auditEntryWrite, writeEntryMirrors } from '../entry-writes.js';
 import { markGraphDirty } from '../graph-queue.js';
 import { removeGraphEntitiesForObject } from '../graph-writes.js';
-import { LEGACY_TYPED_HALF_LIFE, onHandle, openStore, TYPED_HALF_LIFE_META_KEY } from '../open.js';
+import { onHandle, openStore, TYPED_HALF_LIFE_META_KEY } from '../open.js';
 import { isObjectRefusal, } from '../port.js';
 import { auditingRefusal } from './entry-writes-group.js';
 import { insertSpec, rowSpec } from './object-rows.js';
@@ -29,9 +29,11 @@ export function sqliteObjects(hippoRoot) {
         policiesInForce: (tenantId, query) => onHandle(hippoRoot, (db) => policiesInForce(db, tenantId, query)),
         activeSkillsByName: (tenantId, limit) => onHandle(hippoRoot, (db) => activeSkillsByName(db, tenantId, limit)),
         briefReceipts: (tenantId, tag, limit) => onHandle(hippoRoot, (db) => briefReceipts(db, tenantId, tag, limit)),
+        objectIdByMemory: (tenantId, kind, status, memoryId) => onHandle(hippoRoot, (db) => idByMemory(db, tenantId, kind, status, memoryId)),
     };
 }
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export function servedObjects(sync) {
     return {
         listObjects: async (tenantId, kind, query) => sync.listObjects(tenantId, kind, query),
@@ -43,18 +45,22 @@ export function servedObjects(sync) {
         policiesInForce: async (tenantId, query) => sync.policiesInForce(tenantId, query),
         activeSkillsByName: async (tenantId, limit) => sync.activeSkillsByName(tenantId, limit),
         briefReceipts: async (tenantId, tag, limit) => sync.briefReceipts(tenantId, tag, limit),
+        objectIdByMemory: async (tenantId, kind, status, memoryId) => sync.objectIdByMemory(tenantId, kind, status, memoryId),
     };
 }
 /** The newest object in `status` that a memory mirrors, for the CLI flags that name an object by its memory id. */
-export function objectIdByMemory(hippoRoot, tenantId, kind, status, memoryId) {
-    return onHandle(hippoRoot, (db) => {
-        const row = db.prepare(`SELECT id FROM ${rowSpec(kind).table} WHERE memory_id = ? AND tenant_id = ? AND status = ? ORDER BY id DESC LIMIT 1`).get(memoryId, tenantId, status);
-        return row ? row.id : null;
-    });
+function idByMemory(db, tenantId, kind, status, memoryId) {
+    const row = db
+        .prepare(`SELECT id FROM ${rowSpec(kind).table} WHERE memory_id = ? AND tenant_id = ? AND status = ? ORDER BY id DESC ` +
+        `LIMIT 1`)
+        .get(memoryId, tenantId, status);
+    return row ? row.id : null;
 }
 function selectRow(db, kind, tenantId, id) {
     const spec = rowSpec(kind);
-    return db.prepare(`SELECT ${spec.cols} FROM ${spec.table} WHERE id = ? AND tenant_id = ?`).get(id, tenantId);
+    return db
+        .prepare(`SELECT ${spec.cols} FROM ${spec.table} WHERE id = ? AND tenant_id = ?`)
+        .get(id, tenantId);
 }
 function listRows(db, tenantId, kind, query) {
     const spec = rowSpec(kind);
@@ -70,12 +76,14 @@ function listRows(db, tenantId, kind, query) {
     }
     const after = keysetAfter('created_at', 'id', query.after);
     // SAFETY: the SELECT names spec.cols, the columns the kind's row declares, whatever the WHERE clause holds.
-    const rows = db.prepare(`
+    const rows = db
+        .prepare(`
     SELECT ${spec.cols} FROM ${spec.table}
     WHERE ${clauses.join(' AND ')}${after.sql}
     ORDER BY created_at DESC, id DESC
     LIMIT ?
-  `).all(...params, ...after.params, query.limit);
+  `)
+        .all(...params, ...after.params, query.limit);
     return rows.map((row) => spec.rowTo(row));
 }
 /** The status guard sits in the UPDATE, so zero rows changed means missing or not closable; the reread tells which. */
@@ -83,16 +91,26 @@ function closeRow(db, tenantId, kind, id, close) {
     const spec = rowSpec(kind);
     return withWriteScopeOr(db, 'close_object', (rollback) => {
         const marks = placeholders(close.from.length);
-        const updated = db.prepare(`UPDATE ${spec.table} SET status = 'closed', closed_at = ? WHERE id = ? AND tenant_id = ? AND status IN (${marks})`).run(close.at, id, tenantId, ...close.from);
+        const updated = db
+            .prepare(`UPDATE ${spec.table} SET status = 'closed', closed_at = ? WHERE id = ? AND tenant_id = ? AND status IN ` +
+            `(${marks})`)
+            .run(close.at, id, tenantId, ...close.from);
         if (updated.changes === 0) {
-            const existing = db.prepare(`SELECT status FROM ${spec.table} WHERE id = ? AND tenant_id = ?`)
+            const existing = db
+                .prepare(`SELECT status FROM ${spec.table} WHERE id = ? AND tenant_id = ?`)
                 .get(id, tenantId);
             return rollback(existing ? { refused: 'status', status: existing.status } : { refused: 'missing' });
         }
         const row = selectRow(db, kind, tenantId, id);
         if (!row)
             return rollback({ refused: 'vanished' });
-        appendAuditEvent(db, { tenantId, actor: close.actor, op: spec.closeOp, targetId: String(id), metadata: { [spec.idKey]: id } });
+        appendAuditEvent(db, {
+            tenantId,
+            actor: close.actor,
+            op: spec.closeOp,
+            targetId: String(id),
+            metadata: { [spec.idKey]: id },
+        });
         return spec.rowTo(row);
     });
 }
@@ -111,7 +129,10 @@ function closeAt(hippoRoot, tenantId, kind, id, close) {
 }
 /** Runs before the INSERT, so the new row's id can never be the id it replaces. */
 function successorVersion(db, tenantId, kind, replaced) {
-    const pred = db.prepare(`SELECT status, ${insertSpec(kind).versioned ? 'version' : '0 AS version'} FROM ${rowSpec(kind).table} WHERE id = ? AND tenant_id = ?`).get(replaced, tenantId);
+    const pred = db
+        .prepare(`SELECT status, ${insertSpec(kind).versioned ? 'version' : '0 AS version'} FROM ${rowSpec(kind).table} WHERE ` +
+        `id = ? AND tenant_id = ?`)
+        .get(replaced, tenantId);
     if (!pred)
         return { refused: 'missing' };
     if (pred.status !== 'active')
@@ -126,21 +147,27 @@ function insertRow(db, row) {
         cols.push('version', 'change_summary');
         values.push(row.version, row.save.supersedesId === undefined ? null : row.save.changeSummary ?? null);
     }
-    const result = db.prepare(`
-    INSERT INTO ${rowSpec(row.kind).table}(${cols.join(', ')}, status, superseded_by, superseded_at, closed_at, created_at)
+    const result = db
+        .prepare(`
+    INSERT INTO ${rowSpec(row.kind).table}(${cols.join(', ')}, status, superseded_by, superseded_at, closed_at,
+    created_at)
     VALUES (${placeholders(cols.length)}, 'active', NULL, NULL, NULL, ?)
-  `).run(...values, row.save.at);
+  `)
+        .run(...values, row.save.at);
     return Number(result.lastInsertRowid ?? 0);
 }
-/** The status guard sits in the UPDATE, so a row another writer retired since the preflight fails the whole save; false says so. */
+/** The status guard sits in the UPDATE, so a row another writer
+ * retired since the preflight fails the whole save; false says so. */
 function supersedeRow(db, row, replaced, id) {
     const spec = rowSpec(row.kind);
     const insert = insertSpec(row.kind);
-    const updated = db.prepare(`
+    const updated = db
+        .prepare(`
     UPDATE ${spec.table}
     SET status = 'superseded', superseded_by = ?, superseded_at = ?
     WHERE id = ? AND tenant_id = ? AND status = 'active' AND id != ?
-  `).run(id, row.save.at, replaced, row.tenantId, id);
+  `)
+        .run(id, row.save.at, replaced, row.tenantId, id);
     if (updated.changes === 0)
         return false;
     const own = insert.versioned
@@ -155,7 +182,8 @@ function supersedeRow(db, row, replaced, id) {
     });
     return true;
 }
-/** The object half of a save, inside the scope that holds the mirror memory: a refusal or a throw here leaves no row, memory or audit event. */
+/** The object half of a save, inside the scope that holds the mirror memory: a refusal or a throw here leaves no row,
+ * memory or audit event. */
 function writeObjectRow(db, tenantId, kind, memoryId, save) {
     const replaced = save.supersedesId;
     const next = replaced === undefined ? { version: 1 } : successorVersion(db, tenantId, kind, replaced);
@@ -188,7 +216,8 @@ function onStoreHalfLife(db, mirror) {
     const legacy = { ...mirror, half_life_days: deriveHalfLife(LEGACY_TYPED_HALF_LIFE, mirror) };
     return { ...legacy, strength: calculateStrength(legacy) };
 }
-/** One write scope on one handle holds the mirror, the row `writeRow` adds, the successor link and every audit row, the mirror's remember row last. */
+/** One write scope on one handle holds the mirror, the row `writeRow` adds, the successor link and every audit row, the
+ * mirror's remember row last. */
 function withMirror(hippoRoot, write, writeRow) {
     return onHandle(hippoRoot, (db) => auditingRefusal(db, write.actor, () => {
         let mirror = stampOriginProject(hippoRoot, write.mirror);
@@ -212,7 +241,11 @@ function withMirror(hippoRoot, write, writeRow) {
 }
 function saveAt(hippoRoot, tenantId, kind, save) {
     const spec = rowSpec(kind);
-    const write = { mirror: save.mirror, actor: save.actor, graphTenant: spec.graphType ? tenantId : undefined };
+    const write = {
+        mirror: save.mirror,
+        actor: save.actor,
+        graphTenant: spec.graphType ? tenantId : undefined,
+    };
     const written = withMirror(hippoRoot, write, (db, memoryId) => writeObjectRow(db, tenantId, kind, memoryId, save));
     return isObjectRefusal(written) ? written : spec.rowTo(written);
 }
@@ -223,19 +256,23 @@ function openIncidentRow(db, tenantId, memoryId, open) {
     for (const ids of chunked(linkedMemoryIds)) {
         const marks = placeholders(ids.length);
         // SAFETY: rows' shape matches the one column named in the SELECT.
-        const found = db.prepare(`SELECT id FROM memories WHERE tenant_id = ? AND id IN (${marks})`).all(tenantId, ...ids);
+        const found = db
+            .prepare(`SELECT id FROM memories WHERE tenant_id = ? AND id IN (${marks})`)
+            .all(tenantId, ...ids);
         for (const r of found)
             held.add(r.id);
     }
     const missing = linkedMemoryIds.find((linkId) => !held.has(linkId));
     if (missing !== undefined)
         return { refused: 'unlinked', memoryId: missing };
-    const result = db.prepare(`
+    const result = db
+        .prepare(`
     INSERT INTO incidents(
       memory_id, tenant_id, incident_text, context,
       status, resolution_text, resolved_at, closed_at, linked_memory_ids, created_at
     ) VALUES (?, ?, ?, ?, 'open', NULL, NULL, NULL, ?, ?)
-  `).run(memoryId, tenantId, incidentText, context ?? null, JSON.stringify(linkedMemoryIds), open.at);
+  `)
+        .run(memoryId, tenantId, incidentText, context ?? null, JSON.stringify(linkedMemoryIds), open.at);
     const id = Number(result.lastInsertRowid ?? 0);
     const row = selectRow(db, 'incident', tenantId, id);
     if (!row)
@@ -245,7 +282,11 @@ function openIncidentRow(db, tenantId, memoryId, open) {
         actor: open.actor,
         op: 'incident_open',
         targetId: String(id),
-        metadata: { incident_id: id, has_context: context !== undefined && context !== '', linked_memory_count: linkedMemoryIds.length },
+        metadata: {
+            incident_id: id,
+            has_context: context !== undefined && context !== '',
+            linked_memory_count: linkedMemoryIds.length,
+        },
     });
     return row;
 }
@@ -257,24 +298,34 @@ function openIncidentAt(hippoRoot, tenantId, open) {
 /** The status guard sits in the UPDATE, so zero rows changed means missing or not open; the reread tells which. */
 function resolveRow(db, tenantId, id, resolve) {
     return withWriteScopeOr(db, 'resolve_incident', (rollback) => {
-        const updated = db.prepare(`
+        const updated = db
+            .prepare(`
       UPDATE incidents
       SET status = 'resolved', resolution_text = ?, resolved_at = ?
       WHERE id = ? AND tenant_id = ? AND status = 'open'
-    `).run(resolve.text, resolve.at, id, tenantId);
+    `)
+            .run(resolve.text, resolve.at, id, tenantId);
         if (updated.changes === 0) {
-            const existing = db.prepare(`SELECT status FROM incidents WHERE id = ? AND tenant_id = ?`)
+            const existing = db
+                .prepare(`SELECT status FROM incidents WHERE id = ? AND tenant_id = ?`)
                 .get(id, tenantId);
             return rollback(existing ? { refused: 'status', status: existing.status } : { refused: 'missing' });
         }
         const row = selectRow(db, 'incident', tenantId, id);
         if (!row)
             return rollback({ refused: 'vanished' });
-        appendAuditEvent(db, { tenantId, actor: resolve.actor, op: 'incident_resolve', targetId: String(id), metadata: { incident_id: id } });
+        appendAuditEvent(db, {
+            tenantId,
+            actor: resolve.actor,
+            op: 'incident_resolve',
+            targetId: String(id),
+            metadata: { incident_id: id },
+        });
         return rowSpec('incident').rowTo(row);
     });
 }
-/** The successor is joined in so a superseded version is kept only while the row that replaced it is not yet in force. */
+/** The successor is joined in so a superseded version is kept
+ * only while the row that replaced it is not yet in force. */
 function policiesInForce(db, tenantId, query) {
     const { asOf, name } = query;
     const nameClause = name !== undefined ? 'AND p.policy_name = ?' : '';

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

@@ -1,5 +1,6 @@
 import type { Predictions, Sync } from '../port.js';
 export declare function sqlitePredictions(hippoRoot: string): Sync<Predictions>;
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function servedPredictions(sync: Sync<Predictions>): Predictions;
 //# sourceMappingURL=predictions-group.d.ts.map

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

@@ -1,4 +1,5 @@
-// hippo.db's half of the Predictions store group: each method is one call into the queries the CLI and the MCP tools run.
+// hippo.db's half of the Predictions store group: each method is one call into the queries the CLI and the MCP tools
+// run.
 import { closePrediction, computePredictionBaserate, loadAllPredictions, loadOpenPredictions, loadPredictionById, loadPredictionsByClass, writePrediction, } from '../predictions.js';
 export function sqlitePredictions(hippoRoot) {
     return {
@@ -15,7 +16,8 @@ export function sqlitePredictions(hippoRoot) {
         predictionBaserate: (tenantId, classTag, actor) => computePredictionBaserate(hippoRoot, tenantId, classTag, actor),
     };
 }
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export function servedPredictions(sync) {
     return {
         savePrediction: async (tenantId, input, actor) => sync.savePrediction(tenantId, input, actor),

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

@@ -0,0 +1,3 @@
+import type { Promotion } from '../port/promotion.js';
+export declare function sqlitePromotion(hippoRoot: string): Promotion;
+//# sourceMappingURL=promotion-group.d.ts.map

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

@@ -0,0 +1,10 @@
+// The built-in store's promotion: the two existing functions, bound to this hippo root.
+import { copyToGlobal } from './global-promote.js';
+import { memoryReach } from '../tenant-lookup.js';
+export function sqlitePromotion(hippoRoot) {
+    return {
+        reach: (id) => memoryReach(hippoRoot, id),
+        copyToGlobal: (id, opts) => copyToGlobal(hippoRoot, id, opts),
+    };
+}
+//# sourceMappingURL=promotion-group.js.map

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

@@ -1,5 +1,6 @@
 import type { Quarantine, Sync } from '../port.js';
 export declare function sqliteQuarantine(hippoRoot: string): Sync<Quarantine>;
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function servedQuarantine(sync: Sync<Quarantine>): Quarantine;
 //# sourceMappingURL=quarantine-group.d.ts.map

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

@@ -4,7 +4,8 @@ import { readEntry } from '../entry-reads.js';
 import { writeEntryMirrors } from '../entry-writes.js';
 import { onHandle } from '../open.js';
 import { approveQuarantinedAt, listQuarantinedAt, rejectQuarantinedAt } from '../quarantine.js';
-/** After the commit, best effort: a failed rewrite leaves the markdown mirror showing the quarantine scope, which still hides the memory. */
+/** After the commit, best effort: a failed rewrite leaves the markdown mirror showing the quarantine scope, which still
+ * hides the memory. */
 function rewriteMirror(hippoRoot, tenantId, id) {
     try {
         const restored = readEntry(hippoRoot, id, tenantId);
@@ -27,7 +28,8 @@ export function sqliteQuarantine(hippoRoot) {
         rejectQuarantined: (tenantId, id, actor) => onHandle(hippoRoot, (db) => rejectQuarantinedAt(db, tenantId, id, actor)),
     };
 }
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export function servedQuarantine(sync) {
     return {
         listQuarantined: async (tenantId, query) => sync.listQuarantined(tenantId, query),

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

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

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,16 +1,27 @@
-import type { HippoStore, 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;
-export {};
 //# sourceMappingURL=store.d.ts.map