hippo-memory 1.72.0 → 2.1.0

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,43 +366,56 @@ 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 record until the deadline; a record that throws is logged and the rest still run. Returns how many `step` finished. */
-function replayEach(run, records, what, step) {
+/** 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 record of records) {
+    for (const row of rows) {
         if (Date.now() > run.deadline)
             break;
         try {
-            if (step(record))
+            if (step(toRecord(row)))
                 finished++;
         }
         catch (err) {
-            run.log(`${what} of ${record.id} failed: ${errorMessage(err)}`);
+            run.log(`${what} of ${row.id} failed: ${errorMessage(err)}`);
         }
     }
     return finished;
 }
 function replayStalled(run) {
-    const stalled = stalledSummarisedRows(run.db, run.tenantId, new Date(run.now - REPLAY_AFTER_MS).toISOString()).map(toRecord);
+    const stalled = stalledSummarisedRows(run.db, run.tenantId, new Date(run.now - REPLAY_AFTER_MS).toISOString());
     return replayEach(run, stalled, 'replay', (record) => {
         saveItems(run.db, run.hippoRoot, itemContext(run.tenantId, record), run.log);
         return true;
@@ -389,11 +453,11 @@ function fillFromTranscript(run, record) {
     return true;
 }
 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()).map(toRecord);
+    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);

package/dist/store/compactions.js

@@ -1,6 +1,7 @@
 import { originInSql } from '../core/project-identity.js';
 import { scopeAdmitSql } from './rule-sql.js';
-const COLUMNS = 'tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, snapshot_saved, started_at, summarised_at, summary, ' +
+const COLUMNS = 'tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, snapshot_saved, started_at, ' +
+    'summarised_at, summary, ' +
     'items_json, items_written, status';
 function selectRows(db, where, ...params) {
     // SAFETY: the SELECT names exactly COLUMNS, matching CompactionRow's field set.
@@ -15,7 +16,8 @@ export function compactionRowsByRequest(db, tenantId, requestId) {
 }
 /** The session's newest `started` row with a start in [`notBefore`, `notAfter`], both ISO strings. */
 export function latestStartedRows(db, tenantId, sessionId, notAfter, notBefore) {
-    return selectRows(db, `tenant_id = ? AND session_id = ? AND status = 'started' AND started_at <= ? AND started_at >= ? ORDER BY started_at DESC, id DESC LIMIT 1`, tenantId, sessionId, notAfter, notBefore);
+    return selectRows(db, `tenant_id = ? AND session_id = ? AND status = 'started' AND started_at <= ? AND started_at >= ? ORDER BY ` +
+        `started_at DESC, id DESC LIMIT 1`, tenantId, sessionId, notAfter, notBefore);
 }
 /** `summarised` rows whose summary is older than `summarisedBefore`, an ISO string. */
 export function stalledSummarisedRows(db, tenantId, summarisedBefore) {
@@ -23,10 +25,12 @@ export function stalledSummarisedRows(db, tenantId, summarisedBefore) {
 }
 /** `started` rows with a transcript whose start lies between `startedAfter` and `startedBefore`, oldest first. */
 export function openTranscriptRows(db, tenantId, startedBefore, startedAfter) {
-    return selectRows(db, `tenant_id = ? AND status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL ORDER BY started_at`, tenantId, startedBefore, startedAfter);
+    return selectRows(db, `tenant_id = ? AND status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL ` +
+        `ORDER BY started_at`, tenantId, startedBefore, startedAfter);
 }
 export function insertStartedCompaction(db, tenantId, start) {
-    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at)
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, ` +
+        `started_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(tenantId, start.id, start.sessionId, start.originProject, start.trigger, start.cwd, start.transcriptPath, start.startedAt);
 }
 /** Moves a `started` row to `summarised`; false when another process already moved it. */
@@ -34,8 +38,11 @@ export function markCompactionSummarised(db, tenantId, id, update) {
     const { summary, itemsJson, summarisedAt, requestId } = update;
     // Only a caller names the column, so a store from before it was added still takes local writes.
     const stamp = requestId === undefined ? [] : [requestId];
-    const result = db.prepare(`UPDATE compactions SET summary = ?, items_json = ?, summarised_at = ?, status = 'summarised'${stamp.length === 0 ? '' : ', request_id = ?'}
-     WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(summary, itemsJson, summarisedAt, ...stamp, tenantId, id);
+    const result = db
+        .prepare(`UPDATE compactions SET summary = ?, items_json = ?, summarised_at = ?, status = ` +
+        `'summarised'${stamp.length === 0 ? '' : ', request_id = ?'}
+     WHERE tenant_id = ? AND id = ? AND status = 'started'`)
+        .run(summary, itemsJson, summarisedAt, ...stamp, tenantId, id);
     return (result.changes ?? 0) > 0;
 }
 export function insertSummarisedCompaction(db, tenantId, meta, row) {
@@ -43,7 +50,8 @@ export function insertSummarisedCompaction(db, tenantId, meta, row) {
     // Only a caller names the column, so a store from before it was added still takes local writes.
     const stamp = requestId === undefined ? [] : [requestId];
     const [col, mark] = stamp.length === 0 ? ['', ''] : [', request_id', ', ?'];
-    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at, ` +
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, ` +
+        `started_at, ` +
         `summarised_at, summary, items_json, status${col})\n` +
         `     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'summarised'${mark})`).run(tenantId, id, meta.sessionId, meta.originProject, meta.trigger, meta.cwd, meta.transcriptPath, meta.startedAt, summarisedAt, summary, itemsJson, ...stamp);
 }
@@ -51,7 +59,8 @@ export function markSnapshotSavedRow(db, tenantId, recordId) {
     db.prepare(`UPDATE compactions SET snapshot_saved = 1 WHERE tenant_id = ? AND id = ?`).run(tenantId, recordId);
 }
 export function compactionProgress(db, tenantId, id) {
-    return db.prepare(`SELECT status, items_written FROM compactions WHERE tenant_id = ? AND id = ?`)
+    return db
+        .prepare(`SELECT status, items_written FROM compactions WHERE tenant_id = ? AND id = ?`)
         .get(tenantId, id);
 }
 export function markCompactionDone(db, tenantId, id, itemsWritten) {
@@ -59,11 +68,14 @@ export function markCompactionDone(db, tenantId, id, itemsWritten) {
 }
 /** Rows changed: 1 when the `started` row was closed, 0 when it had already moved. */
 export function closeStartedWithoutSummary(db, tenantId, id) {
-    const result = db.prepare(`UPDATE compactions SET status = 'no-summary' WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(tenantId, id);
+    const result = db
+        .prepare(`UPDATE compactions SET status = 'no-summary' WHERE tenant_id = ? AND id = ? AND status = 'started'`)
+        .run(tenantId, id);
     return Number(result.changes ?? 0);
 }
 export function nextCompactionStart(db, tenantId, sessionId, after) {
-    const row = db.prepare(`SELECT MIN(started_at) AS at FROM compactions WHERE tenant_id = ? AND session_id = ? AND started_at > ?`)
+    const row = db
+        .prepare(`SELECT MIN(started_at) AS at FROM compactions WHERE tenant_id = ? AND session_id = ? AND started_at > ?`)
         .get(tenantId, sessionId, after);
     return row?.at ?? null;
 }
