hippo-memory 1.72.0 → 2.1.0

package/dist/store/connectors/github.js

@@ -2,28 +2,27 @@
 import { withWriteScope } from '../../db/index.js';
 import { archiveRawMemory } from '../raw-archive.js';
 import { onHandle } from '../open.js';
-import { getDlqRow, insertDlqRow, listDlqRows, markDlqRetried } from './dlq.js';
+import { eventMemoryAt, eventRecord, eventSeenAt, markEventSeenAt } from './event-log.js';
+import { dlqAccess } from './dlq.js';
+const GITHUB_LOG = { table: 'github_event_log', keyColumn: 'idempotency_key' };
 export function githubEventSeenAt(db, idempotencyKey) {
-    const row = db.prepare(`SELECT 1 FROM github_event_log WHERE idempotency_key = ?`).get(idempotencyKey);
-    return !!row;
+    return eventSeenAt(db, GITHUB_LOG, idempotencyKey);
 }
 export function githubEventMemoryAt(db, idempotencyKey) {
-    // SAFETY: the SELECT projects exactly the memory_id column of github_event_log.
-    const row = db.prepare(`SELECT memory_id FROM github_event_log WHERE idempotency_key = ?`).get(idempotencyKey);
-    return row?.memory_id ?? null;
+    return eventMemoryAt(db, GITHUB_LOG, idempotencyKey);
 }
 /** False when the key was already logged, so a caller inside a write scope can roll its own row back. */
 export function markGitHubEventSeenAt(db, entry) {
-    const inserted = db.prepare(`INSERT OR IGNORE INTO github_event_log (idempotency_key, delivery_id, event_name, ingested_at, memory_id) VALUES (?, ?, ?, ?, ?)`).run(entry.idempotencyKey, entry.deliveryId, entry.eventName, new Date().toISOString(), entry.memoryId);
-    return Number(inserted.changes ?? 0) !== 0;
+    return markEventSeenAt(db, GITHUB_LOG, entry.idempotencyKey, [['delivery_id', entry.deliveryId], ['event_name', entry.eventName]], entry.memoryId);
 }
 export function githubEventRecord(hippoRoot, idempotencyKey) {
-    return onHandle(hippoRoot, (db) => githubEventSeenAt(db, idempotencyKey) ? { seen: true, memoryId: githubEventMemoryAt(db, idempotencyKey) } : { seen: false });
+    return eventRecord(hippoRoot, GITHUB_LOG, idempotencyKey);
 }
 export function markGitHubEventSeen(hippoRoot, entry) {
     onHandle(hippoRoot, (db) => { markGitHubEventSeenAt(db, entry); });
 }
