hippo-memory 2.0.0 → 2.1.0

package/dist/store/cards.js

@@ -1,13 +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';
 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';
+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,
@@ -25,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;
@@ -46,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}`);
     }
@@ -67,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`);
     }
@@ -91,8 +96,10 @@ function transitionCards(db, tenantId, cardIds, options) {
     const lease = to === 'running' ? [leaseUntilFrom(now), now] : [null, null];
     const fromPlaceholders = placeholders(from.length);
     const sql = `
-    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}` : ''}
+    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);
@@ -131,7 +138,8 @@ 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;
@@ -174,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() === '') {
@@ -239,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);
@@ -282,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}`);
@@ -298,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)
@@ -319,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)) {
@@ -348,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) => {
@@ -379,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 {

package/dist/store/compactions-record.js

@@ -7,8 +7,8 @@ import { selectItemRows } from '../util/compaction-items.js';
 import { isSharedStore, loadConfig } from '../core/config.js';
 import { closeHippoDb, isSqliteBusy, openHippoDb, withWriteScopeOr } from '../db/index.js';
 import { gatedWrite } from './gated-write.js';
-import { COMPACTION_MEMORY_TAG, COMPACTION_SOURCE_PREFIX, Layer, createMemory, generateId } from '../core/memory.js';
-import { fallbackOrigin, isGlobalStoreRoot, projectId, projectNames, resolveProjectIdentity } from '../core/project-identity.js';
+import { COMPACTION_MEMORY_TAG, COMPACTION_SOURCE_PREFIX, Layer, createMemory, generateId, } from '../core/memory.js';
+import { fallbackOrigin, isGlobalStoreRoot, projectId, projectNames, resolveProjectIdentity, } from '../core/project-identity.js';
 import { closeStartedWithoutSummary, compactionProgress, compactionRowsByRequest, heldMemoryRows, insertStartedCompaction, insertSummarisedCompaction, latestCompactionRows, latestStartedRows, markCompactionDone, markCompactionSummarised, markSnapshotSavedRow, nextCompactionStart, openTranscriptRows, stalledSummarisedRows, } from './compactions.js';
 import { strengthenRetrievedOn, writeEntryMirrors } from './entry-writes.js';
 import { isRecallBoostAblated } from '../core/ablation.js';
@@ -17,14 +17,18 @@ import { resolveTenantId } from './tenant.js';
 import { errorMessage, reportCompactionFailure } from '../util/log.js';
 /** The marker redactSecretsStrict writes; an item holding it was a secret before it was stored. */
 const REDACTED = '[REDACTED]';
-/** Where the session ran: rows written through the global store or a shared store keep the project the session was in. */
+/** Where the session ran: rows written through the global store or a shared store keep the project the session was
+ * in. */
 function compactionProject(hippoRoot, cwd) {
-    if (!isGlobalStoreRoot(hippoRoot) && !isSharedStore(hippoRoot))
+    if (!isGlobalStoreRoot(hippoRoot) && !isSharedStore(hippoRoot)) {
         return resolveProjectIdentity(path.dirname(hippoRoot));
-    // No cwd means user-global, as stampOriginProject gives the global store; undefined would fall back to the hook's own cwd.
+    }
+    // No cwd means user-global, as stampOriginProject gives the global store; undefined would fall back to the hook's own
+    // cwd.
     return cwd === null ? '' : resolveProjectIdentity(cwd);
 }
-/** The record column cannot hold NULL, but an item from an unknown folder on a shared store must not read as user-global. */
+/** The record column cannot hold NULL, but an item from an unknown folder on a shared store must not read as
+ * user-global. */
 function itemOrigin(hippoRoot, ctx) {
     return ctx.cwd === null && isSharedStore(hippoRoot) ? fallbackOrigin(hippoRoot) : ctx.originProject;
 }
@@ -64,30 +68,39 @@ export function startCompaction(db, tenantId, start, at = new Date()) {
 export function latestCompaction(db, tenantId, sessionId) {
     return latestCompactionRows(db, tenantId, sessionId).map(toRecord)[0] ?? 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 function compactionByRequest(db, tenantId, requestId, sessionId) {
     const record = compactionRowsByRequest(db, tenantId, requestId).map(toRecord)[0] ?? null;
     // Sessions are owner-bound, so this also keeps one owner from reading or finishing another's record.
-    if (record !== null && record.sessionId !== sessionId)
+    if (record !== null && record.sessionId !== sessionId) {
         throw new ConflictError('request id belongs to another session');
+    }
     return record;
 }
-/** Pre-compact's record for the compaction that is ending: the session's newest `started` one within REPLAY_AFTER_MS before `at`.
- * An older one is left for the transcript fill. */
+/** Pre-compact's record for the compaction that is ending: the session's newest `started` one within REPLAY_AFTER_MS
+ * before `at`. An older one is left for the transcript fill. */
 function latestStarted(db, tenantId, sessionId, at) {
-    return latestStartedRows(db, tenantId, sessionId, at.toISOString(), new Date(at.getTime() - REPLAY_AFTER_MS).toISOString()).map(toRecord)[0] ?? null;
+    return (latestStartedRows(db, tenantId, sessionId, at.toISOString(), new Date(at.getTime() - REPLAY_AFTER_MS).toISOString()).map(toRecord)[0] ?? null);
 }
 function markSummarised(db, tenantId, id, options) {
     const { text, summarisedAt, requestId } = options;
-    return markCompactionSummarised(db, tenantId, id, { summary: text.summary, itemsJson: JSON.stringify(text.items), summarisedAt, requestId });
+    return markCompactionSummarised(db, tenantId, id, {
+        summary: text.summary,
+        itemsJson: JSON.stringify(text.items),
+        summarisedAt,
+        requestId,
+    });
 }
 /** Best effort, never throws: a compaction must not fail because its record could not be written. */
 export function recordCompactionStart(hippoRoot, start, log) {
     let db;
     try {
         db = openHippoDb(hippoRoot, { busyWaitMs: COMPACTION_DB_WAIT_MS });
-        return startCompaction(db, resolveTenantId({}), { ...start, originProject: compactionOrigin(hippoRoot, start.cwd) });
+        return startCompaction(db, resolveTenantId({}), {
+            ...start,
+            originProject: compactionOrigin(hippoRoot, start.cwd),
+        });
     }
     catch (err) {
         log(`compaction record not started: ${errorMessage(err)}`);
@@ -116,7 +129,8 @@ export function recordSnapshotSaved(hippoRoot, tenantId, recordId, log) {
             closeHippoDb(db);
     }
 }
-/** 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 function recordSummary(db, hippoRoot, tenantId, options) {
     const { meta, text, at, caller = {} } = options;
     const now = new Date().toISOString();
@@ -130,18 +144,44 @@ export function recordSummary(db, hippoRoot, tenantId, options) {
     const id = generateId('cmp');
     insertSummarisedCompaction(db, tenantId, { ...meta, originProject, startedAt: at.toISOString() }, { id, summary: text.summary, itemsJson, summarisedAt: now, requestId });
     return {
-        id, tenantId, sessionId: meta.sessionId, originProject, trigger: meta.trigger, cwd: meta.cwd, transcriptPath: meta.transcriptPath,
-        snapshotSaved: false, startedAt: at.toISOString(), summarisedAt: now, summary: text.summary, items: text.items, itemsWritten: 0, status: 'summarised',
+        id,
+        tenantId,
+        sessionId: meta.sessionId,
+        originProject,
+        trigger: meta.trigger,
+        cwd: meta.cwd,
+        transcriptPath: meta.transcriptPath,
+        snapshotSaved: false,
+        startedAt: at.toISOString(),
+        summarisedAt: now,
+        summary: text.summary,
+        items: text.items,
+        itemsWritten: 0,
+        status: 'summarised',
     };
 }
 /** Words whose loss reverses or narrows a statement: "do not", "can't", "only", "unless". */
-const PROTECTED_WORDS = new Set(['not', 'no', 'never', 'none', 'nor', 'without', 'cannot', 't', 'only', 'except', 'unless', 'until']);
+const PROTECTED_WORDS = new Set([
+    'not',
+    'no',
+    'never',
+    'none',
+    'nor',
+    'without',
+    'cannot',
+    't',
+    'only',
+    'except',
+    'unless',
+    'until',
+]);
 /** Below this share of the held text's words, an item is a fragment of something longer, not a restatement. */
 const RESTATE_MIN_SHARE = 0.5;
 function words(text) {
     return text.normalize('NFC').toLowerCase().split(/[^\p{L}\p{M}\p{N}_]+/u).filter(Boolean);
 }
-/** True when `item` is `held` with words left out, in the same order, keeping every number and protected word. Spacing, case and punctuation may differ. */
+/** True when `item` is `held` with words left out, in the same order, keeping every number and protected word. Spacing,
+ * case and punctuation may differ. */
 function restates(item, held) {
     if (item.length === 0 || item.length < RESTATE_MIN_SHARE * held.length)
         return false;
@@ -155,9 +195,14 @@ function restates(item, held) {
     }
     return next === item.length;
 }
-/** Live rows of one tenant and origin that default recall shows: a compaction often restates what an earlier one, or the user, already saved. */
+/** Live rows of one tenant and origin that default recall shows: a compaction often restates what an earlier one, or
+ * the user, already saved. */
 function heldRows(db, tenantId, origins) {
-    return heldMemoryRows(db, tenantId, origins).map((r) => ({ id: r.id, sessionId: r.source_session_id, words: words(r.content) }));
+    return heldMemoryRows(db, tenantId, origins).map((r) => ({
+        id: r.id,
+        sessionId: r.source_session_id,
+        words: words(r.content),
+    }));
 }
 function compactionEntry(text, ctx, origin, baseHalfLifeDays) {
     return {
@@ -167,7 +212,7 @@ function compactionEntry(text, ctx, origin, baseHalfLifeDays) {
             source: `${COMPACTION_SOURCE_PREFIX}${ctx.sessionId}`,
             confidence: 'observed',
             kind: 'distilled',
-            source_session_id: ctx.sessionId,
+            sourceSessionId: ctx.sessionId,
             tenantId: ctx.tenantId,
             baseHalfLifeDays,
         }),
@@ -224,7 +269,8 @@ function finishItemWrites(hippoRoot, writes, log) {
         }
     }
 }
-/** 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 function saveItems(db, hippoRoot, ctx, log) {
     const usable = ctx.items.filter((item) => !item.includes(REDACTED));
     if (usable.length < ctx.items.length)
@@ -262,7 +308,11 @@ export function saveItems(db, hippoRoot, ctx, log) {
 }
 function recordStep(step) {
     try {
-        const record = recordSummary(step.db, step.hippoRoot, step.tenantId, { meta: step.meta, text: step.text, at: step.at });
+        const record = recordSummary(step.db, step.hippoRoot, step.tenantId, {
+            meta: step.meta,
+            text: step.text,
+            at: step.at,
+        });
         step.result.snapshotSaved = record.snapshotSaved;
         return record;
     }
@@ -294,7 +344,8 @@ function itemsStep(step, record) {
         log(`store busy, items left for the next sleep: ${errorMessage(err)}`);
     }
 }
-/** 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 function saveCompactionAt(hippoRoot, meta, text, at, log) {
     const result = { written: null, deferred: false, snapshotSaved: false };
     let db;
@@ -315,27 +366,39 @@ export function saveCompactionAt(hippoRoot, meta, text, at, log) {
     return { result, spoolReason: null };
 }
 function closeWithoutSummary(db, tenantId, id, log) {
-    if (closeStartedWithoutSummary(db, tenantId, id) > 0)
+    if (closeStartedWithoutSummary(db, tenantId, id) > 0) {
         log(`${id} closed as no-summary: its transcript holds no summary for it`);
+    }
 }
 function nextStartedAt(db, record) {
     return nextCompactionStart(db, record.tenantId, record.sessionId, record.startedAt);
 }
 /** The one place a record becomes the argument saveItems takes. */
 function itemContext(tenantId, record, items = record.items) {
-    return { tenantId, recordId: record.id, sessionId: record.sessionId, originProject: record.originProject, cwd: record.cwd, items };
+    return {
+        tenantId,
+        recordId: record.id,
+        sessionId: record.sessionId,
+        originProject: record.originProject,
+        cwd: record.cwd,
+        items,
+    };
 }
 /** Records a spooled summary, then writes its items. */
 function spoolRecorder(db, hippoRoot, log) {
     return (spooled, recorded) => {
-        const record = recordSummary(db, hippoRoot, spooled.tenantId, { meta: spooled.payload, text: spooled.text, at: spooled.at });
+        const record = recordSummary(db, hippoRoot, spooled.tenantId, {
+            meta: spooled.payload,
+            text: spooled.text,
+            at: spooled.at,
+        });
         // The record holds the items now, so the file is done even if the write below fails.
         recorded();
         saveItems(db, hippoRoot, itemContext(spooled.tenantId, record), log);
     };
 }
-/** Runs `step` over each row until the deadline; a row that will not map or a step that throws is logged and the rest still run.
- * Returns how many `step` finished. */
+/** Runs `step` over each row until the deadline; a row that will not map or a step that throws is logged and the rest
+ * still run. Returns how many `step` finished. */
 function replayEach(run, rows, what, step) {
     let finished = 0;
     for (const row of rows) {
@@ -393,8 +456,8 @@ function replayOpen(run) {
     const open = openTranscriptRows(run.db, run.tenantId, new Date(run.now - REPLAY_AFTER_MS).toISOString(), new Date(run.now - TRANSCRIPT_FILL_WINDOW_MS).toISOString());
     return replayEach(run, open, 'transcript fill', (record) => fillFromTranscript(run, record));
 }
-/** Finishes what a killed hook or a busy store left: `summarised` records, spool files, and `started` records the transcript can fill.
- * Returns how many compactions it saved. */
+/** Finishes what a killed hook or a busy store left: `summarised` records, spool files, and `started` records the
+ * transcript can fill. Returns how many compactions it saved. */
 function replayCompactions(db, hippoRoot, sources, log, deadline) {
     const run = { db, hippoRoot, tenantId: resolveTenantId({}), now: Date.now(), sources, log, deadline };
     return replayStalled(run) + replaySpool(run) + replayOpen(run);