hippo-memory 1.72.0 → 2.1.0

package/dist/store/sqlite/last-recall-group.d.ts

@@ -0,0 +1,15 @@
+import type { LastRecall, RecallWrites, Sync } from '../port.js';
+/** 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 declare function sqliteLastRecall(hippoRoot: string): Sync<LastRecall>;
+/** The group as a served store answers it: the call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
+export declare function servedLastRecall(sync: Sync<LastRecall>): LastRecall;
+export {};
+//# sourceMappingURL=last-recall-group.d.ts.map

package/dist/store/sqlite/last-recall-group.js

@@ -0,0 +1,62 @@
+// hippo.db's LastRecall group: the last recall sits in its meta table, and a traced outcome links on the outcome's own
+// handle.
+import { withWriteScope } from '../../db/index.js';
+import { appendAuditEvent } from '../audit.js';
+import { strengthenRetrieved, strengthenRetrievedInOwnTx } from '../entry-writes.js';
+import { localGoalRecallRows, writeGoalRecallLog } from '../goals.js';
+import { loadLastRecall, saveIndex } from '../index-and-stats.js';
+import { onHandle } from '../open.js';
+import { writeRecallTrace } from '../recall-trace.js';
+import { applyOutcomeAt } from './entry-writes-group.js';
+/** 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();
+        });
+    });
+}
+export function sqliteLastRecall(hippoRoot) {
+    return {
+        applyTracedOutcome: (outcome, traceId) => applyOutcomeAt(hippoRoot, outcome, traceId),
+        applyOutcomeToLast(target, good) {
+            const { last_retrieval_ids: ids, last_trace_id: trace } = loadLastRecall(hippoRoot);
+            if (ids.length === 0)
+                return [];
+            return applyOutcomeAt(hippoRoot, { ...target, ids, good }, trace === null ? undefined : Number(trace));
+        },
+        finishRecall(writes, globalRoot) {
+            const { ids, opts } = writes.strengthen;
+            const { traceId, strengthened } = finishRecallAt(hippoRoot, writes);
+            if (globalRoot !== undefined)
+                strengthenRetrieved(globalRoot, ids.filter((id) => !strengthened.has(id)), opts);
+            // One write for both keys, so an outcome never pairs these ids with an older trace; a lost trace saves null.
+            saveIndex(hippoRoot, { last_retrieval_ids: [...ids], last_trace_id: traceId === null ? null : String(traceId) });
+            return traceId;
+        },
+    };
+}
+/** The group as a served store answers it: the call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
+export function servedLastRecall(sync) {
+    return {
+        applyTracedOutcome: async (outcome, traceId) => sync.applyTracedOutcome(outcome, traceId),
+        applyOutcomeToLast: async (target, good) => sync.applyOutcomeToLast(target, good),
+        finishRecall: async (writes, globalRoot) => sync.finishRecall(writes, globalRoot),
+    };
+}
+//# sourceMappingURL=last-recall-group.js.map

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

@@ -0,0 +1,4 @@
+import type { Learning } from '../port/learning.js';
+/** The learn passes' store work on the hippo.db under `hippoRoot`, each call on its own short-lived handle. */
+export declare function sqliteLearning(hippoRoot: string): Learning;
+//# sourceMappingURL=learning-group.d.ts.map

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

@@ -0,0 +1,17 @@
+import { confirmedOutcomeTimes } from '../audit.js';
+import { loadAllEntries, loadCurrentEntriesFromOrigins, loadEntriesMentioning, readEntry } from '../entry-reads.js';
+import { addTagToEntries, writeEntriesTogether, writeEntry } from '../entry-writes.js';
+/** The learn passes' store work on the hippo.db under `hippoRoot`, each call on its own short-lived handle. */
+export function sqliteLearning(hippoRoot) {
+    return {
+        allEntries: (tenantId) => loadAllEntries(hippoRoot, tenantId),
+        entriesMentioning: (tokens, tag, tenantId) => loadEntriesMentioning(hippoRoot, tokens, tag, tenantId),
+        readEntry: (id, tenantId) => readEntry(hippoRoot, id, tenantId),
+        currentEntriesFromOrigins: (tenantId, origins) => loadCurrentEntriesFromOrigins(hippoRoot, tenantId, origins),
+        writeEntry: (entry) => writeEntry(hippoRoot, entry),
+        writeEntriesTogether: (entries) => writeEntriesTogether(hippoRoot, entries),
+        addTagToEntries: (tenantId, ids, tag) => addTagToEntries(hippoRoot, tenantId, ids, tag),
+        confirmedOutcomeTimes: (tenantId) => confirmedOutcomeTimes(hippoRoot, tenantId),
+    };
+}
+//# sourceMappingURL=learning-group.js.map

package/dist/store/sqlite/maintenance-groups.d.ts

