hippo-memory 2.0.0 → 2.1.0

package/dist/store/delete-and-batch.js

@@ -15,11 +15,23 @@ import { onHandle, openStore } from './open.js';
 import { clock } from '../util/write-budget.js';
 import { chunked } from '../util/chunked.js';
 import { placeholders } from '../util/sql.js';
-/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
-export const MEMORY_BACKED_TABLES = ['predictions', 'decisions', 'incidents', 'processes', 'policies', 'skills', 'project_briefs', 'customer_notes'];
-/** Deleting a memory that backs an object nulls the object's link, and no restore can repair it, so no automatic pass may. */
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL);
+ * tests/dormant-memories.test.ts pins it to the schema. */
+export const MEMORY_BACKED_TABLES = [
+    'predictions',
+    'decisions',
+    'incidents',
+    'processes',
+    'policies',
+    'skills',
+    'project_briefs',
+    'customer_notes',
+];
+/** Deleting a memory that backs an object nulls the object's link, and no restore can repair it, so no automatic pass
+ * may. */
 const AUTOMATIC_DELETE_SQL = `${AUTO_DELETABLE_SQL}${MEMORY_BACKED_TABLES.map((t) => ` AND NOT EXISTS (SELECT 1 FROM ${t} WHERE ${t}.memory_id = memories.id)`).join('')}`;