-/** Archives every active raw row of one tenant's artifact and logs the delete event; a failed archive rolls back the batch and the log row. */
+/** Archives every active raw row of one tenant's artifact and logs the delete event; a failed archive rolls back the
+ * batch and the log row. */
 export function archiveDeletedArtifact(hippoRoot, del) {
     return onHandle(hippoRoot, (db) => {
         if (githubEventSeenAt(db, del.idempotencyKey))
@@ -47,50 +46,32 @@ export function archiveDeletedArtifact(hippoRoot, del) {
         return { duplicate: false, archived: memoryIds.length };
     });
 }
-const SELECT_COLUMNS = `id, tenant_id, raw_payload, error, event_name, delivery_id,
-            signature, installation_id, repo_full_name, retry_count,
-            received_at, retried_at, bucket`;
-function rowToItem(r) {
-    return {
-        id: Number(r.id),
-        tenantId: String(r.tenant_id),
-        rawPayload: String(r.raw_payload),
-        error: String(r.error),
-        eventName: r.event_name == null ? null : String(r.event_name),
-        deliveryId: r.delivery_id == null ? null : String(r.delivery_id),
-        signature: r.signature == null ? null : String(r.signature),
-        installationId: r.installation_id == null ? null : String(r.installation_id),
-        repoFullName: r.repo_full_name == null ? null : String(r.repo_full_name),
-        retryCount: Number(r.retry_count ?? 0),
-        receivedAt: String(r.received_at),
-        retriedAt: r.retried_at == null ? null : String(r.retried_at),
-        bucket: r.bucket == null ? 'parse_error' : String(r.bucket),
-    };
-}
+const DLQ = dlqAccess('github_dlq', [
+    { field: 'id', column: 'id', kind: 'int' },
+    { field: 'tenantId', column: 'tenant_id', kind: 'text', insert: true },
+    { field: 'rawPayload', column: 'raw_payload', kind: 'text', insert: true },
+    { field: 'error', column: 'error', kind: 'text', insert: true },
+    { field: 'eventName', column: 'event_name', kind: 'nullableText', insert: true },
+    { field: 'deliveryId', column: 'delivery_id', kind: 'nullableText', insert: true },
+    { field: 'signature', column: 'signature', kind: 'nullableText', insert: true },
+    { field: 'installationId', column: 'installation_id', kind: 'nullableText', insert: true },
+    { field: 'repoFullName', column: 'repo_full_name', kind: 'nullableText', insert: true },
+    { field: 'retryCount', column: 'retry_count', kind: 'count' },
+    { field: 'receivedAt', column: 'received_at', kind: 'text' },
+    { field: 'retriedAt', column: 'retried_at', kind: 'nullableText' },
+    { field: 'bucket', column: 'bucket', kind: 'bucket', insert: true },
+]);
 export function insertGitHubDlq(hippoRoot, row) {
-    return onHandle(hippoRoot, (db) => insertDlqRow(db, 'github_dlq', [
-        ['tenant_id', row.tenantId],
-        ['raw_payload', row.rawPayload],
-        ['error', row.error],
-        ['event_name', row.eventName ?? null],
-        ['delivery_id', row.deliveryId ?? null],
-        ['signature', row.signature],
-        ['installation_id', row.installationId ?? null],
-        ['repo_full_name', row.repoFullName ?? null],
-        ['bucket', row.bucket],
-    ]));
+    return onHandle(hippoRoot, (db) => DLQ.insert(db, row));
 }
 export function listGitHubDlq(hippoRoot, tenantId, limit) {
-    return onHandle(hippoRoot, (db) => listDlqRows(db, 'github_dlq', SELECT_COLUMNS, tenantId, limit).map(rowToItem));
+    return onHandle(hippoRoot, (db) => DLQ.list(db, tenantId, limit));
 }
 export function githubDlqEntry(hippoRoot, id) {
-    return onHandle(hippoRoot, (db) => {
-        const row = getDlqRow(db, 'github_dlq', SELECT_COLUMNS, id);
-        return row ? rowToItem(row) : null;
-    });
+    return onHandle(hippoRoot, (db) => DLQ.get(db, id));
 }
 export function markGitHubDlqRetried(hippoRoot, id) {
-    onHandle(hippoRoot, (db) => markDlqRetried(db, 'github_dlq', id));
+    onHandle(hippoRoot, (db) => DLQ.markRetried(db, id));
 }
 export function githubRouting(hippoRoot, args) {
     return onHandle(hippoRoot, (db) => {
@@ -145,7 +126,8 @@ export function writeHwm(hippoRoot, tenantId, repo, column, value) {
 /** Sets all three HWMs to `since` for a first run; COALESCE keeps any HWM a stream has already saved. */
 export function seedCursors(hippoRoot, tenantId, repo, since) {
     onHandle(hippoRoot, (db) => {
-        db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, issues_hwm, issue_comments_hwm, pr_review_comments_hwm, updated_at)
+        db.prepare(`INSERT INTO github_cursors (tenant_id, repo_full_name, issues_hwm, issue_comments_hwm, ` +
+            `pr_review_comments_hwm, updated_at)
          VALUES (?, ?, ?, ?, ?, ?)
          ON CONFLICT(tenant_id, repo_full_name) DO UPDATE SET
            issues_hwm = COALESCE(github_cursors.issues_hwm, excluded.issues_hwm),

package/dist/store/connectors/slack.d.ts

@@ -10,7 +10,8 @@ export declare function markSlackEventSeenAt(db: DatabaseSyncLike, eventId: stri
 export declare function slackEventMemoryAt(db: DatabaseSyncLike, eventId: string): string | null;
 export declare function slackEventRecord(hippoRoot: string, eventId: string): ConnectorEventRecord;
 export declare function markSlackEventSeen(hippoRoot: string, eventId: string, memoryId: string | null): void;
-/** The raw memory a Slack message became. The tenant filter keeps one tenant's deletion from reaching another's row with the same ref. */
+/** The raw memory a Slack message became. The tenant filter keeps one tenant's deletion from reaching another's row
+ * with the same ref. */
 export declare function rawMemoryIdForArtifactAt(db: DatabaseSyncLike, artifactRef: string, tenantId: string): string | null;
 export type DlqBucket = 'parse_error' | 'unroutable' | 'signature_fail';
 export interface DlqItem {

package/dist/store/connectors/slack.js

@@ -1,7 +1,9 @@
-// Every statement the Slack connector runs on hippo.db: backfill cursors, the event log, the dead-letter queue and workspace routing.
-// `xAt(db, ...)` runs on the caller's handle; the same name without `At` opens hippo.db for that one call.
+// Every statement the Slack connector runs on hippo.db: backfill cursors, the event log, the dead-letter queue and
+// workspace routing. `xAt(db, ...)` runs on the caller's handle; the same name without `At` opens hippo.db for that one
+// call.
 import { onHandle } from '../open.js';
-import { getDlqRow, insertDlqRow, listDlqRows, markDlqRetried } from './dlq.js';
+import { eventMemoryAt, eventRecord, eventSeenAt, markEventSeenAt } from './event-log.js';
+import { dlqAccess } from './dlq.js';
 // Backfill cursors
 export function slackCursorAt(db, tenantId, channelId) {
     // SAFETY: the SELECT names the single `latest_ts` column; sqlite returns undefined when no row matches.
@@ -12,7 +14,8 @@ export function slackCursorAt(db, tenantId, channelId) {
 }
 export function saveSlackCursorAt(db, tenantId, channelId, latestTs) {
     db.prepare(`INSERT INTO slack_cursors (tenant_id, channel_id, latest_ts, updated_at) VALUES (?,?,?,?)
-       ON CONFLICT(tenant_id, channel_id) DO UPDATE SET latest_ts = excluded.latest_ts, updated_at = excluded.updated_at`).run(tenantId, channelId, latestTs, new Date().toISOString());
+       ON CONFLICT(tenant_id, channel_id) DO UPDATE SET latest_ts = excluded.latest_ts, updated_at =
+       excluded.updated_at`).run(tenantId, channelId, latestTs, new Date().toISOString());
 }
 export function slackCursor(hippoRoot, tenantId, channelId) {
     return onHandle(hippoRoot, (db) => slackCursorAt(db, tenantId, channelId));
@@ -21,30 +24,26 @@ export function saveSlackCursor(hippoRoot, tenantId, channelId, latestTs) {
     onHandle(hippoRoot, (db) => saveSlackCursorAt(db, tenantId, channelId, latestTs));
 }
 // Event log
+const SLACK_LOG = { table: 'slack_event_log', keyColumn: 'event_id' };
 export function slackEventSeenAt(db, eventId) {
-    const row = db.prepare(`SELECT 1 FROM slack_event_log WHERE event_id = ?`).get(eventId);
-    return !!row;
+    return eventSeenAt(db, SLACK_LOG, eventId);
 }
 /** Records the event unless a row already holds its id; false means another writer got there first. */
 export function markSlackEventSeenAt(db, eventId, memoryId) {
-    const inserted = db
-        .prepare(`INSERT OR IGNORE INTO slack_event_log (event_id, ingested_at, memory_id) VALUES (?, ?, ?)`)
-        .run(eventId, new Date().toISOString(), memoryId);
-    return Number(inserted.changes ?? 0) !== 0;
+    return markEventSeenAt(db, SLACK_LOG, eventId, [], memoryId);
 }
 export function slackEventMemoryAt(db, eventId) {
-    // SAFETY: the SELECT names only `memory_id`, a nullable column; .get() returns undefined when no row matches.
-    const row = db.prepare(`SELECT memory_id FROM slack_event_log WHERE event_id = ?`).get(eventId);
-    return row?.memory_id ?? null;
+    return eventMemoryAt(db, SLACK_LOG, eventId);
 }
 export function slackEventRecord(hippoRoot, eventId) {
-    return onHandle(hippoRoot, (db) => slackEventSeenAt(db, eventId) ? { seen: true, memoryId: slackEventMemoryAt(db, eventId) } : { seen: false });
+    return eventRecord(hippoRoot, SLACK_LOG, eventId);
 }
 export function markSlackEventSeen(hippoRoot, eventId, memoryId) {
     onHandle(hippoRoot, (db) => markSlackEventSeenAt(db, eventId, memoryId));
 }
 // Deletion lookup
-/** The raw memory a Slack message became. The tenant filter keeps one tenant's deletion from reaching another's row with the same ref. */
+/** The raw memory a Slack message became. The tenant filter keeps one tenant's deletion from reaching another's row
+ * with the same ref. */
 export function rawMemoryIdForArtifactAt(db, artifactRef, tenantId) {
     // SAFETY: the SELECT projects only `id`; .get() returns undefined when no row matches.
     const row = db
@@ -52,45 +51,30 @@ export function rawMemoryIdForArtifactAt(db, artifactRef, tenantId) {
         .get(artifactRef, tenantId);
     return row?.id ?? null;
 }
-const SELECT_COLUMNS = `id, tenant_id, team_id, raw_payload, error, received_at, retried_at,
-              bucket, retry_count, signature, slack_timestamp`;
-function rowToItem(r) {
-    return {
-        id: Number(r.id),
-        tenantId: String(r.tenant_id),
-        teamId: r.team_id == null ? null : String(r.team_id),
-        rawPayload: String(r.raw_payload),
-        error: String(r.error),
-        receivedAt: String(r.received_at),
-        retriedAt: r.retried_at == null ? null : String(r.retried_at),
-        bucket: r.bucket == null ? 'parse_error' : String(r.bucket),
-        retryCount: Number(r.retry_count ?? 0),
-        signature: r.signature == null ? null : String(r.signature),
-        slackTimestamp: r.slack_timestamp == null ? null : String(r.slack_timestamp),
-    };
-}
+const DLQ = dlqAccess('slack_dlq', [
+    { field: 'id', column: 'id', kind: 'int' },
+    { field: 'tenantId', column: 'tenant_id', kind: 'text', insert: true },
+    { field: 'teamId', column: 'team_id', kind: 'nullableText', insert: true },
+    { field: 'rawPayload', column: 'raw_payload', kind: 'text', insert: true },
+    { field: 'error', column: 'error', kind: 'text', insert: true },
+    { field: 'receivedAt', column: 'received_at', kind: 'text' },
+    { field: 'retriedAt', column: 'retried_at', kind: 'nullableText' },
+    { field: 'bucket', column: 'bucket', kind: 'bucket', insert: true },
+    { field: 'retryCount', column: 'retry_count', kind: 'count' },
+    { field: 'signature', column: 'signature', kind: 'nullableText', insert: true },
+    { field: 'slackTimestamp', column: 'slack_timestamp', kind: 'nullableText', insert: true },
+]);
 export function insertSlackDlq(hippoRoot, row) {
-    return onHandle(hippoRoot, (db) => insertDlqRow(db, 'slack_dlq', [
-        ['tenant_id', row.tenantId],
-        ['team_id', row.teamId ?? null],
-        ['raw_payload', row.rawPayload],
-        ['error', row.error],
-        ['bucket', row.bucket],
-        ['signature', row.signature],
-        ['slack_timestamp', row.slackTimestamp ?? null],
-    ]));
+    return onHandle(hippoRoot, (db) => DLQ.insert(db, row));
 }
 export function listSlackDlq(hippoRoot, tenantId, limit) {
-    return onHandle(hippoRoot, (db) => listDlqRows(db, 'slack_dlq', SELECT_COLUMNS, tenantId, limit).map(rowToItem));
+    return onHandle(hippoRoot, (db) => DLQ.list(db, tenantId, limit));
 }
 export function slackDlqEntry(hippoRoot, id) {
-    return onHandle(hippoRoot, (db) => {
-        const row = getDlqRow(db, 'slack_dlq', SELECT_COLUMNS, id);
-        return row ? rowToItem(row) : null;
-    });
+    return onHandle(hippoRoot, (db) => DLQ.get(db, id));
 }
 export function markSlackDlqRetried(hippoRoot, id) {
-    onHandle(hippoRoot, (db) => markDlqRetried(db, 'slack_dlq', id));
+    onHandle(hippoRoot, (db) => DLQ.markRetried(db, id));
 }
 export function slackTeamRouteAt(db, teamId) {
     // SAFETY: the SELECT names only `tenant_id`; .get() returns undefined when no row matches.

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

@@ -13,15 +13,19 @@ export interface DashboardRows {
 }
 /** One tenant's live rows and the counts of the rest, read in one transaction so the two agree. */
 export declare function loadDashboardRows(hippoRoot: string, tenantId: string): DashboardRows;
-/** The dashboard's one read-only connection, kept across refreshes for the commit signal; it opens on the first read that finds a database. */
+/** The dashboard's one read-only connection, kept across refreshes for the commit signal; it opens on the first read
+ * that finds a database. */
 export declare class DashboardConnection {
     private readonly hippoRoot;
     private db;
     constructor(hippoRoot: string);
     /** `PRAGMA data_version`, which moves when another connection commits; null while the store has no hippo.db. */
     dataVersion(): number | null;
-    /** Ids with a stored vector: none before the connection opens, null on a store older than the vector table (schema v52). */
-    embeddedIds(): ReadonlySet<string> | null;
+    /** Ids of the tenant's rows with a stored vector: none before the connection opens, null on a store older than the
+     * vector table (schema v52). */
+    embeddedIds(tenantId: string): ReadonlySet<string> | null;
+    /** Whether `id` has a stored vector, whatever its tenant and whether or not a memory row holds it. */
+    hasVector(id: string): boolean;
     close(): void;
 }
 //# sourceMappingURL=dashboard-reads.d.ts.map

package/dist/store/dashboard-reads.js

@@ -1,17 +1,22 @@
-// The dashboard snapshot's read of one tenant: live rows with only the columns it shows, and SQL counts of the rows it leaves out.
+// The dashboard snapshot's read of one tenant: live rows with only
+// the columns it shows, and SQL counts of the rows it leaves out.
 import * as fs from 'fs';
 import { closeHippoDb, getHippoDbPath, openHippoDbReadOnly } from '../db/index.js';
 import { withReadSnapshot } from '../db/busy.js';
 import { pragmaDataVersion } from '../db/meta.js';
 import { tableExists } from '../db/tables.js';
-import { storedVectorIds } from '../db/vector-store.js';
 import { onHandle, openStore } from './open.js';
 import { QUARANTINE_SCOPE_PREFIX } from './quarantine.js';
 import { parseJsonArray } from './rows.js';
-const LIVE_COLUMNS = 'id, created, last_retrieved, retrieval_count, half_life_days, layer, tags_json, emotional_valence, outcome_positive, ' +
+// Full content stays: dashboard-snapshot's Fact.lower serves search over the whole text, so a preview would change
+// which rows match.
+const LIVE_COLUMNS = 'id, created, last_retrieved, retrieval_count, half_life_days, ' +
+    'layer, tags_json, emotional_valence, outcome_positive, ' +
     'outcome_negative, pinned, confidence, content, superseded_by, kind, scope, origin_project';
-// SQL twins of isQuarantineScope and of the two halves of isLiveMemory; substr compares bytes, as startsWith does, where LIKE would fold case.
-const QUARANTINED = `(scope IS NOT NULL AND substr(scope, 1, ${QUARANTINE_SCOPE_PREFIX.length}) = '${QUARANTINE_SCOPE_PREFIX}')`;
+// SQL twins of isQuarantineScope and of the two halves of isLiveMemory; substr compares bytes, as startsWith does,
+// where LIKE would fold case.
+const QUARANTINED = `(scope IS NOT NULL ` +
+    `AND substr(scope, 1, ${QUARANTINE_SCOPE_PREFIX.length}) = '${QUARANTINE_SCOPE_PREFIX}')`;
 const SUPERSEDED_BY = `(superseded_by IS NOT NULL AND superseded_by <> '')`;
 const KIND = `COALESCE(kind, 'distilled')`;
 const LIVE = `NOT ${SUPERSEDED_BY} AND ${KIND} IN ('raw', 'distilled') AND NOT ${QUARANTINED}`;
@@ -43,7 +48,9 @@ export function loadDashboardRows(hippoRoot, tenantId) {
     return onHandle(hippoRoot, (db) => {
         return withReadSnapshot(db, () => {
             // SAFETY: the SELECT names exactly LiveRow's columns.
-            const live = db.prepare(`SELECT ${LIVE_COLUMNS} FROM memories WHERE tenant_id = ? AND ${LIVE} ORDER BY created ASC, id ASC`).all(tenantId);
+            const live = db
+                .prepare(`SELECT ${LIVE_COLUMNS} FROM memories WHERE tenant_id = ? AND ${LIVE} ORDER BY created ASC, id ASC`)
+                .all(tenantId);
             // SAFETY: the SELECT names exactly these two fields, and `why` is one of the three CASE arms or NULL.
             const counts = db.prepare(`\n        SELECT CASE WHEN ${QUARANTINED} THEN 'quarantined' ` +
                 `WHEN ${SUPERSEDED_BY} OR ${KIND} = 'superseded' THEN 'superseded' ` +
@@ -58,7 +65,8 @@ export function loadDashboardRows(hippoRoot, tenantId) {
         });
     }, openStore);
 }
-/** The dashboard's one read-only connection, kept across refreshes for the commit signal; it opens on the first read that finds a database. */
+/** The dashboard's one read-only connection, kept across refreshes for the commit signal; it opens on the first read
+ * that finds a database. */
 export class DashboardConnection {
     hippoRoot;
     db = null;
@@ -74,11 +82,25 @@ export class DashboardConnection {
         }
         return pragmaDataVersion(this.db);
     }
-    /** Ids with a stored vector: none before the connection opens, null on a store older than the vector table (schema v52). */
-    embeddedIds() {
+    /** Ids of the tenant's rows with a stored vector: none before the connection opens, null on a store older than the
+     * vector table (schema v52). */
+    embeddedIds(tenantId) {
         if (this.db === null)
             return new Set();
-        return tableExists(this.db, 'memory_vectors') ? storedVectorIds(this.db) : null;
+        if (!tableExists(this.db, 'memory_vectors'))
+            return null;
+        // SAFETY: the SELECT names the one TEXT id column.
+        const rows = this.db
+            .prepare('SELECT m.id FROM memories m WHERE m.tenant_id = ? ' +
+            'AND EXISTS (SELECT 1 FROM memory_vectors v WHERE v.memory_id = m.id)')
+            .all(tenantId);
+        return new Set(rows.map((row) => row.id));
+    }
+    /** Whether `id` has a stored vector, whatever its tenant and whether or not a memory row holds it. */
+    hasVector(id) {
+        if (this.db === null || !tableExists(this.db, 'memory_vectors'))
+            return false;
+        return this.db.prepare('SELECT 1 FROM memory_vectors WHERE memory_id = ?').get(id) !== undefined;
     }
     close() {
         if (this.db !== null)

package/dist/store/delete-and-batch.d.ts

@@ -2,14 +2,17 @@ import { type MemoryEntry } from '../core/memory.js';
 import { openHippoDb, type DatabaseSyncLike } from '../db/index.js';
 import { type DormantMove } from './dormant.js';
 import { type WriteBudget } from '../util/write-budget.js';
-/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL); tests/dormant-memories.test.ts pins it to the schema. */
+/** Tables whose rows keep a first-class object's backing memory in `memory_id` (ON DELETE SET NULL);
+ * tests/dormant-memories.test.ts pins it to the schema. */
 export declare const MEMORY_BACKED_TABLES: readonly ["predictions", "decisions", "incidents", "processes", "policies", "skills", "project_briefs", "customer_notes"];
-/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing from an older schema is skipped. */
+/** Ids of memories that back a first-class object, for passes that plan deletes before making them. A table missing
+ * from an older schema is skipped. */
 export declare function memoriesBackingObjects(hippoRoot: string): Set<string>;
 /** memoriesBackingObjects on the caller's handle. */
 export declare function memoriesBackingObjectsOn(db: DatabaseSyncLike): Set<string>;
-/** db-scoped delete core, composable inside a caller's transaction; NO filesystem I/O, mirrors are written post-commit. `suppressForgetAudit` is set by
- * rejectValue and resolveConflict (own audit row). Returns `{tenantId, dagParentId}`, or null if absent or `automatic` refused it. */
+/** db-scoped delete core, composable inside a caller's transaction; NO filesystem I/O, mirrors are written post-commit.
+ * `suppressForgetAudit` is set by rejectValue and resolveConflict (own audit row). Returns `{tenantId, dagParentId}`,
+ * or null if absent or `automatic` refused it. */
 export declare function deleteEntryCore(db: ReturnType<typeof openHippoDb>, id: string, opts?: {
     actor?: string;
     suppressForgetAudit?: boolean;
@@ -20,22 +23,25 @@ export declare function deleteEntryCore(db: ReturnType<typeof openHippoDb>, id:
     dagParentId: string | null;
 } | null;
 /** Delete an entry from SQLite and mirrors; thin wrapper over `deleteEntryCore` (open, core, mirrors, close).
- * `opts.actor` defaults to 'cli'; the api layer threads `ctx.actor` so HTTP callers land as `api_key:<key_id>` in the audit log. */
+ * `opts.actor` defaults to 'cli'; the api layer threads `ctx.actor` so HTTP callers land as `api_key:<key_id>` in the
+ * audit log. */
 export declare function deleteEntry(hippoRoot: string, id: string, opts?: {
     actor?: string;
     reason?: string;
     automatic?: boolean;
 }): boolean;
-/** deleteEntry with `automatic` for each removal and its own forget row and reason, all in one transaction after one read of the id set.
- *  Returns the ids deleted, in `removals` order; a missing, repeated, pinned, raw or object-backing id is left out. */
+/** deleteEntry with `automatic` for each removal and its own forget row and reason, all in one transaction after one
+ * read of the id set. Returns the ids deleted, in `removals` order; a missing, repeated, pinned, raw or object-backing
+ * id is left out. */
 export declare function deleteEntriesAutomatically(hippoRoot: string, removals: readonly {
     id: string;
     reason: string;
 }[], actor: string): string[];
 /** Each row as the caller loaded it, by id; a `ReadonlyMap` fits. */
 export type LoadedRows = Pick<ReadonlyMap<string, MemoryEntry>, 'get'>;
-/** Writes, deletes and dormant moves in one transaction. With `snapshot`, a write keeps only the fields the caller changed and never resurrects a gone row.
- * Dormant moves (src/store/dormant.ts) leave `memories` like a delete; both skip rows no longer auto-deletable. Returns ids that left `memories`. */
+/** Writes, deletes and dormant moves in one transaction. With `snapshot`, a write keeps only the fields the caller
+ * changed and never resurrects a gone row. Dormant moves (src/store/dormant.ts) leave `memories` like a delete; both
+ * skip rows no longer auto-deletable. Returns ids that left `memories`. */
 export declare function batchWriteAndDelete(hippoRoot: string, toWrite: MemoryEntry[], toDeleteIds: string[], opts?: {
     snapshot?: ReadonlyMap<string, MemoryEntry>;
     dormant?: DormantMove[];
@@ -56,8 +62,8 @@ export declare function deleteEntriesOneByOne(hippoRoot: string, targets: readon
     actor?: string;
     automatic?: boolean;
 }): boolean[];
-/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids that left `memories`.
- * The snapshot keeps what other writers changed after the caller loaded its rows. */
+/** Commits whole components in transactions of about `budget.holdMs`, letting other writers in between; returns the ids
+ * that left `memories`. The snapshot keeps what other writers changed after the caller loaded its rows. */
 export declare function commitInChunks(hippoRoot: string, components: readonly FlushComponent[], opts: {
     snapshot: LoadedRows;
     budget: WriteBudget;