@@ -0,0 +1,6 @@
+import type { AuditMaintenance, LessonWrites, Sync } from '../port.js';
+export declare function sqliteAuditMaintenance(hippoRoot: string): Sync<AuditMaintenance>;
+export declare function servedAuditMaintenance(sync: Sync<AuditMaintenance>): AuditMaintenance;
+export declare function sqliteLessonWrites(hippoRoot: string): Sync<LessonWrites>;
+export declare function servedLessonWrites(sync: Sync<LessonWrites>): LessonWrites;
+//# sourceMappingURL=maintenance-groups.d.ts.map

package/dist/store/sqlite/maintenance-groups.js

@@ -0,0 +1,61 @@
+// hippo.db's half of the AuditMaintenance and LessonWrites store groups: the quality audit, audit prune and git learn's
+// batch.
+import { pruneAuditRows } from '../audit.js';
+import { loadTextsHoldingWords } from '../candidates.js';
+import { deleteEntriesAutomatically, memoriesBackingObjects } from '../delete-and-batch.js';
+import { loadAllEntries } from '../entry-reads.js';
+import { writeEntriesSkippingRejected, writeEntriesTogether } from '../entry-writes.js';
+import { updateStats } from '../index-and-stats.js';
+import { repairAutomaticMemories, repairQualityOnce } from '../quality-repair.js';
+import { touchableScopeSql } from '../rule-sql.js';
+export function sqliteAuditMaintenance(hippoRoot) {
+    return {
+        tenantEntries: (tenantId) => loadAllEntries(hippoRoot, tenantId),
+        objectBackedIds: () => memoriesBackingObjects(hippoRoot),
+        deleteAutomatically: (removals, actor) => deleteEntriesAutomatically(hippoRoot, removals, actor),
+        pruneAuditRows: (prune) => pruneAuditRows(hippoRoot, prune),
+        repairQuality: (tenantId, apply) => repairAutomaticMemories(hippoRoot, { tenantId, apply }),
+        repairQualityOnce: (tenantId) => repairQualityOnce(hippoRoot, tenantId),
+    };
+}
+export function servedAuditMaintenance(sync) {
+    return {
+        tenantEntries: async (tenantId) => sync.tenantEntries(tenantId),
+        objectBackedIds: async () => sync.objectBackedIds(),
+        deleteAutomatically: async (removals, actor) => sync.deleteAutomatically(removals, actor),
+        pruneAuditRows: async (prune) => sync.pruneAuditRows(prune),
+        repairQuality: async (tenantId, apply) => sync.repairQuality(tenantId, apply),
+        repairQualityOnce: async (tenantId) => sync.repairQualityOnce(tenantId),
+    };
+}
+export function sqliteLessonWrites(hippoRoot) {
+    return {
+        tenantEntries: (tenantId) => loadAllEntries(hippoRoot, tenantId),
+        textsHoldingWords: (tenantId, words, ownScope) => loadTextsHoldingWords(hippoRoot, tenantId, words, undefined, touchableScopeSql('', ownScope)),
+        writeSkippingRejected(entries, actor) {
+            const written = [];
+            writeEntriesSkippingRejected(hippoRoot, (put) => {
+                for (const entry of entries)
+                    if (put(entry))
+                        written.push(entry.id);
+            }, actor);
+            return written;
+        },
+        writeTogether(entries) {
+            writeEntriesTogether(hippoRoot, entries);
+        },
+        bumpRemembered(count) {
+            updateStats(hippoRoot, { remembered: count });
+        },
+    };
+}
+export function servedLessonWrites(sync) {
+    return {
+        tenantEntries: async (tenantId) => sync.tenantEntries(tenantId),
+        textsHoldingWords: async (tenantId, words, ownScope) => sync.textsHoldingWords(tenantId, words, ownScope),
+        writeSkippingRejected: async (entries, actor) => sync.writeSkippingRejected(entries, actor),
+        writeTogether: async (entries) => sync.writeTogether(entries),
+        bumpRemembered: async (count) => sync.bumpRemembered(count),
+    };
+}
+//# sourceMappingURL=maintenance-groups.js.map

package/dist/store/sqlite/object-rows.d.ts

@@ -78,7 +78,8 @@ interface RowSpec<K extends ObjectKind> {
     readonly closeOp: AuditOp;
     /** The one column a list may filter by equality. */
     readonly filterColumn?: string;
-    /** Set for the kinds the graph extracts, so a save marks the graph stale and a close drops the object's graph rows. */
+    /** Set for the kinds the graph extracts, so a save marks the graph stale and a close drops the object's graph
+     * rows. */
     readonly graphType?: SourceObjectType;
 }
 /** What one column of a new row can hold. */