-/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing from an older schema is skipped. */
+/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing
+ * from an older schema is skipped. */
 export function memoriesBackingObjects(hippoRoot) {
     return onHandle(hippoRoot, (db) => {
         return memoriesBackingObjectsOn(db);
@@ -57,8 +69,9 @@ function deleteMemoryRow(db, sql, id) {
         throw isRawTriggerAbort(cause) ? new RawAppendOnlyError(cause) : cause;
     }
 }
-/** db-scoped delete core, composable inside a caller's transaction; NO filesystem I/O, mirrors are written post-commit. `suppressForgetAudit` is set by
- * rejectValue and resolveConflict (own audit row). Returns `{tenantId, dagParentId}`, or null if absent or `automatic` refused it. */
+/** db-scoped delete core, composable inside a caller's transaction; NO filesystem I/O, mirrors are written post-commit.
+ * `suppressForgetAudit` is set by rejectValue and resolveConflict (own audit row). Returns `{tenantId, dagParentId}`,
+ * or null if absent or `automatic` refused it. */
 export function deleteEntryCore(db, id, opts) {
     // SAFETY: row's shape matches the three columns named in the SELECT above.
     const row = db
@@ -73,7 +86,12 @@ function deleteTargetRow(db, row, opts) {
         return null;
     deleteFtsRow(db, id);
     if (!opts?.suppressForgetAudit) {
-        audit(db, 'forget', { targetId: id, metadata: opts?.reason ? { reason: opts.reason } : undefined, actor: opts?.actor ?? 'cli', tenantId: row.tenant_id });
+        audit(db, 'forget', {
+            targetId: id,
+            metadata: opts?.reason ? { reason: opts.reason } : undefined,
+            actor: opts?.actor ?? 'cli',
+            tenantId: row.tenant_id,
+        });
     }
     // Forgetting a child of a summary marks the parent dirty. Not atomic with the DELETE, but
     // markSummaryDirtyInTx is idempotent, so the next child mutation re-marks the parent if this fails.
@@ -83,13 +101,15 @@ function deleteTargetRow(db, row, opts) {
     return { tenantId: row.tenant_id ?? DEFAULT_TENANT_ID, dagParentId: row.dag_parent_id ?? null };
 }
 /** Delete an entry from SQLite and mirrors; thin wrapper over `deleteEntryCore` (open, core, mirrors, close).
- * `opts.actor` defaults to 'cli'; the api layer threads `ctx.actor` so HTTP callers land as `api_key:<key_id>` in the audit log. */
+ * `opts.actor` defaults to 'cli'; the api layer threads `ctx.actor` so HTTP callers land as `api_key:<key_id>` in the
+ * audit log. */
 export function deleteEntry(hippoRoot, id, opts) {
     return onHandle(hippoRoot, (db) => {
         return deleteEntryOn(db, hippoRoot, id, opts);
     }, openStore);
 }
-/** deleteEntry on the caller's open store, so a loop of deletes opens the store once; each delete still commits alone. */
+/** deleteEntry on the caller's open store, so a loop of deletes opens the store once; each delete still commits
+ * alone. */
 function deleteEntryOn(db, hippoRoot, id, opts) {
     const result = withWriteScope(db, 'delete_entry', () => deleteEntryCore(db, id, opts));
     if (!result)
@@ -97,8 +117,9 @@ function deleteEntryOn(db, hippoRoot, id, opts) {
     purgeMirrorBestEffort(hippoRoot, id, false, 'deleteEntry');
     return true;
 }
-/** deleteEntry with `automatic` for each removal and its own forget row and reason, all in one transaction after one read of the id set.
- *  Returns the ids deleted, in `removals` order; a missing, repeated, pinned, raw or object-backing id is left out. */
+/** deleteEntry with `automatic` for each removal and its own forget row and reason, all in one transaction after one
+ * read of the id set. Returns the ids deleted, in `removals` order; a missing, repeated, pinned, raw or object-backing
+ * id is left out. */
 export function deleteEntriesAutomatically(hippoRoot, removals, actor) {
     if (removals.length === 0)
         return [];
@@ -119,7 +140,8 @@ function selectDeleteTargets(db, ids) {
     const rows = new Map();
     for (const chunk of chunked([...new Set(ids)])) {
         // SAFETY: rows' shape matches the three columns named in the SELECT.
-        const found = db.prepare(`SELECT id, tenant_id, dag_parent_id FROM memories WHERE id IN (${placeholders(chunk.length)})`)
+        const found = db
+            .prepare(`SELECT id, tenant_id, dag_parent_id FROM memories WHERE id IN (${placeholders(chunk.length)})`)
             .all(...chunk);
         for (const row of found)
             rows.set(row.id, row);
@@ -137,8 +159,9 @@ function mergeOwnChanges(base, ours, live) {
     }
     return row;
 }
-/** Writes, deletes and dormant moves in one transaction. With `snapshot`, a write keeps only the fields the caller changed and never resurrects a gone row.
- * Dormant moves (src/store/dormant.ts) leave `memories` like a delete; both skip rows no longer auto-deletable. Returns ids that left `memories`. */
+/** Writes, deletes and dormant moves in one transaction. With `snapshot`, a write keeps only the fields the caller
+ * changed and never resurrects a gone row. Dormant moves (src/store/dormant.ts) leave `memories` like a delete; both
+ * skip rows no longer auto-deletable. Returns ids that left `memories`. */
 export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
     const dormant = opts?.dormant ?? [];
     if (toWrite.length === 0 && toDeleteIds.length === 0 && dormant.length === 0)
@@ -150,7 +173,8 @@ export function batchWriteAndDelete(hippoRoot, toWrite, toDeleteIds, opts) {
     }, openStore);
 }
 const failedUnits = new WeakMap();
-/** Tags a flush error with the ids of the component it stopped at, for the partial sleep audit row; the first tag wins. */
+/** Tags a flush error with the ids of the component it stopped at, for the partial sleep audit row; the first tag
+ * wins. */
 function noteFailedUnit(err, component) {
     if (!component || failedUnits.has(err))
         return;
@@ -161,8 +185,9 @@ function noteFailedUnit(err, component) {
 export function failedUnitOf(err) {
     return err ? failedUnits.get(err) : undefined;
 }
-/** batchWriteAndDelete on the caller's open store from component `from`, each component whole, closing the transaction at the
- *  first component boundary after `holdMs`. Returns the next component's index and the ids that left `memories`. */
+/** batchWriteAndDelete on the caller's open store from component `from`, each component whole, closing the transaction
+ * at the first component boundary after `holdMs`. Returns the next component's index and the ids that left
+ * `memories`. */
 function batchWriteAndDeleteOn(db, hippoRoot, components, from, opts) {
     const now = opts.clock ?? clock;
     const out = {
@@ -199,7 +224,8 @@ function batchWriteAndDeleteOn(db, hippoRoot, components, from, opts) {
     reportChunk(hippoRoot, out);
     return { next, removedIds: out.removedIds };
 }
-/** One component in the open transaction, in the order a single batch always ran: pin-checked deletes, writes, dormant moves, row deletes. */
+/** One component in the open transaction, in the order a single batch always ran: pin-checked deletes, writes, dormant
+ * moves, row deletes. */
 function applyComponent(db, hippoRoot, component, snapshot, out) {
     // Snapshot every doomed row's dag_parent_id before the deletes: consolidation flushes through here
     // every cycle, so without it parents would never be marked dirty for decay, merge or garbage-collect.
@@ -218,7 +244,8 @@ function applyComponent(db, hippoRoot, component, snapshot, out) {
 /** After COMMIT: warn about refused writes, then sync mirrors once for what landed. */
 function reportChunk(hippoRoot, out) {
     if (out.rejectedSkips > 0) {
-        log.warn(`batchWriteAndDelete: skipped ${out.rejectedSkips} write(s) whose content matches a rejected value (tombstone hit during the batch transaction)`);
+        log.warn(`batchWriteAndDelete: skipped ${out.rejectedSkips} write(s) whose content matches a rejected value (tombstone ` +
+            `hit during the batch transaction)`);
     }
     // A skipped write never landed, so mirroring it would resurrect the text the skip kept out of the DB.
     mirrorBestEffort('markdown mirrors', () => {
@@ -246,10 +273,14 @@ function moveDormantAndDelete(db, dormantMoves, deletableIds, out) {
         out.removedIds.push(id);
     }
 }
-/** The still auto-deletable rows among `ids`, recording each one's DAG parent as dirty. Placeholders come from `ids` itself. */
+/** The still auto-deletable rows among `ids`, recording each one's DAG parent as dirty. Placeholders come from `ids`
+ * itself. */
 function selectAutoDeletableRows(db, ids, dirty) {
     // SAFETY: rows' shape matches the three columns named in the SELECT.
-    const rows = db.prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders(ids.length)}) AND ${AUTOMATIC_DELETE_SQL}`).all(...ids);
+    const rows = db
+        .prepare(`SELECT id, dag_parent_id, tenant_id FROM memories WHERE id IN (${placeholders(ids.length)}) AND ` +
+        `${AUTOMATIC_DELETE_SQL}`)
+        .all(...ids);
     for (const row of rows) {
         if (row.dag_parent_id) {
             dirty.parents.add(row.dag_parent_id);
@@ -285,7 +316,8 @@ function applyBatchWrites(db, stampedWrites, snapshot, out) {
             if (live)
                 fts.staleIds.push(row.id);
         }
-        // Hook for writes: a new child, or a change to what its summary reads, marks the parent dirty; decay alone does not.
+        // Hook for writes: a new child, or a change to what its summary reads, marks the parent dirty; decay alone does
+        // not.
         if (row.dag_parent_id && (!live || SUMMARY_INPUTS.some((k) => row[k] !== live[k]))) {
             dirty.parents.add(row.dag_parent_id);
             dirty.tenantById.set(row.dag_parent_id, row.tenant_id);
@@ -302,7 +334,12 @@ function isRejectedBatchWrite(db, row) {
     }
     catch (err) {
         if (err instanceof RejectedValueError) {
-            audit(db, 'reject_refusal', { targetId: row.id, metadata: { digest: err.digest, reason: err.reason }, actor: 'sleep-batch', tenantId: entryTenantId });
+            audit(db, 'reject_refusal', {
+                targetId: row.id,
+                metadata: { digest: err.digest, reason: err.reason },
+                actor: 'sleep-batch',
+                tenantId: entryTenantId,
+            });
             return true;
         }
         throw err;
@@ -317,8 +354,8 @@ export function deleteEntriesOneByOne(hippoRoot, targets, opts) {
         return targets.map((target) => deleteEntryOn(db, hippoRoot, target.id, { ...opts, reason: target.reason }));
     }, openStore);
 }
-/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids that left `memories`.
- * The snapshot keeps what other writers changed after the caller loaded its rows. */
+/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids
+ * that left `memories`. The snapshot keeps what other writers changed after the caller loaded its rows. */
 export async function commitInChunks(hippoRoot, components, opts) {
     if (components.length === 0)
         return [];
@@ -332,7 +369,11 @@ export async function commitInChunks(hippoRoot, components, opts) {
         while (next < components.length) {
             if (next > 0)
                 await budget.pause(committedAt);
-            const chunk = batchWriteAndDeleteOn(db, hippoRoot, components, next, { snapshot, holdMs: budget.holdMs, clock: budget.clock });
+            const chunk = batchWriteAndDeleteOn(db, hippoRoot, components, next, {
+                snapshot,
+                holdMs: budget.holdMs,
+                clock: budget.clock,
+            });
             committedAt = budget.clock();
             next = chunk.next;
             for (const id of chunk.removedIds)

package/dist/store/delivery-recorder.d.ts

@@ -12,8 +12,8 @@ export type DeliveryPool = 'pin' | 'recent' | 'prompt-recall' | 'strength' | 'se
 export type DeliveryStage = 'load' | 'eligible' | 'gate' | 'budget' | 'limit' | 'final';
 export type DeliveryOutcome = 'emitted' | 'reused' | 'rejected';
 export type DeliveryRejectReason = 'budget' | 'gate-below-threshold' | 'gate-max-items' | 'duplicate' | 'scope' | 'quality' | 'limit';
-/** Row format version in `delivery_events.ledger_version`: 4 = written by a binary that can write `tool-failure` rows and hashes the
- * store's resolved root. */
+/** Row format version in `delivery_events.ledger_version`: 4 = written by a binary that can write `tool-failure` rows
+ * and hashes the store's resolved root. */
 export declare const DELIVERY_LEDGER_VERSION = 4;
 /** Rejected candidate rows kept per event; the rest only add to `rejected_unlisted`. */
 export declare const DELIVERY_REJECTED_ROW_CAP = 16;
@@ -87,7 +87,8 @@ export interface DeliveryObserver {
     sections(shown: number, dropped: number): void;
     /** Returns `admit`'s own answer unchanged and lets its throws through. */
     watchAdmit(admit: (e: MemoryEntry) => boolean): (e: MemoryEntry) => boolean;
-    /** The loader's quality floor dropped a row admit let through; with prompt recall on, eligibility reports it instead. */
+    /** The loader's quality floor dropped a row admit let through; with prompt recall on, eligibility reports it
+     * instead. */
     qualityDropped(entry: MemoryEntry, isGlobal: boolean): void;
     disabled(): void;
     /** No `pool` means pin or recent by the entry's own flag. */
@@ -123,7 +124,8 @@ export interface DeliveryRecorder extends DeliveryObserver {
     delivered(outcome: DeliveryOutcomeInput): void;
     /** The failure log row id a `tool-failure` event links to; null when the log write threw. */
     logged(failureId: number | null): void;
-    /** Builds the event and hands it to `write` once per call; throws on an injected fault, and writes nothing once broken. */
+    /** Builds the event and hands it to `write` once per call; throws on an injected fault, and writes nothing once
+     * broken. */
     flush(write: (input: DeliveryEventInput) => number | null): void;
 }
 export interface DeliveryRecorderInit {
@@ -134,7 +136,8 @@ export interface DeliveryRecorderInit {
     tenantId: string;
     stdinText?: string;
     envSessionId?: string;
-    /** Set by the caller's runtime flag; Copilot payloads carry hook_event_name too, so inference would say claude-code. */
+    /** Set by the caller's runtime flag; Copilot payloads carry hook_event_name too, so inference would say
+     * claude-code. */
     runtime?: DeliveryRuntime;
     /** Set by hooks that are not prompt or context calls; without it the payload's hook event decides. */
     eventType?: DeliveryEventType;

package/dist/store/delivery-recorder.js

@@ -7,8 +7,8 @@ import { errorMessage, log } from '../util/log.js';
 export const isBoundaryEvent = (type) => type === 'pre-compact' || type === 'compact-resume' || type === 'session-end';
 /** Only the per-prompt calls keep prompt facts; a boundary or a `hippo context` run is not a prompt. */
 const carriesPrompt = (type) => type === 'prompt-submit' || type === 'pinned-manual';
-/** Row format version in `delivery_events.ledger_version`: 4 = written by a binary that can write `tool-failure` rows and hashes the
- * store's resolved root. */
+/** Row format version in `delivery_events.ledger_version`: 4 = written by a binary that can write `tool-failure` rows
+ * and hashes the store's resolved root. */
 export const DELIVERY_LEDGER_VERSION = 4;
 /** Rejected candidate rows kept per event; the rest only add to `rejected_unlisted`. */
 export const DELIVERY_REJECTED_ROW_CAP = 16;
@@ -145,37 +145,52 @@ function buildEvent(init, payload, state, ts, startedMs) {
         candidates: rows,
     };
 }
+function markQualityDropped(state, ...[e, isGlobal]) {
+    state.filtered.add(e.id);
+    if (!state.candidates.has(e.id)) {
+        state.candidates.set(e.id, {
+            id: e.id,
+            sourceStore: storeOf(isGlobal),
+            pool: 'recent',
+            stage: null,
+            reason: null,
+            score: null,
+            tokens: null,
+        });
+    }
+    rejectId(state, e.id, { stage: 'load', reason: 'quality', score: null, tokens: null });
+}
+function offerEntries(state, ...[entries, isGlobal, pool]) {
+    for (const e of entries) {
+        const held = state.candidates.get(e.id);
+        const wanted = pool ?? (e.pinned ? 'pin' : 'recent');
+        // A loaded recent row the prompt-recall gate then judges belongs to that pool.
+        const relabel = held !== undefined && held.reason === null && held.pool === 'recent' && wanted === 'prompt-recall';
+        if (held !== undefined && !relabel)
+            continue;
+        state.candidates.set(e.id, {
+            id: e.id,
+            sourceStore: storeOf(isGlobal),
+            pool: wanted,
+            stage: null,
+            reason: null,
+            score: null,
+            tokens: null,
+        });
+    }
+}
 /** The candidate-tracking half of the observer, each method run through `guard`. */
 function candidateMethods(state, guard) {
     return {
-        qualityDropped: (e, isGlobal) => guard(() => {
-            state.filtered.add(e.id);
-            if (!state.candidates.has(e.id)) {
-                state.candidates.set(e.id, {
-                    id: e.id, sourceStore: storeOf(isGlobal), pool: 'recent', stage: null, reason: null, score: null, tokens: null,
-                });
-            }
-            rejectId(state, e.id, { stage: 'load', reason: 'quality', score: null, tokens: null });
-        }),
-        offer: (entries, isGlobal, pool) => guard(() => {
-            for (const e of entries) {
-                const held = state.candidates.get(e.id);
-                const wanted = pool ?? (e.pinned ? 'pin' : 'recent');
-                // A loaded recent row the prompt-recall gate then judges belongs to that pool.
-                const relabel = held !== undefined && held.reason === null && held.pool === 'recent' && wanted === 'prompt-recall';
-                if (held !== undefined && !relabel)
-                    continue;
-                state.candidates.set(e.id, {
-                    id: e.id, sourceStore: storeOf(isGlobal), pool: wanted, stage: null, reason: null, score: null, tokens: null,
-                });
-            }
-        }),
+        qualityDropped: (...args) => guard(() => markQualityDropped(state, ...args)),
+        offer: (...args) => guard(() => offerEntries(state, ...args)),
         reject: (e, stage, reason, score, tokens) => guard(() => rejectId(state, e.id, { stage, reason, score: score ?? null, tokens: tokens ?? null })),
         dropMissing: (before, after, stage, reason) => guard(() => {
             const kept = new Set(after.map((e) => e.id));
-            for (const e of before)
+            for (const e of before) {
                 if (!kept.has(e.id))
                     rejectId(state, e.id, { stage, reason, score: null, tokens: null });
+            }
         }),
         gated: (prompt, items, gate, kept) => guard(() => {
             const keptIds = new Set(kept.map((g) => g.item.id));
@@ -184,30 +199,53 @@ function candidateMethods(state, guard) {
                     continue;
                 const { score, shared } = scoreOverlap(prompt, c.tokens, gate.metric);
                 const cleared = score >= gate.threshold && shared >= gate.minShared;
-                rejectId(state, c.id, { stage: 'gate', reason: cleared ? 'gate-max-items' : 'gate-below-threshold', score, tokens: null });
+                rejectId(state, c.id, {
+                    stage: 'gate',
+                    reason: cleared ? 'gate-max-items' : 'gate-below-threshold',
+                    score,
+                    tokens: null,
+                });
             }
         }),
         selected: (items) => guard(() => {
             state.picked.clear();
             items.forEach((r, i) => {
                 state.picked.set(r.entry.id, {
-                    entry: r.entry, rank: i + 1, score: r.score, tokens: r.tokens,
-                    sourceStore: storeOf(r.isGlobal), promptRecall: r.promptRecall === true,
+                    entry: r.entry,
+                    rank: i + 1,
+                    score: r.score,
+                    tokens: r.tokens,
+                    sourceStore: storeOf(r.isGlobal),
+                    promptRecall: r.promptRecall === true,
                 });
             });
         }),
     };
 }
+function newRecorderState() {
+    return {
+        candidates: new Map(),
+        picked: new Map(),
+        filtered: new Set(),
+        facts: null,
+        shown: 0,
+        dropped: 0,
+        disabledSeen: false,
+        outcome: { state: 'empty' },
+        queryHash: null,
+        recallTraceId: null,
+        failureId: null,
+        broken: null,
+        flushed: false,
+    };
+}
 /** A recorder for one call; every observer method is guarded, and a throw marks it broken instead of escaping. */
 export function createDeliveryRecorder(init) {
     const startedMs = Date.now();
     const ts = evalNow().toISOString();
     const fault = init.fault ?? null;
     const payload = readPayload(init);
-    const state = {
-        candidates: new Map(), picked: new Map(), filtered: new Set(), facts: null, shown: 0, dropped: 0,
-        disabledSeen: false, outcome: { state: 'empty' }, queryHash: null, recallTraceId: null, failureId: null, broken: null, flushed: false,
-    };
+    const state = newRecorderState();
     const guard = guardFor(state, fault);
     const { qualityDropped, offer, reject, dropMissing, gated, selected } = candidateMethods(state, guard);
     return {

package/dist/store/descendant-page.d.ts

@@ -7,6 +7,7 @@ export interface PagedWalk {
     readonly depth: number;
     readonly page: DescendantPage;
 }
-/** The walk `summaryWithDescendants` documents, with `levels` cut to the first `page.rows` rows and each level's full count in `sizes`. */
+/** The walk `summaryWithDescendants` documents, with `levels` cut to the first `page.rows` rows and each level's full
+ * count in `sizes`. */
 export declare function pagedDescendants(db: DatabaseSyncLike, walk: PagedWalk, summaryAdmitted: boolean): SummaryDescendants;
 //# sourceMappingURL=descendant-page.d.ts.map

package/dist/store/descendant-page.js

@@ -3,7 +3,8 @@ import { chunked } from '../util/chunked.js';
 import { MEMORY_SELECT_COLUMNS, rowToEntry } from './rows.js';
 import { placeholders } from '../util/sql.js';
 const marks = (ids) => placeholders(ids.length);
-/** The walk `summaryWithDescendants` documents, with `levels` cut to the first `page.rows` rows and each level's full count in `sizes`. */
+/** The walk `summaryWithDescendants` documents, with `levels` cut to the first `page.rows` rows and each level's full
+ * count in `sizes`. */
 export function pagedDescendants(db, walk, summaryAdmitted) {
     const sizes = [];
     const levels = [];
@@ -27,7 +28,10 @@ function keyedLevel(db, walk, parents, at) {
     const byParent = new Map();
     for (const chunk of chunked([...parents])) {
         // SAFETY: the SELECT names exactly ChildKey's four columns, and the WHERE keeps dag_parent_id a string.
-        const keys = db.prepare(`SELECT id, dag_parent_id, scope, origin_project FROM memories WHERE dag_parent_id IN (${marks(chunk)}) AND ${TENANT_IS} ORDER BY created ASC, id ASC`).all(...chunk, walk.tenantId);
+        const keys = db
+            .prepare(`SELECT id, dag_parent_id, scope, origin_project FROM memories WHERE dag_parent_id IN (${marks(chunk)}) AND ` +
+            `${TENANT_IS} ORDER BY created ASC, id ASC`)
+            .all(...chunk, walk.tenantId);
         for (const key of keys) {
             const bucket = byParent.get(key.dag_parent_id);
             if (bucket)
@@ -49,14 +53,18 @@ function keyedLevel(db, walk, parents, at) {
     const whole = selectEntriesByIds(db, shown, walk.tenantId);
     return { ids, size: ids.length, rows: shown.flatMap((id) => whole.get(id) ?? []) };
 }
-/** The last level counted in SQL and read up to `room` rows; null when a row there is refused, which only the keyed read can leave out.
- *  A row has one parent and a parent is read at one level, so the summary is the only row an earlier level can already hold. */
+/** The last level counted in SQL and read up to `room` rows; null when a row there is refused, which only the keyed
+ * read can leave out. A row has one parent and a parent is read at one level, so the summary is the only row an earlier
+ * level can already hold. */
 function countedLevel(db, walk, parents, room) {
     const perParent = new Map();
     for (const chunk of chunked([...parents])) {
         // SAFETY: the SELECT names exactly ChildGroup's four fields, and the WHERE keeps dag_parent_id a string.
-        const groups = db.prepare(`SELECT dag_parent_id, scope, origin_project, COUNT(*) AS n FROM memories ` +
-            `WHERE dag_parent_id IN (${marks(chunk)}) AND ${TENANT_IS} AND id <> ? GROUP BY dag_parent_id, scope, origin_project`).all(...chunk, walk.tenantId, walk.summary.id);
+        const groups = db
+            .prepare(`SELECT dag_parent_id, scope, origin_project, COUNT(*) AS n FROM memories ` +
+            `WHERE dag_parent_id IN (${marks(chunk)}) AND ${TENANT_IS} AND id <> ? GROUP BY dag_parent_id, scope, ` +
+            `origin_project`)
+            .all(...chunk, walk.tenantId, walk.summary.id);
         for (const group of groups) {
             if (!walk.page.admit(group))
                 return null;
@@ -66,7 +74,11 @@ function countedLevel(db, walk, parents, room) {
     let size = 0;
     for (const n of perParent.values())
         size += n;
-    return { ids: [], size, rows: firstRows(db, walk, parents.filter((id) => perParent.has(id)), { perParent, room }) };
+    return {
+        ids: [],
+        size,
+        rows: firstRows(db, walk, parents.filter((id) => perParent.has(id)), { perParent, room }),
+    };
 }
 // Every parent before the one the page ends in is read whole in one statement; that last one is read under a LIMIT.
 function firstRows(db, walk, parents, at) {
@@ -88,8 +100,11 @@ function childrenInOrder(db, walk, parents, limit) {
     const byParent = new Map();
     for (const chunk of chunked([...parents])) {
         // SAFETY: selects exactly MEMORY_SELECT_COLUMNS, matching MemoryRow's field set.
-        const rows = db.prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE dag_parent_id IN (${marks(chunk)}) AND ${TENANT_IS} AND id <> ? ` +
-            `ORDER BY created ASC, id ASC LIMIT ?`).all(...chunk, walk.tenantId, walk.summary.id, limit);
+        const rows = db
+            .prepare(`SELECT ${MEMORY_SELECT_COLUMNS} FROM memories WHERE dag_parent_id IN (${marks(chunk)}) AND ${TENANT_IS} AND ` +
+            `id <> ? ` +
+            `ORDER BY created ASC, id ASC LIMIT ?`)
+            .all(...chunk, walk.tenantId, walk.summary.id, limit);
         for (const row of rows) {
             const bucket = byParent.get(row.dag_parent_id ?? '');
             if (bucket)

package/dist/store/diagnostics.d.ts

@@ -42,6 +42,7 @@ export interface StoreInventory {
     /** Row count by table name; null for a table that cannot be counted. */
     readonly tables: JsonObject;
 }
-/** Schema version, oldest allowed binary and row count of every table, for a support bundle; never reads a memory column. */
+/** Schema version, oldest allowed binary and row count of every table, for a support bundle; never reads a memory
+ * column. */
 export declare function readStoreInventory(hippoRoot: string): StoreInventory;
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/store/diagnostics.js

@@ -30,7 +30,8 @@ export function readStoreHealth(hippoRoot, cutoffs) {
         };
     }, openHippoDbReadOnly);
 }
-/** Schema version, oldest allowed binary and row count of every table, for a support bundle; never reads a memory column. */
+/** Schema version, oldest allowed binary and row count of every table, for a support bundle; never reads a memory
+ * column. */
 export function readStoreInventory(hippoRoot) {
     return onHandle(hippoRoot, (db) => {
         const schemaVersion = getSchemaVersion(db);

package/dist/store/doctor-reads.d.ts

@@ -4,7 +4,8 @@ export interface CompactionCounts {
     summarised: number;
     started: number;
 }
-/** Compaction records in all, those with a summary whose memories never got saved, and those still without a summary; each cutoff is an ISO time. */
+/** Compaction records in all, those with a summary whose memories never got saved, and those still without a summary;
+ * each cutoff is an ISO time. */
 export declare function compactionCountsAt(db: DatabaseSyncLike, stuckBefore: string, transcriptFloor: string): CompactionCounts;
 export interface TokenTally {
     injected: number;

package/dist/store/doctor-reads.js

@@ -1,11 +1,19 @@
-/** Compaction records in all, those with a summary whose memories never got saved, and those still without a summary; each cutoff is an ISO time. */
+/** Compaction records in all, those with a summary whose memories never got saved, and those still without a summary;
+ * each cutoff is an ISO time. */
 export function compactionCountsAt(db, stuckBefore, transcriptFloor) {
     // SAFETY: COUNT aggregate row.
-    const row = db.prepare(`SELECT COUNT(*) AS total,
+    const row = db
+        .prepare(`SELECT COUNT(*) AS total,
               COUNT(CASE WHEN status = 'summarised' AND summarised_at < ? THEN 1 END) AS summarised,
-              COUNT(CASE WHEN status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL THEN 1 END) AS started
-       FROM compactions`).get(stuckBefore, stuckBefore, transcriptFloor);
-    return { total: Number(row?.total ?? 0), summarised: Number(row?.summarised ?? 0), started: Number(row?.started ?? 0) };
+              COUNT(CASE WHEN status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL
+              THEN 1 END) AS started
+       FROM compactions`)
+        .get(stuckBefore, stuckBefore, transcriptFloor);
+    return {
+        total: Number(row?.total ?? 0),
+        summarised: Number(row?.summarised ?? 0),
+        started: Number(row?.started ?? 0),
+    };
 }
 /** Memory blocks injected since `sinceIso`, the tokens they sent and the tokens later model calls re-read. */
 export function tokenTallySince(db, sinceIso) {

package/dist/store/dormant.d.ts

@@ -1,12 +1,14 @@
-/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`; `retentionDays` bounds how long one is kept).
- * Content stays in `dormant_memories` (schema v44) and the `memories` row goes, so every reader of `memories` stops seeing it, as if deleted.
- * Not the raw archive (`raw_archive`, `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
+/** Dormant memories: what sleep does with a faded memory instead of deleting it (config `dormant.enabled`;
+ * `retentionDays` bounds how long one is kept). Content stays in `dormant_memories` (schema v44) and the `memories` row
+ * goes, so every reader of `memories` stops seeing it, as if deleted. Not the raw archive (`raw_archive`,
+ * `archiveRawMemory`), which keeps metadata only. db-taking helpers leave the handle and transaction to the caller. */
 import { type DatabaseSyncLike } from '../db/index.js';
 import type { MemoryEntry } from '../core/memory.js';
 import type { SqlFragment } from './rule-sql.js';
 import type { WriteBudget } from '../util/write-budget.js';
-/** Why a memory went dormant: sleep's decay pass, an imported agent memory whose note was deleted, `hippo projects repair`
- * splitting a two-project merge, or `hippo audit repair` setting aside an automatic memory with a certain defect. */
+/** Why a memory went dormant: sleep's decay pass, an imported agent memory whose note was deleted, `hippo projects
+ * repair` splitting a two-project merge, or `hippo audit repair` setting aside an automatic memory with a certain
+ * defect. */
 export type DormantReason = 'decay' | 'source-deleted' | 'project-repair' | 'quality-repair';
 /** One memory that sleep is moving out of active memory into the dormant store. */
 export interface DormantMove {
@@ -38,7 +40,8 @@ export interface ListDormantOpts {
     /** Maximum rows returned, newest first. Default 20. */
     limit?: number;
 }
-/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same transaction. */
+/** Insert (or refresh) the dormant snapshot for `move.entry`; the caller deletes the `memories` row in the same
+ * transaction. */
 export declare function insertDormantRow(db: DatabaseSyncLike, move: DormantMove): void;
 /** A dormant memory's stored snapshot plus when and why it went dormant. */
 export interface DormantSnapshot {
@@ -57,9 +60,11 @@ export declare function dormantSnapshotsBySourcePrefix(db: DatabaseSyncLike, ten
 export declare function replaceDormantEntry(db: DatabaseSyncLike, tenantId: string, id: string, entry: MemoryEntry): void;
 /** Delete a tenant's dormant memory. Returns false when there was none. */
 export declare function deleteDormantRow(db: DatabaseSyncLike, tenantId: string, id: string): boolean;
-/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot linger; returns their ids. */
+/** Deletes the tenant's dormant copies of a rejected digest whose snapshot scope `inReach` admits, so the value cannot
+ * linger; returns their ids. */
 export declare function purgeDormantByDigest(db: DatabaseSyncLike, tenantId: string, digest: string, inReach: (scope: string | null) => boolean): string[];
-/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under `dryRun` how many would. */
+/** Deletes for good every memory that went dormant before `cutoffIso`, on one handle; returns how many went, or under
+ * `dryRun` how many would. */
 export declare function expireDormantBefore(hippoRoot: string, cutoffIso: string, opts: {
     dryRun: boolean;
     budget: WriteBudget;
@@ -69,7 +74,8 @@ export declare function expireDormantBefore(hippoRoot: string, cutoffIso: string
 export declare function loadDormantMemories(hippoRoot: string, tenantId: string, opts?: ListDormantOpts, admit?: SqlFragment): DormantMemory[];
 /** Whether a tenant holds a dormant memory with this id whose scope `admit` passes, read on a handle of its own. */
 export declare function holdsDormantMemory(hippoRoot: string, tenantId: string, id: string, admit?: SqlFragment): boolean;
-/** One restore as the store applies it. The two functions are the caller's policy over plain rows; neither is handed the handle. */
+/** One restore as the store applies it. The two functions are the caller's policy over plain rows; neither is handed
+ * the handle. */
 export interface DormantRestore {
     readonly tenantId: string;
     readonly id: string;
@@ -89,7 +95,8 @@ export type DormantRestoreOutcome = {
 } | {
     readonly status: 'active';
 };
-/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit together, then its mirrors are written. */
+/** Brings one dormant memory back on a single handle: the live row, the dormant delete and the audit row commit
+ * together, then its mirrors are written. */
 export declare function restoreDormantMemory(hippoRoot: string, restore: DormantRestore): DormantRestoreOutcome;
 /** One permanent delete of a dormant memory. */
 export interface DormantForget {
@@ -100,6 +107,7 @@ export interface DormantForget {
     /** The scopes this caller may touch; a row outside them reads as missing. */
     readonly admit: SqlFragment;
 }
-/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it holds none `admit` passes. */
+/** Deletes a tenant's dormant memory for good and writes its `forget` audit row, on a single handle; false when it
+ * holds none `admit` passes. */
 export declare function forgetDormantMemory(hippoRoot: string, forget: DormantForget): boolean;
 //# sourceMappingURL=dormant.d.ts.map