@@ -71,8 +83,11 @@ export function nextCompactionStart(db, tenantId, sessionId, after) {
 export function heldMemoryRows(db, tenantId, origins) {
     const deny = scopeAdmitSql('');
     // SAFETY: the SELECT names the id, source_session_id and content columns.
-    return db.prepare(`SELECT id, source_session_id, content FROM memories WHERE tenant_id = ? AND ${originInSql(origins)} AND superseded_by IS NULL AND kind != 'raw'
-       AND ${deny.sql}`).all(tenantId, ...origins, ...deny.params);
+    return db
+        .prepare(`SELECT id, source_session_id, content FROM memories WHERE tenant_id = ? AND ${originInSql(origins)} AND ` +
+        `superseded_by IS NULL AND kind != 'raw'
+       AND ${deny.sql}`)
+        .all(tenantId, ...origins, ...deny.params);
 }
 export function restampCompactionOrigin(db, tenantId, from, into) {
     return Number(db.prepare(`UPDATE compactions SET origin_project = ? WHERE tenant_id = ? AND origin_project = ?`)
@@ -80,16 +95,21 @@ export function restampCompactionOrigin(db, tenantId, from, into) {
 }
 export function compactionTranscripts(db, tenantId) {
     // SAFETY: the SELECT names the two columns of the row type.
-    return db.prepare(`SELECT DISTINCT transcript_path AS transcript, cwd FROM compactions WHERE tenant_id = ? AND transcript_path IS NOT NULL`)
+    return db
+        .prepare(`SELECT DISTINCT transcript_path AS transcript, cwd FROM compactions WHERE tenant_id = ? AND transcript_path ` +
+        `IS NOT NULL`)
         .all(tenantId);
 }
 export function compactionOriginsWithCwd(db, tenantId) {
     // SAFETY: the SELECT names the two columns of the row type.
-    return db.prepare(`SELECT DISTINCT origin_project AS origin, cwd FROM compactions WHERE tenant_id = ? AND origin_project <> '' AND cwd IS NOT NULL`)
+    return db
+        .prepare(`SELECT DISTINCT origin_project AS origin, cwd FROM compactions WHERE tenant_id = ? AND origin_project <> '' ` +
+        `AND cwd IS NOT NULL`)
         .all(tenantId);
 }
 /** True when `table` holds a row of this tenant under the project name. */
 export function holdsOrigin(db, table, tenantId, name) {
-    return db.prepare(`SELECT 1 FROM ${table} WHERE tenant_id = ? AND origin_project = ? LIMIT 1`).get(tenantId, name) !== undefined;
+    return (db.prepare(`SELECT 1 FROM ${table} WHERE tenant_id = ? AND origin_project = ? LIMIT 1`).get(tenantId, name) !==
+        undefined);
 }
 //# sourceMappingURL=compactions.js.map

package/dist/store/conflicts.d.ts

@@ -4,18 +4,21 @@ import { type MemoryConflict } from './rows.js';
 export declare function listMemoryConflicts(hippoRoot: string, status?: string, tenantId?: string): MemoryConflict[];
 /** How many open conflicts listMemoryConflicts returns for a tenant, without loading one. */
 export declare function countOpenConflicts(hippoRoot: string, tenantId: string): number;
+/** countOpenConflicts on a handle the caller holds, so it can share a snapshot with other reads. */
+export declare function countOpenConflictsAt(db: DatabaseSyncLike, tenantId: string): number;
 /** One open conflict of a memory, with the row on its other side. */
 export interface OpenConflictOf {
     conflict: MemoryConflict;
     other: MemoryEntry;
 }
-/** A tenant's open conflicts naming `memoryId`, in listMemoryConflicts' order, each with its other member read in one batch. */
+/** A tenant's open conflicts naming `memoryId`, in listMemoryConflicts'
+ * order, each with its other member read in one batch. */
 export declare function loadOpenConflictsOf(hippoRoot: string, tenantId: string, memoryId: string): OpenConflictOf[];
 /** Conflicts whose two rows `actor` may both touch; someone else's personal row hides its whole pair. */
 export declare function listTouchableConflicts(hippoRoot: string, status: string, tenantId: string, actor: {
     owner?: string;
 }): MemoryConflict[];
-type DetectedConflict = {
+export type DetectedConflict = {
     memory_a_id: string;
     memory_b_id: string;
     reason: string;
@@ -23,7 +26,8 @@ type DetectedConflict = {
 };
 type SameTenant = (a: string, b: string) => boolean;
 export declare function replaceDetectedConflicts(hippoRoot: string, detected: Array<DetectedConflict>, detectedAt?: string): void;
-/** The tenant of every memory the refresh can compare, and each stored conflicts_with_json other than '[]', read before the refresh takes the write lock. */
+/** The tenant of every memory the refresh can compare, and each stored conflicts_with_json other than '[]', read
+ * before the refresh takes the write lock. */
 export interface ConflictRefreshReads {
     sameTenant: SameTenant;
     storedRefs: ReadonlyMap<string, string | null>;
@@ -38,9 +42,16 @@ export interface ResolveConflictOpts {
      *  loser is kind='raw'). Defaults to a conflict-context string. */
     reason?: string;
 }
-/** Resolve a conflict by keeping one memory and halving the loser's half-life; `--forget` removes the loser, `opts.rejectLoserValue` also tombstones its
+export interface ResolveConflictRequest {
+    readonly conflictId: number;
+    readonly keepId: string;
+    readonly forgetLoser?: boolean;
+    readonly tenantId?: string;
+}
+/** Resolve a conflict by keeping one memory and halving the loser's half-life; `--forget` removes the loser,
+ * `opts.rejectLoserValue` also tombstones its
  * digest. Every path emits a `conflict_resolve` audit row. Returns the resolved conflict, or null if not found. */
-export declare function resolveConflict(hippoRoot: string, conflictId: number, keepId: string, forgetLoser?: boolean, tenantId?: string, opts?: ResolveConflictOpts): {
+export declare function resolveConflict(hippoRoot: string, { conflictId, keepId, forgetLoser, tenantId }: ResolveConflictRequest, opts?: ResolveConflictOpts): {
     conflict: MemoryConflict;
     loserId: string;
 } | null;