@@ -86,12 +87,14 @@ export type ColumnValue = string | number | null;
 interface InsertSpec<K extends SavableKind> {
     readonly createOp: AuditOp;
     readonly supersedeOp: AuditOp;
-    /** A versioned table has `version` and `change_summary`: a successor takes its predecessor's version plus one and the caller's change note. */
+    /** A versioned table has `version` and `change_summary`: a successor takes its predecessor's version plus one and the
+     * caller's change note. */
     readonly versioned: boolean;
     /** The kind's own columns, in the order `values` fills them. */
     readonly columns: readonly string[];
     readonly values: (w: ObjectFields[K]) => readonly ColumnValue[];
-    /** The create audit's keys after the id, in the order they are stored: ids, counts and flags, never the object's text. */
+    /** The create audit's keys after the id, in the order they are stored: ids, counts and flags, never the object's
+     * text. */
     readonly createMeta: (w: ObjectFields[K], version: number) => JsonObject;
     /** Keys the supersede audit stores after its own. */
     readonly supersedeMeta?: (w: ObjectFields[K]) => JsonObject;

package/dist/store/sqlite/object-rows.js

@@ -69,11 +69,40 @@ function parseSteps(raw, id) {
         return [];
     }
 }
-const rowToProcess = (row) => ({ ...head(row), processName: row.process_name, description: row.description, steps: parseSteps(row.steps, row.id), ...versionedTail(row) });
-const rowToPolicy = (row) => ({ ...head(row), policyName: row.policy_name, policyText: row.policy_text, validFrom: row.valid_from, validTo: row.valid_to, ...versionedTail(row) });
-const rowToSkill = (row) => ({ ...head(row), skillName: row.skill_name, instructions: row.instructions, trigger: row.trigger_text, ...versionedTail(row) });
-const rowToProjectBrief = (row) => ({ ...head(row), repo: row.repo, summary: row.summary, ...versionedTail(row) });
-const rowToCustomerNote = (row) => ({ ...head(row), customer: row.customer, note: row.note, ...versionedTail(row) });
+const rowToProcess = (row) => ({
+    ...head(row),
+    processName: row.process_name,
+    description: row.description,
+    steps: parseSteps(row.steps, row.id),
+    ...versionedTail(row),
+});
+const rowToPolicy = (row) => ({
+    ...head(row),
+    policyName: row.policy_name,
+    policyText: row.policy_text,
+    validFrom: row.valid_from,
+    validTo: row.valid_to,
+    ...versionedTail(row),
+});
+const rowToSkill = (row) => ({
+    ...head(row),
+    skillName: row.skill_name,
+    instructions: row.instructions,
+    trigger: row.trigger_text,
+    ...versionedTail(row),
+});
+const rowToProjectBrief = (row) => ({
+    ...head(row),
+    repo: row.repo,
+    summary: row.summary,
+    ...versionedTail(row),
+});
+const rowToCustomerNote = (row) => ({
+    ...head(row),
+    customer: row.customer,
+    note: row.note,
+    ...versionedTail(row),
+});
 /** Tells an auto-refresh from a manual write in the audit log without a fourth audit op. */
 function refreshMeta(w) {
     return w.receiptCount === undefined ? { refreshed: false } : { refreshed: true, receipt_count: w.receiptCount };

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

@@ -3,16 +3,18 @@ import { appendAuditEvent } from '../audit.js';
 import { getMeta, withWriteScopeOr } from '../../db/index.js';
 import { escapeLike } from '../../util/escape.js';
 import { keysetAfter } from '../../util/keyset.js';
-import { calculateStrength, deriveHalfLife } from '../../core/memory.js';
+import { chunked } from '../../util/chunked.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';
+import { placeholders } from '../../util/sql.js';
 export function sqliteObjects(hippoRoot) {
     return {
         listObjects: (tenantId, kind, query) => onHandle(hippoRoot, (db) => listRows(db, tenantId, kind, query)),
@@ -27,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),
@@ -41,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);
@@ -68,29 +76,41 @@ 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. */
 function closeRow(db, tenantId, kind, id, close) {
     const spec = rowSpec(kind);
     return withWriteScopeOr(db, 'close_object', (rollback) => {
-        const marks = close.from.map(() => '?').join(', ');
-        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 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);
         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);
     });
 }
@@ -109,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')
@@ -124,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)
-    VALUES (${cols.map(() => '?').join(', ')}, 'active', NULL, NULL, NULL, ?)
-  `).run(...values, row.save.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);
     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
@@ -153,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);
@@ -186,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);
@@ -210,24 +241,38 @@ 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);
 }
 /** The linked ids are checked once the mirror is in and before the INSERT, so a refusal undoes the mirror with it. */
 function openIncidentRow(db, tenantId, memoryId, open) {
     const { incidentText, context, linkedMemoryIds } = open.fields;
-    for (const linkId of linkedMemoryIds) {
-        const held = db.prepare(`SELECT id FROM memories WHERE id = ? AND tenant_id = ?`).get(linkId, tenantId);
-        if (!held)
-            return { refused: 'unlinked', memoryId: linkId };
+    const held = new Set();
+    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);
+        for (const r of found)
+            held.add(r.id);
     }
-    const result = db.prepare(`
+    const missing = linkedMemoryIds.find((linkId) => !held.has(linkId));
+    if (missing !== undefined)
+        return { refused: 'unlinked', memoryId: missing };
+    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)
@@ -237,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;
 }
@@ -249,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