hippo-memory 1.72.0 → 2.1.0

package/dist/store/cards.d.ts

@@ -1,5 +1,7 @@
+import { type DatabaseSyncLike } from '../db/index.js';
 import { SessionHandoff, HandoffOutcome } from '../core/handoff.js';
 import { Card, CardStatus, CardRun, CardComment } from '../core/card.js';
+export declare function loadCardRow(db: DatabaseSyncLike, tenantId: string, id: string): Card | null;
 export interface TransitionCardOptions {
     readonly from: CardStatus[];
     readonly to: CardStatus;
@@ -29,34 +31,46 @@ export declare function loadCardDeps(hippoRoot: string, tenantId: string, id: st
     parents: string[];
     children: string[];
 };
+export declare function loadCardDepsAt(db: DatabaseSyncLike, tenantId: string, id: string): {
+    parents: string[];
+    children: string[];
+};
 /** Returns this card's run history, most recent first. */
 export declare function loadCardRuns(hippoRoot: string, tenantId: string, id: string): CardRun[];
+export declare function loadCardRunsAt(db: DatabaseSyncLike, tenantId: string, id: string): CardRun[];
 /** Returns this card's comments, most recent first. */
 export declare function loadCardComments(hippoRoot: string, tenantId: string, id: string): CardComment[];
+export declare function loadCardCommentsAt(db: DatabaseSyncLike, tenantId: string, id: string): CardComment[];
 /** Read side of the card <-> handoff round trip: the newest handoff filed against this card. */
 export declare function loadLatestHandoffForCard(hippoRoot: string, tenantId: string, cardId: string): SessionHandoff | null;
-/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id;
- * returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
+export declare function loadLatestHandoffForCardAt(db: DatabaseSyncLike, tenantId: string, cardId: string): SessionHandoff | null;
+/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown
+ * card id; returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new
+ * run's id as runId. */
 export declare function claimCard(hippoRoot: string, tenantId: string, id: string, runtime: string, sessionId?: string): (Card & {
     runId: number;
 }) | null;
-/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an
- * unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
+/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws
+ * on an unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId
+ * is its live run. */
 export declare function heartbeatCard(hippoRoot: string, tenantId: string, id: string, runId: number): Card | null;
 /** Requires the card be running; closes the live run as blocked and files reason as a comment. Throws on an unknown
  * card id; returns null for a card not running. When runId is given, returns null unless it is the card's live run. */
 export declare function blockCard(hippoRoot: string, tenantId: string, id: string, reason: string, runId?: number): Card | null;
-/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is
- * given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
+/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When
+ * runId is given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card
+ * not running. */
 export declare function reviewCard(hippoRoot: string, tenantId: string, id: string, runId?: number): Card | null;
-/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all done; 'failure'/'partial' shelves it.
- * Throws on an unknown card id; returns null for a card not in review, or when `runId` is given and is not the card's live run. */
+/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all
+ * done; 'failure'/'partial' shelves it. Throws on an unknown card id; returns null for a card not in review, or when
+ * `runId` is given and is not the card's live run. */
 export declare function completeCard(hippoRoot: string, tenantId: string, id: string, outcome: HandoffOutcome, runId?: number): {
     card: Card;
     promotedChildren: string[];
 } | null;
-/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live
- * run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
+/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes
+ * its live run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card
+ * ids in id order. */
 export declare function reclaimExpiredCards(hippoRoot: string, tenantId: string): string[];
 /** Appends a comment to cardId in any card status; throws if cardId is not a card of this tenant. */
 export declare function addCardComment(hippoRoot: string, tenantId: string, cardId: string, author: string, body: string): CardComment;

package/dist/store/cards.js

@@ -1,12 +1,14 @@
 import { generateId } from '../core/memory.js';
 import { withWriteScope, withWriteScopeOr } from '../db/index.js';
-import { rowToSessionHandoff, isHandoffOutcome } from '../core/handoff.js';
+import { rowToSessionHandoff, isHandoffOutcome, } from '../core/handoff.js';
 import { CARD_LEASE_MS, assertCardTransition } from '../core/card.js';
 import { assertTenantId } from './tenant.js';
 import { onHandle, openStore } from './open.js';
 import { chunked } from '../util/chunked.js';
 import { HANDOFF_COLUMNS } from './handoffs.js';
-const CARD_COLUMNS = 'id, title, status, assignee_runtime, repo, contract, budget, lease_until, heartbeat_at, created_at, updated_at, tenant_id, scope';
+import { placeholders } from '../util/sql.js';
+const CARD_COLUMNS = 'id, title, status, assignee_runtime, repo, contract, budget, lease_until, heartbeat_at, created_at, updated_at, ' +
+    'tenant_id, scope';
 function rowToCard(row) {
     return {
         id: row.id,
@@ -24,7 +26,7 @@ function rowToCard(row) {
         scope: row.scope,
     };
 }
-function loadCardRow(db, tenantId, id) {
+export function loadCardRow(db, tenantId, id) {
     // SAFETY: row's shape matches CARD_COLUMNS; status only ever holds a CardStatus value.
     const row = db.prepare(`SELECT ${CARD_COLUMNS} FROM cards WHERE id = ? AND tenant_id = ?`).get(id, tenantId);
     return row ? rowToCard(row) : null;
@@ -45,10 +47,12 @@ function rowToCardComment(row) {
 }
 function insertCardComment(db, tenantId, cardId, author, body) {
     const now = new Date().toISOString();
-    const result = db.prepare(`
+    const result = db
+        .prepare(`
     INSERT INTO card_comments (card_id, author, body, created_at, tenant_id)
     SELECT ?, ?, ?, ?, ? WHERE EXISTS (SELECT 1 FROM cards WHERE id = ? AND tenant_id = ?)
-  `).run(cardId, author, body, now, tenantId, cardId, tenantId);
+  `)
+        .run(cardId, author, body, now, tenantId, cardId, tenantId);
     if (Number(result.changes ?? 0) === 0) {
         throw new Error(`unknown card id: ${cardId}`);
     }
@@ -66,7 +70,9 @@ function assertRunId(runId) {
 // A second run that has not ended means a corrupt store; throw rather than guess which run the caller means.
 function isLiveRun(db, tenantId, cardId, runId) {
     // SAFETY: rows' shape matches the single `id` column named in the SELECT below.
-    const rows = db.prepare(`SELECT id FROM card_runs WHERE tenant_id = ? AND card = ? AND ended IS NULL`).all(tenantId, cardId);
+    const rows = db
+        .prepare(`SELECT id FROM card_runs WHERE tenant_id = ? AND card = ? AND ended IS NULL`)
+        .all(tenantId, cardId);
     if (rows.length > 1) {
         throw new Error(`card ${cardId} has ${rows.length} runs that have not ended`);
     }
@@ -88,10 +94,12 @@ function transitionCards(db, tenantId, cardIds, options) {
     const now = new Date().toISOString();
     // Lease columns follow status: set on the move to running, cleared on every other move (rule 15).
     const lease = to === 'running' ? [leaseUntilFrom(now), now] : [null, null];
-    const fromPlaceholders = from.map(() => '?').join(', ');
+    const fromPlaceholders = placeholders(from.length);
     const sql = `
-    UPDATE cards SET status = ?, updated_at = ?, lease_until = ?, heartbeat_at = ?${extra?.setSql ? `, ${extra.setSql}` : ''}
-    WHERE id IN (${cardIds.map(() => '?').join(', ')}) AND tenant_id = ? AND status IN (${fromPlaceholders})${extra?.whereSql ? ` AND ${extra.whereSql}` : ''}
+    UPDATE cards SET status = ?, updated_at = ?, lease_until = ?, heartbeat_at =
+    ?${extra?.setSql ? `, ${extra.setSql}` : ''}
+    WHERE id IN (${placeholders(cardIds.length)}) AND tenant_id = ? AND status IN
+    (${fromPlaceholders})${extra?.whereSql ? ` AND ${extra.whereSql}` : ''}
   `;
     const params = [to, now, ...lease, ...(extra?.params ?? []), ...cardIds, tenantId, ...from];
     const result = db.prepare(sql).run(...params);
@@ -130,13 +138,14 @@ export function createCard(hippoRoot, tenantId, input) {
         return loadCardRow(db, tenantId, id);
     }, openStore);
 }
-/** Whether every dependsOn card is done, true for none; throws on an id that is no card of the tenant. Call inside the write scope. */
+/** Whether every dependsOn card is done, true for none; throws on an id that is no card of the tenant. Call inside the
+ * write scope. */
 function everyParentDone(db, tenantId, dependsOn) {
     if (dependsOn.length === 0)
         return true;
-    const placeholders = dependsOn.map(() => '?').join(', ');
+    const marks = placeholders(dependsOn.length);
     // SAFETY: rows' shape matches the two columns named in the SELECT below.
-    const rows = db.prepare(`SELECT id, status FROM cards WHERE tenant_id = ? AND id IN (${placeholders})`).all(tenantId, ...dependsOn);
+    const rows = db.prepare(`SELECT id, status FROM cards WHERE tenant_id = ? AND id IN (${marks})`).all(tenantId, ...dependsOn);
     const found = new Map(rows.map((r) => [r.id, r.status]));
     // Pre-check before any write: a typo'd --depends-on can never commit a card row.
     for (const parentId of dependsOn) {
@@ -173,52 +182,57 @@ export function listCards(hippoRoot, tenantId, opts = {}) {
 /** Returns this card's parent and child ids from card_deps. */
 export function loadCardDeps(hippoRoot, tenantId, id) {
     assertTenantId('loadCardDeps', tenantId);
-    return onHandle(hippoRoot, (db) => {
-        // SAFETY: rows' shape matches the single `parent` column named in the SELECT below.
-        const parents = db.prepare(`SELECT parent FROM card_deps WHERE tenant_id = ? AND child = ?`).all(tenantId, id).map((r) => r.parent);
-        // SAFETY: rows' shape matches the single `child` column named in the SELECT below.
-        const children = db.prepare(`SELECT child FROM card_deps WHERE tenant_id = ? AND parent = ?`).all(tenantId, id).map((r) => r.child);
-        return { parents, children };
-    }, openStore);
+    return onHandle(hippoRoot, (db) => loadCardDepsAt(db, tenantId, id), openStore);
+}
+export function loadCardDepsAt(db, tenantId, id) {
+    // SAFETY: rows' shape matches the single `parent` column named in the SELECT below.
+    const parents = db.prepare(`SELECT parent FROM card_deps WHERE tenant_id = ? AND child = ?`).all(tenantId, id).map((r) => r.parent);
+    // SAFETY: rows' shape matches the single `child` column named in the SELECT below.
+    const children = db.prepare(`SELECT child FROM card_deps WHERE tenant_id = ? AND parent = ?`).all(tenantId, id).map((r) => r.child);
+    return { parents, children };
 }
 /** Returns this card's run history, most recent first. */
 export function loadCardRuns(hippoRoot, tenantId, id) {
     assertTenantId('loadCardRuns', tenantId);
-    return onHandle(hippoRoot, (db) => {
-        // SAFETY: rows' shape matches CardRunRow.
-        const rows = db.prepare(`
-      SELECT id, card, runtime, session_id, started, ended, outcome
-      FROM card_runs WHERE tenant_id = ? AND card = ? ORDER BY started DESC, id DESC
-    `).all(tenantId, id);
-        return rows.map(rowToCardRun);
-    }, openStore);
+    return onHandle(hippoRoot, (db) => loadCardRunsAt(db, tenantId, id), openStore);
+}
+export function loadCardRunsAt(db, tenantId, id) {
+    // SAFETY: rows' shape matches CardRunRow.
+    const rows = db.prepare(`
+    SELECT id, card, runtime, session_id, started, ended, outcome
+    FROM card_runs WHERE tenant_id = ? AND card = ? ORDER BY started DESC, id DESC
+  `).all(tenantId, id);
+    return rows.map(rowToCardRun);
 }
 /** Returns this card's comments, most recent first. */
 export function loadCardComments(hippoRoot, tenantId, id) {
     assertTenantId('loadCardComments', tenantId);
-    return onHandle(hippoRoot, (db) => {
-        // SAFETY: rows' shape matches CardCommentRow.
-        const rows = db.prepare(`
-      SELECT id, card_id, author, body, created_at
-      FROM card_comments WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC
-    `).all(tenantId, id);
-        return rows.map(rowToCardComment);
-    }, openStore);
+    return onHandle(hippoRoot, (db) => loadCardCommentsAt(db, tenantId, id), openStore);
+}
+export function loadCardCommentsAt(db, tenantId, id) {
+    // SAFETY: rows' shape matches CardCommentRow.
+    const rows = db.prepare(`
+    SELECT id, card_id, author, body, created_at
+    FROM card_comments WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC
+  `).all(tenantId, id);
+    return rows.map(rowToCardComment);
 }
 /** Read side of the card <-> handoff round trip: the newest handoff filed against this card. */
 export function loadLatestHandoffForCard(hippoRoot, tenantId, cardId) {
     assertTenantId('loadLatestHandoffForCard', tenantId);
-    return onHandle(hippoRoot, (db) => {
-        // SAFETY: row's shape matches HANDOFF_COLUMNS.
-        const row = db.prepare(`
-      SELECT ${HANDOFF_COLUMNS} FROM session_handoffs
-      WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC LIMIT 1
-    `).get(tenantId, cardId);
-        return row ? rowToSessionHandoff(row) : null;
-    }, openStore);
+    return onHandle(hippoRoot, (db) => loadLatestHandoffForCardAt(db, tenantId, cardId), openStore);
+}
+export function loadLatestHandoffForCardAt(db, tenantId, cardId) {
+    // SAFETY: row's shape matches HANDOFF_COLUMNS.
+    const row = db.prepare(`
+    SELECT ${HANDOFF_COLUMNS} FROM session_handoffs
+    WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC LIMIT 1
+  `).get(tenantId, cardId);
+    return row ? rowToSessionHandoff(row) : null;
 }
-/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id;
- * returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
+/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown
+ * card id; returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new
+ * run's id as runId. */
 export function claimCard(hippoRoot, tenantId, id, runtime, sessionId) {
     assertTenantId('claimCard', tenantId);
     if (runtime.trim() === '') {
@@ -238,17 +252,20 @@ export function claimCard(hippoRoot, tenantId, id, runtime, sessionId) {
                 return rollback(null);
             }
             const now = new Date().toISOString();
-            const insert = db.prepare(`
+            const insert = db
+                .prepare(`
         INSERT INTO card_runs (card, runtime, session_id, started, created_at, updated_at, tenant_id)
         VALUES (?, ?, ?, ?, ?, ?, ?)
-      `).run(id, runtime, sessionId ?? null, now, now, now, tenantId);
+      `)
+                .run(id, runtime, sessionId ?? null, now, now, now, tenantId);
             return Number(insert.lastInsertRowid ?? 0);
         });
         return runId === null ? null : { ...loadCardRow(db, tenantId, id), runId };
     }, openStore);
 }
-/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an
- * unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
+/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws
+ * on an unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId
+ * is its live run. */
 export function heartbeatCard(hippoRoot, tenantId, id, runId) {
     assertTenantId('heartbeatCard', tenantId);
     assertRunId(runId);
@@ -281,7 +298,13 @@ export function blockCard(hippoRoot, tenantId, id, reason, runId) {
     return onHandle(hippoRoot, (db) => {
         const blocked = withWriteScopeOr(db, 'block_card', (rollback) => {
             const allowed = runId === undefined || isLiveRun(db, tenantId, id, runId);
-            const changes = allowed ? transitionCard(db, tenantId, id, { from: ['running'], to: 'blocked', extra: { setSql: 'assignee_runtime = NULL' } }) : 0;
+            const changes = allowed
+                ? transitionCard(db, tenantId, id, {
+                    from: ['running'],
+                    to: 'blocked',
+                    extra: { setSql: 'assignee_runtime = NULL' },
+                })
+                : 0;
             if (changes === 0) {
                 if (!loadCardRow(db, tenantId, id)) {
                     throw new Error(`unknown card id: ${id}`);
@@ -297,8 +320,9 @@ export function blockCard(hippoRoot, tenantId, id, reason, runId) {
         return blocked ? loadCardRow(db, tenantId, id) : null;
     }, openStore);
 }
-/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is
- * given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
+/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When
+ * runId is given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card
+ * not running. */
 export function reviewCard(hippoRoot, tenantId, id, runId) {
     assertTenantId('reviewCard', tenantId);
     if (runId !== undefined)
@@ -318,8 +342,9 @@ export function reviewCard(hippoRoot, tenantId, id, runId) {
         return moved ? loadCardRow(db, tenantId, id) : null;
     }, openStore);
 }
-/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all done; 'failure'/'partial' shelves it.
- * Throws on an unknown card id; returns null for a card not in review, or when `runId` is given and is not the card's live run. */
+/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all
+ * done; 'failure'/'partial' shelves it. Throws on an unknown card id; returns null for a card not in review, or when
+ * `runId` is given and is not the card's live run. */
 export function completeCard(hippoRoot, tenantId, id, outcome, runId) {
     assertTenantId('completeCard', tenantId);
     if (!isHandoffOutcome(outcome)) {
@@ -347,24 +372,29 @@ export function completeCard(hippoRoot, tenantId, id, outcome, runId) {
         return promoted === null ? null : { card: loadCardRow(db, tenantId, id), promotedChildren: promoted };
     }, openStore);
 }
-/** Moves to ready each backlog child of `parentId` whose parents are all done, and returns their ids. Call inside the write scope. */
+/** Moves to ready each backlog child of `parentId` whose parents are all done, and returns their ids. Call inside the
+ * write scope. */
 function promoteUnblockedChildren(db, tenantId, parentId) {
-    // The child's status and its open parents are result columns, not joins, so the rows keep the order of a plain read of the parent's children.
-    // SAFETY: rows' shape matches the three columns named in the SELECT below.
-    const children = db.prepare(`
+    // The child's status and its open parents are result columns, not joins, so the rows keep the order of a plain read
+    // of the parent's children. SAFETY: rows' shape matches the three columns named in the SELECT below.
+    const children = db
+        .prepare(`
     SELECT d.child AS child,
       (SELECT c.status FROM cards c WHERE c.tenant_id = ? AND c.id = d.child) AS status,
       (SELECT COUNT(*) FROM card_deps p WHERE p.tenant_id = ? AND p.child = d.child
-        AND NOT EXISTS (SELECT 1 FROM cards pc WHERE pc.tenant_id = ? AND pc.id = p.parent AND pc.status = 'done')) AS open_parents
+        AND NOT EXISTS (SELECT 1 FROM cards pc WHERE pc.tenant_id = ? AND pc.id = p.parent AND pc.status = 'done')) AS
+        open_parents
     FROM card_deps d WHERE d.tenant_id = ? AND d.parent = ?
-  `).all(tenantId, tenantId, tenantId, tenantId, parentId);
+  `)
+        .all(tenantId, tenantId, tenantId, tenantId, parentId);
     const unblocked = children.filter((r) => r.status === 'backlog' && r.open_parents === 0).map((r) => r.child);
     for (const ids of chunked(unblocked))
         transitionCards(db, tenantId, ids, { from: ['backlog'], to: 'ready' });
     return unblocked;
 }
-/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live
- * run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
+/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes
+ * its live run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card
+ * ids in id order. */
 export function reclaimExpiredCards(hippoRoot, tenantId) {
     assertTenantId('reclaimExpiredCards', tenantId);
     return onHandle(hippoRoot, (db) => {
@@ -378,7 +408,11 @@ export function reclaimExpiredCards(hippoRoot, tenantId) {
         ORDER BY id
       `).all(tenantId, now).map((r) => r.id);
             for (const id of ids) {
-                transitionCard(db, tenantId, id, { from: ['running'], to: 'ready', extra: { setSql: 'assignee_runtime = NULL' } });
+                transitionCard(db, tenantId, id, {
+                    from: ['running'],
+                    to: 'ready',
+                    extra: { setSql: 'assignee_runtime = NULL' },
+                });
                 closeLiveRun(db, tenantId, id, 'reclaimed', now);
             }
             return ids;

package/dist/store/compaction-caller.d.ts

@@ -13,6 +13,7 @@ export interface CallerItems {
     readonly owner: string;
     readonly origins: readonly string[];
 }
-/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count,
+ * and a `summarised` one is reused. */
 export declare function saveCallerItems(hippoRoot: string, tenantId: string, req: CallerItems, log: Log): number;
 //# sourceMappingURL=compaction-caller.d.ts.map

package/dist/store/compaction-caller.js

@@ -9,7 +9,8 @@ export function startCompactionAt(hippoRoot, tenantId, start) {
 export function markSnapshotSavedAt(hippoRoot, tenantId, recordId) {
     onHandle(hippoRoot, (db) => markSnapshotSaved(db, tenantId, recordId));
 }
-/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count,
+ * and a `summarised` one is reused. */
 export function saveCallerItems(hippoRoot, tenantId, req, log) {
     return onHandle(hippoRoot, (db) => {
         const earlier = compactionByRequest(db, tenantId, req.requestId, req.sessionId);

package/dist/store/compactions-record.d.ts

@@ -28,8 +28,8 @@ export interface CompactionStart {
 export declare function startCompaction(db: DatabaseSyncLike, tenantId: string, start: CompactionStart, at?: Date): string;
 /** A session's newest record, or null. */
 export declare function latestCompaction(db: DatabaseSyncLike, tenantId: string, sessionId: string): CompactionRecord | null;
-/** The record a caller's request made, whatever state it reached, so a retry neither writes its items twice nor starts a second record.
- * Another session's id is a ConflictError. */
+/** The record a caller's request made, whatever state it reached, so a retry neither writes its items twice nor starts
+ * a second record. Another session's id is a ConflictError. */
 export declare function compactionByRequest(db: DatabaseSyncLike, tenantId: string, requestId: string, sessionId: string): CompactionRecord | null;
 /** Best effort, never throws: a compaction must not fail because its record could not be written. */
 export declare function recordCompactionStart(hippoRoot: string, start: Omit<CompactionStart, 'originProject'>, log: Log): string | null;
@@ -51,7 +51,8 @@ export interface RecordSummaryOptions {
     readonly at: Date;
     readonly caller?: SummaryCaller;
 }
-/** Puts the summary on the session's `started` record, or inserts a `summarised` one when pre-compact wrote none. One statement each. */
+/** Puts the summary on the session's `started` record, or inserts a `summarised` one when pre-compact wrote none. One
+ * statement each. */
 export declare function recordSummary(db: DatabaseSyncLike, hippoRoot: string, tenantId: string, options: RecordSummaryOptions): CompactionRecord;
 export interface ItemContext {
     tenantId: string;
@@ -62,13 +63,15 @@ export interface ItemContext {
     /** Where the session ran, so rows held under the project's older folder name count too. */
     cwd: string | null;
     items: string[];
-    /** Set when another machine sent the items: its audit actor and its project's names, since the server's folder is neither. */
+    /** Set when another machine sent the items: its audit actor and its project's names, since the server's folder is
+     * neither. */
     caller?: {
         actor: string;
         origins: readonly string[];
     };
 }
-/** Items that become rows, then the record `done`, in one transaction so two sessions cannot both insert one text. Mirrors after commit. */
+/** Items that become rows, then the record `done`, in one transaction so two sessions cannot both insert one text.
+ * Mirrors after commit. */
 export declare function saveItems(db: DatabaseSyncLike, hippoRoot: string, ctx: ItemContext, log: Log): number;
 export interface CompactionSaveResult {
     /** Memories written; null when neither the record nor the items could be saved. */
@@ -77,12 +80,14 @@ export interface CompactionSaveResult {
     deferred: boolean;
     snapshotSaved: boolean;
 }
-/** What one PostCompact save did; `spoolReason` is set when the store was busy or would not open, so the caller keeps the summary on disk. */
+/** What one PostCompact save did; `spoolReason` is set when the store was busy or would not open, so the caller keeps
+ * the summary on disk. */
 export interface CompactionSaveOutcome {
     result: CompactionSaveResult;
     spoolReason: string | null;
 }
-/** The PostCompact store work, on a handle of its own: record the summary, then write its items. Each step is independent. Never throws. */
+/** The PostCompact store work, on a handle of its own: record the summary, then write its items. Each step is
+ * independent. Never throws. */
 export declare function saveCompactionAt(hippoRoot: string, meta: Omit<CompactionStart, 'originProject'>, text: CompactionText, at: Date, log: Log): CompactionSaveOutcome;
 /** One spooled summary, as plain data. */
 export interface SpooledSummary {
@@ -91,7 +96,8 @@ export interface SpooledSummary {
     text: CompactionText;
     at: Date;
 }
-/** Records one spooled summary; it calls `recorded` once the store holds it, so the file is done even if a later step throws. */
+/** Records one spooled summary; it calls `recorded` once the store holds it, so the file is done even if a later step
+ * throws. */
 export type SpoolRecorder = (spooled: SpooledSummary, recorded: () => void) => void;
 /** A summary read out of a transcript, scrubbed; `listed` is false when it had no memories section. */
 export interface TranscriptText {