hippo-memory 1.72.0 → 2.1.0

package/dist/store/sessions.js

@@ -30,10 +30,13 @@ function assertKeyedOnSharedStore(fn, hippoRoot, key) {
     }
 }
 function insertSnapshot(db, tenantId, snapshot, now, stamp) {
-    const result = db.prepare(`
-    INSERT INTO task_snapshots(task, summary, next_step, status, source, session_id, scope, tenant_id, created_at, updated_at, owner_subject, origin_project)
+    const result = db
+        .prepare(`
+    INSERT INTO task_snapshots(task, summary, next_step, status, source, session_id, scope, tenant_id, created_at,
+    updated_at, owner_subject, origin_project)
     VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(redactSecretsStrict(snapshot.task), redactSecretsStrict(snapshot.summary), redactSecretsStrict(snapshot.next_step), snapshot.source ?? 'cli', snapshot.session_id ?? null, snapshot.scope ?? null, tenantId, now, now, stamp?.owner ?? null, stamp?.origin ?? null);
+  `)
+        .run(redactSecretsStrict(snapshot.task), redactSecretsStrict(snapshot.summary), redactSecretsStrict(snapshot.next_step), snapshot.source ?? 'cli', snapshot.session_id ?? null, snapshot.scope ?? null, tenantId, now, now, stamp?.owner ?? null, stamp?.origin ?? null);
     return Number(result.lastInsertRowid ?? 0);
 }
 export function saveActiveTaskSnapshot(hippoRoot, tenantId, snapshot, key) {
@@ -45,8 +48,8 @@ export function saveActiveTaskSnapshot(hippoRoot, tenantId, snapshot, key) {
     const now = new Date().toISOString();
     try {
         const id = withWriteScope(db, 'save_active_task', () => {
-            db.prepare(`UPDATE task_snapshots SET status = 'superseded', updated_at = ? WHERE status = 'active' AND tenant_id = ?${owned ? ` AND ${owned.sql}` : ''}`)
-                .run(now, tenantId, ...(owned?.params ?? []));
+            db.prepare(`UPDATE task_snapshots SET status = 'superseded', updated_at = ? WHERE status = 'active' AND tenant_id = ` +
+                `?${owned ? ` AND ${owned.sql}` : ''}`).run(now, tenantId, ...(owned?.params ?? []));
             const inserted = insertSnapshot(db, tenantId, snapshot, now, stamp);
             // An older binary's tenant-wide supersede would close other owners' rows, so the first owner row shuts it out.
             if (stamp)
@@ -95,15 +98,18 @@ export function loadActiveTaskSnapshot(hippoRoot, tenantId, key) {
         return loaded;
     }, openStore);
 }
-/** Default freshness bound for AMBIENT active-task-snapshot reads: 72h rather than 48h so a Friday-evening orphan still offers continuity on Monday;
- * override via `loadFreshActiveTaskSnapshot`'s `opts.maxAgeMs`; deliberately no env knob. */
+/** Default freshness bound for AMBIENT active-task-snapshot reads: 72h rather than 48h so a Friday-evening orphan still
+ * offers continuity on Monday; override via `loadFreshActiveTaskSnapshot`'s `opts.maxAgeMs`; deliberately no env
+ * knob. */
 export const SNAPSHOT_AMBIENT_MAX_AGE_MS = 72 * HOUR_MS;
-/** A usable session id: non-null, non-empty string; named so the owner-match rule in `loadFreshActiveTaskSnapshot` states its contract once. */
+/** A usable session id: non-null, non-empty string; named so the owner-match rule in `loadFreshActiveTaskSnapshot`
+ * states its contract once. */
 function isNonEmptySessionId(value) {
     return typeof value === 'string' && value.length > 0;
 }
-/** Bounded read for AMBIENT snapshot surfaces so orphaned snapshots expire. The owner (both session ids non-empty and `===`) always sees its own state;
- * all others, null ids included (null === null is no match), get it only if age(updated_at) <= maxAgeMs (default `SNAPSHOT_AMBIENT_MAX_AGE_MS`), else null. */
+/** Bounded read for AMBIENT snapshot surfaces so orphaned snapshots expire. The owner (both session ids non-empty and
+ * `===`) always sees its own state; all others, null ids included (null === null is no match), get it only if
+ * age(updated_at) <= maxAgeMs (default `SNAPSHOT_AMBIENT_MAX_AGE_MS`), else null. */
 export function loadFreshActiveTaskSnapshot(hippoRoot, tenantId, opts = {}, key) {
     return freshActiveSnapshot(loadActiveTaskSnapshot(hippoRoot, tenantId, key), opts);
 }
@@ -128,7 +134,10 @@ export function clearActiveTaskSnapshot(hippoRoot, tenantId, clearedStatus = 'cl
     const now = new Date().toISOString();
     try {
         // SAFETY: active's shape matches the single `id` column selected above.
-        const active = db.prepare(`SELECT id FROM task_snapshots WHERE status = 'active' AND tenant_id = ? ORDER BY updated_at DESC, id DESC LIMIT 1`).get(tenantId);
+        const active = db
+            .prepare(`SELECT id FROM task_snapshots WHERE status = 'active' AND tenant_id = ? ORDER BY updated_at DESC, id DESC ` +
+            `LIMIT 1`)
+            .get(tenantId);
         if (!active?.id) {
             removeActiveTaskMirror(hippoRoot, tenantId);
             return false;
@@ -141,8 +150,8 @@ export function clearActiveTaskSnapshot(hippoRoot, tenantId, clearedStatus = 'cl
         closeHippoDb(db);
     }
 }
-/** Close the `active` task snapshot(s) owned by `sessionId` at session end; the WHERE scopes on `session_id` too so an ending session can never close a
- * newer session's snapshot. Returns the number of rows closed. */
+/** Close the `active` task snapshot(s) owned by `sessionId` at session end; the WHERE scopes on `session_id` too so an
+ * ending session can never close a newer session's snapshot. Returns the number of rows closed. */
 export function closeTaskSnapshotsForSession(hippoRoot, tenantId, sessionId, status = 'session-ended', key) {
     assertTenantId('closeTaskSnapshotsForSession', tenantId);
     if (key)
@@ -151,7 +160,10 @@ export function closeTaskSnapshotsForSession(hippoRoot, tenantId, sessionId, sta
     const db = openStore(hippoRoot);
     const now = new Date().toISOString();
     try {
-        const result = db.prepare(`UPDATE task_snapshots SET status = ?, updated_at = ? WHERE status = 'active' AND tenant_id = ? AND session_id = ?${owned ? ` AND ${owned.sql}` : ''}`).run(status, now, tenantId, sessionId, ...(owned?.params ?? []));
+        const result = db
+            .prepare(`UPDATE task_snapshots SET status = ?, updated_at = ? WHERE status = 'active' AND tenant_id = ? AND ` +
+            `session_id = ?${owned ? ` AND ${owned.sql}` : ''}`)
+            .run(status, now, tenantId, sessionId, ...(owned?.params ?? []));
         return Number(result.changes ?? 0);
     }
     finally {
@@ -159,10 +171,13 @@ export function closeTaskSnapshotsForSession(hippoRoot, tenantId, sessionId, sta
     }
 }
 function insertSessionEventRow(db, tenantId, event, now) {
-    const result = db.prepare(`
-      INSERT INTO session_events(session_id, task, event_type, content, source, scope, metadata_json, tenant_id, created_at)
+    const result = db
+        .prepare(`
+      INSERT INTO session_events(session_id, task, event_type, content, source, scope, metadata_json, tenant_id,
+      created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(event.session_id, event.task ?? null, event.event_type, event.content, event.source ?? 'cli', event.scope ?? null, JSON.stringify(event.metadata ?? {}), tenantId, now);
+    `)
+        .run(event.session_id, event.task ?? null, event.event_type, event.content, event.source ?? 'cli', event.scope ?? null, JSON.stringify(event.metadata ?? {}), tenantId, now);
     return Number(result.lastInsertRowid ?? 0);
 }
 function reloadSessionEvent(db, id) {
@@ -179,13 +194,15 @@ function reloadSessionEvent(db, id) {
 }
 function recentSessionEventsOldestFirst(db, tenantId, sessionId, limit) {
     // SAFETY: recentRows' shape matches the nine columns named in the SELECT below.
-    const recentRows = db.prepare(`
+    const recentRows = db
+        .prepare(`
       SELECT id, session_id, task, event_type, content, source, scope, metadata_json, created_at
       FROM session_events
       WHERE session_id = ? AND tenant_id = ?
       ORDER BY created_at DESC, id DESC
       LIMIT ?
-    `).all(sessionId, tenantId, limit);
+    `)
+        .all(sessionId, tenantId, limit);
     return recentRows.map(rowToSessionEvent).reverse();
 }
 export function appendSessionEvent(hippoRoot, tenantId, event) {
@@ -232,7 +249,8 @@ export function listSessionEvents(hippoRoot, tenantId, options = {}) {
         return rows.map(rowToSessionEvent).reverse();
     }, openStore);
 }
-/** Session_ids with a `session_complete` event newer than `sinceMs`; bounds the sleep auto-promotion scan to a fixed window. */
+/** Session_ids with a `session_complete` event newer than `sinceMs`; bounds the sleep auto-promotion scan to a fixed
+ * window. */
 export function findPromotableSessions(hippoRoot, tenantId, sinceMs) {
     assertTenantId('findPromotableSessions', tenantId);
     return onHandle(hippoRoot, (db) => {
@@ -265,7 +283,8 @@ function selectSessionOwnerAt(db, tenantId, sessionId) {
 }
 /** Binds `sessionId` to `owner` unless a binding exists; the count is 1 when this call bound it. */
 function insertSessionOwnerAt(db, tenantId, sessionId, owner, createdAt) {
-    const result = db.prepare(`INSERT OR IGNORE INTO session_owners(tenant_id, session_id, owner_subject, created_at) VALUES (?, ?, ?, ?)`)
+    const result = db
+        .prepare(`INSERT OR IGNORE INTO session_owners(tenant_id, session_id, owner_subject, created_at) VALUES (?, ?, ?, ?)`)
         .run(tenantId, sessionId, owner, createdAt);
     return Number(result.changes ?? 0);
 }

package/dist/store/set-aside.d.ts

@@ -1,6 +1,5 @@
 import type { DatabaseSyncLike } from '../db/index.js';
 import { type MemoryEntry } from '../core/memory.js';
-export declare const SYNC_ACTOR = "agent-memories";
 export type SetAsideWhy = 'note-gone' | 'note-changed' | 'handover' | 'project-merge' | 'project-repair';
 export type SetAsideResult = {
     readonly kind: 'untagged';
@@ -9,6 +8,7 @@ export type SetAsideResult = {
     readonly kind: 'dormant';
     readonly id: string;
 };
-/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant,
+ * restorable. */
 export declare function setAsideRow(db: DatabaseSyncLike, tag: string, row: MemoryEntry, why: SetAsideWhy): SetAsideResult;
 //# sourceMappingURL=set-aside.d.ts.map

package/dist/store/set-aside.js

@@ -1,13 +1,21 @@
-// Takes an imported agent note out of recall on the caller's transaction; the note sync and the project repair both use it.
+// Takes an imported agent note out of recall on the caller's transaction; the note sync and the project repair both use
+// it.
 import { appendAuditEvent } from './audit.js';
+import { SYNC_ACTOR } from '../core/agent-memory-tools.js';
 import { insertDormantRow } from './dormant.js';
 import { calculateStrength } from '../core/memory.js';
 import { deleteEntryRowInTx, setEntryTagsInTx } from './entry-writes.js';
-export const SYNC_ACTOR = 'agent-memories';
-/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
+/** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant,
+ * restorable. */
 export function setAsideRow(db, tag, row, why) {
     const untagged = { ...row, tags: row.tags.filter((t) => t !== tag) };
-    const audit = (metadata) => appendAuditEvent(db, { tenantId: row.tenantId, actor: SYNC_ACTOR, op: 'agent_memory_set_aside', targetId: row.id, metadata });
+    const audit = (metadata) => appendAuditEvent(db, {
+        tenantId: row.tenant_id,
+        actor: SYNC_ACTOR,
+        op: 'agent_memory_set_aside',
+        targetId: row.id,
+        metadata,
+    });
     if (row.pinned) {
         setEntryTagsInTx(db, untagged);
         audit({ why, untagged: true });
@@ -15,7 +23,12 @@ export function setAsideRow(db, tag, row, why) {
     }
     const now = new Date();
     // Sleep's dormant move skips kept rows, so the steps are written out here without its filter.
-    insertDormantRow(db, { entry: untagged, strength: calculateStrength(row, now), reason: 'source-deleted', dormantAt: now.toISOString() });
+    insertDormantRow(db, {
+        entry: untagged,
+        strength: calculateStrength(row, now),
+        reason: 'source-deleted',
+        dormantAt: now.toISOString(),
+    });
     deleteEntryRowInTx(db, row, SYNC_ACTOR);
     audit({ why });
     return { kind: 'dormant', id: row.id };

package/dist/store/sqlite/agent-import.d.ts

@@ -0,0 +1,3 @@
+import type { AgentImport } from '../port/agent-import.js';
+export declare const sqliteAgentImport: AgentImport;
+//# sourceMappingURL=agent-import.d.ts.map

package/dist/store/sqlite/agent-import.js

@@ -0,0 +1,77 @@
+// AgentImport on hippo.db: each target holds one bare handle, and a container's calls run on it in one scope.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { closeHippoDb, isSqliteBusy, outsideRequestStores, withTrialScope, withWriteScope, } from '../../db/index.js';
+import { appendAuditEvent } from '../audit.js';
+import { deleteDormantRow, dormantSnapshotsBySourcePrefix, readDormantSnapshot, replaceDormantEntry, } from '../dormant.js';
+import { stampOriginProject } from '../entry-row.js';
+import { entryIdTakenAt, selectLiveEntriesBySourcePrefix, selectRowsOutsideSourcePrefixAt } from '../entry-reads.js';
+import { renameEntrySourceAndOriginAt, renameEntrySourceAt, setEntryTagsInTx, supersedeEntryAt, writeEntryMirrors, } from '../entry-writes.js';
+import { gatedWrite } from '../gated-write.js';
+import { updateStats } from '../index-and-stats.js';
+import { removeEntryMirrors } from '../mirrors.js';
+import { initStore, openBareHandle } from '../open.js';
+import { projectTagReads } from '../project-tags.js';
+import { findRejectedValue, rejectionDigest } from '../rejection.js';
+import { setAsideRow } from '../set-aside.js';
+import { markSummaryDirtyInTx } from '../summary-dirty.js';
+import { resolveTenantId } from '../tenant.js';
+function containerTx(db, root) {
+    return {
+        liveBySourcePrefix: (tenantId, prefix) => selectLiveEntriesBySourcePrefix(db, tenantId, prefix),
+        dormantBySourcePrefix: (tenantId, prefix) => dormantSnapshotsBySourcePrefix(db, tenantId, prefix),
+        readDormant: (tenantId, id) => readDormantSnapshot(db, tenantId, id),
+        deleteDormant: (tenantId, id) => {
+            deleteDormantRow(db, tenantId, id);
+        },
+        replaceDormant: (tenantId, id, entry) => replaceDormantEntry(db, tenantId, id, entry),
+        entryIdTaken: (id) => entryIdTakenAt(db, id),
+        isRejected: (tenantId, text) => findRejectedValue(db, tenantId, rejectionDigest(text)) !== null,
+        renameSource: (tenantId, id, from, to) => renameEntrySourceAt(db, tenantId, id, from, to),
+        renameSourceAndOrigin: (tenantId, id, move) => renameEntrySourceAndOriginAt(db, tenantId, id, move),
+        setTags: (entry) => setEntryTagsInTx(db, entry),
+        supersede: (tenantId, id, newId) => supersedeEntryAt(db, tenantId, id, newId),
+        markSummaryDirty: (summaryId, tenantId, actor) => markSummaryDirtyInTx(db, summaryId, tenantId, actor),
+        appendAudit: (event) => appendAuditEvent(db, event),
+        gatedWrite: (entry, opts) => gatedWrite(db, root, entry, opts),
+        setAside: (tag, row, why) => setAsideRow(db, tag, row, why),
+        stampOrigin: (entry) => stampOriginProject(root, entry),
+    };
+}
+function importTarget(db, root, close) {
+    const tenantId = resolveTenantId({});
+    return {
+        root,
+        tenantId,
+        liveBySourcePrefix: (prefix) => selectLiveEntriesBySourcePrefix(db, tenantId, prefix),
+        rowsOutsideSourcePrefix: (prefix, origins) => selectRowsOutsideSourcePrefixAt(db, tenantId, prefix, origins),
+        projectTagReads: () => projectTagReads(db, tenantId),
+        inContainer: (scope, dryRun, work) => {
+            const run = () => work(containerTx(db, root));
+            return dryRun ? withTrialScope(db, scope, run) : withWriteScope(db, scope, run);
+        },
+        writeMirror: (entry) => writeEntryMirrors(root, entry),
+        removeMirror: (id) => removeEntryMirrors(root, id),
+        bumpRemembered: (count) => updateStats(root, { remembered: count }),
+        close,
+    };
+}
+export const sqliteAgentImport = {
+    create: (root) => initStore(root),
+    open: (root, opts) => {
+        const db = openBareHandle(root, { busyWaitMs: opts.busyWaitMs });
+        return importTarget(db, root, () => closeHippoDb(db));
+    },
+    openStandIn: () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'hippo-agent-memories-'));
+        // Its folder is deleted at close, so a request scope must not keep the file open past that.
+        const db = outsideRequestStores(() => openBareHandle(root));
+        return importTarget(db, root, () => {
+            closeHippoDb(db);
+            fs.rmSync(root, { recursive: true, force: true });
+        });
+    },
+    isBusy: (err) => isSqliteBusy(err),
+};
+//# sourceMappingURL=agent-import.js.map

package/dist/store/sqlite/cards-group.d.ts

@@ -0,0 +1,6 @@
+import type { Cards } from '../port-groups.js';
+import type { Sync } from '../port.js';
+export declare function sqliteCards(hippoRoot: string): Sync<Cards>;
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export declare function servedCards(sync: Sync<Cards>): Cards;
+//# sourceMappingURL=cards-group.d.ts.map

package/dist/store/sqlite/cards-group.js

@@ -0,0 +1,37 @@
+// hippo.db's Cards group: the agent work board.
+import { loadCardDetail } from '../card-detail.js';
+import { addCardComment, blockCard, claimCard, completeCard, createCard, heartbeatCard, listCards, loadCard, loadCardRuns, reclaimExpiredCards, reviewCard, } from '../cards.js';
+export function sqliteCards(hippoRoot) {
+    return {
+        create: (tenantId, input) => createCard(hippoRoot, tenantId, { ...input, dependsOn: input.dependsOn ? [...input.dependsOn] : undefined }),
+        load: (tenantId, id) => loadCard(hippoRoot, tenantId, id),
+        detail: (tenantId, id) => loadCardDetail(hippoRoot, tenantId, id),
+        list: (tenantId, opts) => listCards(hippoRoot, tenantId, opts),
+        runs: (tenantId, id) => loadCardRuns(hippoRoot, tenantId, id),
+        claim: (tenantId, id, runtime, sessionId) => claimCard(hippoRoot, tenantId, id, runtime, sessionId),
+        heartbeat: (tenantId, id, runId) => heartbeatCard(hippoRoot, tenantId, id, runId),
+        block: (tenantId, id, reason, runId) => blockCard(hippoRoot, tenantId, id, reason, runId),
+        review: (tenantId, id, runId) => reviewCard(hippoRoot, tenantId, id, runId),
+        complete: (tenantId, id, outcome, runId) => completeCard(hippoRoot, tenantId, id, outcome, runId),
+        reclaimExpired: (tenantId) => reclaimExpiredCards(hippoRoot, tenantId),
+        comment: (tenantId, cardId, author, body) => addCardComment(hippoRoot, tenantId, cardId, author, body),
+    };
+}
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export function servedCards(sync) {
+    return {
+        create: async (tenantId, input) => sync.create(tenantId, input),
+        load: async (tenantId, id) => sync.load(tenantId, id),
+        detail: async (tenantId, id) => sync.detail(tenantId, id),
+        list: async (tenantId, opts) => sync.list(tenantId, opts),
+        runs: async (tenantId, id) => sync.runs(tenantId, id),
+        claim: async (tenantId, id, runtime, sessionId) => sync.claim(tenantId, id, runtime, sessionId),
+        heartbeat: async (tenantId, id, runId) => sync.heartbeat(tenantId, id, runId),
+        block: async (tenantId, id, reason, runId) => sync.block(tenantId, id, reason, runId),
+        review: async (tenantId, id, runId) => sync.review(tenantId, id, runId),
+        complete: async (tenantId, id, outcome, runId) => sync.complete(tenantId, id, outcome, runId),
+        reclaimExpired: async (tenantId) => sync.reclaimExpired(tenantId),
+        comment: async (tenantId, cardId, author, body) => sync.comment(tenantId, cardId, author, body),
+    };
+}
+//# sourceMappingURL=cards-group.js.map

package/dist/store/sqlite/conflicts-group.d.ts

@@ -0,0 +1,6 @@
+import type { Conflicts } from '../port-groups.js';
+import type { Sync } from '../port.js';
+export declare function sqliteConflicts(hippoRoot: string): Sync<Conflicts>;
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export declare function servedConflicts(sync: Sync<Conflicts>): Conflicts;
+//# sourceMappingURL=conflicts-group.d.ts.map

package/dist/store/sqlite/conflicts-group.js

@@ -0,0 +1,18 @@
+// hippo.db's Conflicts group: listing and resolving the memory_conflicts rows.
+import { listMemoryConflicts, listTouchableConflicts, resolveConflict } from '../conflicts.js';
+export function sqliteConflicts(hippoRoot) {
+    return {
+        list: (tenantId, status) => listMemoryConflicts(hippoRoot, status, tenantId ?? undefined),
+        listTouchable: (tenantId, status, actor) => listTouchableConflicts(hippoRoot, status, tenantId, actor),
+        resolve: (tenantId, request, opts) => resolveConflict(hippoRoot, { ...request, tenantId }, opts),
+    };
+}
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export function servedConflicts(sync) {
+    return {
+        list: async (tenantId, status) => sync.list(tenantId, status),
+        listTouchable: async (tenantId, status, actor) => sync.listTouchable(tenantId, status, actor),
+        resolve: async (tenantId, request, opts) => sync.resolve(tenantId, request, opts),
+    };
+}
+//# sourceMappingURL=conflicts-group.js.map

package/dist/store/sqlite/connector-events-group.d.ts

@@ -1,5 +1,6 @@
 import type { ConnectorEvents, Sync } from '../port.js';
 export declare function sqliteConnectorEvents(hippoRoot: string): Sync<ConnectorEvents>;
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function servedConnectorEvents(sync: Sync<ConnectorEvents>): ConnectorEvents;
 //# sourceMappingURL=connector-events-group.d.ts.map

package/dist/store/sqlite/connector-events-group.js

@@ -1,9 +1,11 @@
 // hippo.db's half of the ConnectorEvents store group: each call on a handle of its own.
-import { archiveDeletedArtifact, githubEventRecord, githubEventSeenAt, githubRouting, insertGitHubDlq, markGitHubEventSeen } from '../connectors/github.js';
-import { insertSlackDlq, markSlackEventSeen, rawMemoryIdForArtifactAt, slackEventRecord, slackEventSeenAt, slackTeamRoute } from '../connectors/slack.js';
+import { archiveDeletedArtifact, githubEventRecord, githubEventSeenAt, githubRouting, insertGitHubDlq, markGitHubEventSeen, } from '../connectors/github.js';
+import { insertSlackDlq, markSlackEventSeen, rawMemoryIdForArtifactAt, slackEventRecord, slackEventSeenAt, slackTeamRoute, } from '../connectors/slack.js';
 import { onHandle } from '../open.js';
 function eventRecord(hippoRoot, event) {
-    return event.connector === 'slack' ? slackEventRecord(hippoRoot, event.eventId) : githubEventRecord(hippoRoot, event.idempotencyKey);
+    return event.connector === 'slack'
+        ? slackEventRecord(hippoRoot, event.eventId)
+        : githubEventRecord(hippoRoot, event.idempotencyKey);
 }
 function markEventSeen(hippoRoot, event) {
     if (event.connector === 'slack')
@@ -19,7 +21,15 @@ function deletionTarget(hippoRoot, { event, artifactRef, tenantId }) {
 }
 function archiveArtifact(hippoRoot, { tenantId, actor, artifactRef, reason, event }) {
     const { idempotencyKey, deliveryId, eventName } = event;
-    return archiveDeletedArtifact(hippoRoot, { tenantId, artifactRef, idempotencyKey, deliveryId, eventName, reason, who: actor });
+    return archiveDeletedArtifact(hippoRoot, {
+        tenantId,
+        artifactRef,
+        idempotencyKey,
+        deliveryId,
+        eventName,
+        reason,
+        who: actor,
+    });
 }
 export function sqliteConnectorEvents(hippoRoot) {
     return {
@@ -29,10 +39,11 @@ export function sqliteConnectorEvents(hippoRoot) {
         archiveDeletedArtifact: (archive) => archiveArtifact(hippoRoot, archive),
         slackTeamRoute: (teamId) => slackTeamRoute(hippoRoot, teamId),
         githubRouting: (query) => githubRouting(hippoRoot, query),
-        parkDeadLetter: (letter) => (letter.connector === 'slack' ? insertSlackDlq(hippoRoot, letter) : insertGitHubDlq(hippoRoot, letter)),
+        parkDeadLetter: (letter) => letter.connector === 'slack' ? insertSlackDlq(hippoRoot, letter) : insertGitHubDlq(hippoRoot, letter),
     };
 }
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export function servedConnectorEvents(sync) {
     return {
         eventRecord: async (event) => sync.eventRecord(event),

package/dist/store/sqlite/connector-writes-group.d.ts

@@ -1,6 +1,7 @@
 import type { ConnectorWrites, Sync } from '../port.js';
 /** Each call on its own handle; the mirror follows the commit, so a duplicate or a rolled-back write leaves none. */
 export declare function sqliteConnectorWrites(hippoRoot: string): Sync<ConnectorWrites>;
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export declare function servedConnectorWrites(sync: Sync<ConnectorWrites>): ConnectorWrites;
 //# sourceMappingURL=connector-writes-group.d.ts.map

package/dist/store/sqlite/connector-writes-group.js

@@ -16,13 +16,19 @@ function logEvent(db, event, memoryId) {
     return markGitHubEventSeenAt(db, { idempotencyKey, deliveryId, eventName, memoryId });
 }
 function loggedMemory(db, event) {
-    return event.connector === 'slack' ? slackEventMemoryAt(db, event.eventId) : githubEventMemoryAt(db, event.idempotencyKey);
+    return event.connector === 'slack'
+        ? slackEventMemoryAt(db, event.eventId)
+        : githubEventMemoryAt(db, event.idempotencyKey);
 }
-/** The record, then the log row, go in after the memory row and ahead of its remember row, as a second store must order them. */
+/** The record, then the log row, go in after the memory row and ahead of its remember row, as a second store must order
+ * them. */
 function writeWithCompanions(db, { entry, actor, event, quarantine }) {
     writeInOwnTenant(db, entry, actor, (handle, memoryId) => {
-        if (quarantine)
-            recordQuarantine(handle, { tenantId: entry.tenantId, memoryId, originalScope: quarantine.originalScope, reason: quarantine.reason, actor });
+        if (quarantine) {
+            recordQuarantine(handle, {
+                tenantId: entry.tenant_id, memoryId, originalScope: quarantine.originalScope, reason: quarantine.reason, actor,
+            });
+        }
         if (event && !logEvent(handle, event, memoryId))
             throw new EventAlreadyLogged();
     });
@@ -55,7 +61,8 @@ export function sqliteConnectorWrites(hippoRoot) {
         },
     };
 }
-/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as another store's would. */
+/** The group as a served store answers it: each call runs at once and resolves through a Promise, so a throw rejects as
+ * another store's would. */
 export function servedConnectorWrites(sync) {
     return {
         writeConnectorEntry: async (write) => sync.writeConnectorEntry(write),

package/dist/store/sqlite/consolidation-group.d.ts

@@ -0,0 +1,4 @@
+import type { Consolidation } from '../port/consolidation.js';
+/** Sleep's store work on the hippo.db under `hippoRoot`, each call on its own short-lived handle. */
+export declare function sqliteConsolidation(hippoRoot: string): Consolidation;
+//# sourceMappingURL=consolidation-group.d.ts.map

package/dist/store/sqlite/consolidation-group.js

@@ -0,0 +1,64 @@
+import { SLEEP_DB_WAIT_MS } from '../../db/index.js';
+import { recordAuditEventsRowByRow, reportAuditWriteFailure } from '../audit.js';
+import { replaceDetectedConflicts } from '../conflicts.js';
+import { commitInChunks, deleteEntriesOneByOne, failedUnitOf, memoriesBackingObjects } from '../delete-and-batch.js';
+import { expireDormantBefore } from '../dormant.js';
+import { loadAllEntries, loadAllEntriesWithBase, loadCurrentDistilledEntries } from '../entry-reads.js';
+import { ftsDrift } from '../entry-row.js';
+import { writeEntriesTogether, writeEntry } from '../entry-writes.js';
+import { loadPendingExtractionTenants, markPendingProcessedUpTo } from '../graph-queue.js';
+import { moveHalfLives, recordedHalfLifeBase } from '../half-life.js';
+import { appendConsolidationRun, incrementSleepCount, loadSessionDecayContext } from '../index-and-stats.js';
+import { findPromotableSessions, listSessionEvents, traceExistsForSession } from '../sessions.js';
+import { applyRebuildResult, childrenKey, clearSummaryDirtyAfterBuild, loadAllDirtySummaries, loadAllL2Summaries, loadChildrenOfSummaries, loadChildrenOfSummary, } from '../summaries.js';
+import { lazyTombstoneChecks } from '../tombstone-checks.js';
+import { loadStoredParticles, saveStoredParticles } from '../vector-index.js';
+import { errorMessage } from '../../util/log.js';
+/** Sleep's store work on the hippo.db under `hippoRoot`, each call on its own short-lived handle. */
+export function sqliteConsolidation(hippoRoot) {
+    return {
+        entriesWithBase: () => loadAllEntriesWithBase(hippoRoot),
+        objectBackedIds: () => memoriesBackingObjects(hippoRoot),
+        ftsDrift: (repair) => ftsDrift(hippoRoot, repair),
+        sessionDecayContext: () => loadSessionDecayContext(hippoRoot),
+        tombstoneChecks: (dryRun) => lazyTombstoneChecks(hippoRoot, dryRun),
+        halfLifeBase: () => recordedHalfLifeBase(hippoRoot),
+        moveHalfLives: (to, opts, plan) => moveHalfLives(hippoRoot, to, opts, plan),
+        promotableSessions: (tenantId, sinceMs) => findPromotableSessions(hippoRoot, tenantId, sinceMs),
+        traceExists: (tenantId, sessionId) => traceExistsForSession(hippoRoot, tenantId, sessionId),
+        sessionEvents: (tenantId, opts) => listSessionEvents(hippoRoot, tenantId, opts),
+        storedParticles: () => loadStoredParticles(hippoRoot),
+        saveParticles: (particles) => saveStoredParticles(hippoRoot, particles),
+        // The wait is sleep's own, not a server request's 250 ms.
+        commitFlush: (components, opts) => commitInChunks(hippoRoot, components, { ...opts, busyWaitMs: SLEEP_DB_WAIT_MS }),
+        expireDormant: (cutoffIso, opts) => expireDormantBefore(hippoRoot, cutoffIso, { ...opts, busyWaitMs: SLEEP_DB_WAIT_MS }),
+        replaceConflicts: (detected, detectedAt) => replaceDetectedConflicts(hippoRoot, detected, detectedAt),
+        recordRun: (run) => appendConsolidationRun(hippoRoot, run),
+        countSleep: () => incrementSleepCount(hippoRoot),
+        auditEachRow(events) {
+            const failed = recordAuditEventsRowByRow(hippoRoot, events);
+            for (const { event, error } of failed)
+                reportAuditWriteFailure(event.op, errorMessage(error), event.targetId);
+            return failed.length;
+        },
+        reportAuditFailure: (op, reason) => reportAuditWriteFailure(op, reason),
+        allEntries: () => loadAllEntries(hippoRoot),
+        currentDistilledEntries: () => loadCurrentDistilledEntries(hippoRoot),
+        deleteOneByOne: (targets, opts) => deleteEntriesOneByOne(hippoRoot, targets, opts),
+        failedUnitOf,
+        dirtyGraphTenants: () => loadPendingExtractionTenants(hippoRoot),
+        markGraphDrained: (tenantId, maxId) => markPendingProcessedUpTo(hippoRoot, tenantId, maxId),
+        writeEntry: (entry) => writeEntry(hippoRoot, entry),
+        writeTogether: (entries) => writeEntriesTogether(hippoRoot, entries),
+        dirtySummaries: (limit) => loadAllDirtySummaries(hippoRoot, limit),
+        childrenOfSummary: (summaryId, tenantId) => loadChildrenOfSummary(hippoRoot, summaryId, tenantId),
+        childrenOfSummaries(summaries) {
+            const byParent = loadChildrenOfSummaries(hippoRoot, summaries);
+            return (summary) => byParent.get(childrenKey(summary.tenant_id, summary.id)) ?? [];
+        },
+        applyRebuild: (summary, patch) => applyRebuildResult(hippoRoot, summary, patch),
+        clearSummaryDirty: (summaryId, tenantId, actor, source) => clearSummaryDirtyAfterBuild(hippoRoot, summaryId, tenantId, actor, source),
+        unprofiledTopicSummaries: () => loadAllL2Summaries(hippoRoot),
+    };
+}
+//# sourceMappingURL=consolidation-group.js.map

package/dist/store/sqlite/dag-reads-group.js

@@ -1,5 +1,5 @@
 import { pagedDescendants } from '../descendant-page.js';
-import { countSessionRawMemories, loadSessionRawMemories, selectChildrenByParent, selectEntriesByIds } from '../entry-reads.js';
+import { countSessionRawMemories, loadSessionRawMemories, selectChildrenByParent, selectEntriesByIds, } from '../entry-reads.js';
 import { onHandle, openStore } from '../open.js';
 export function sqliteDagReads(hippoRoot) {
     return {

package/dist/store/sqlite/dormant-group.d.ts

@@ -0,0 +1,6 @@
+import type { Dormant } from '../port-groups.js';
+import type { Sync } from '../port.js';
+export declare function sqliteDormant(hippoRoot: string): Sync<Dormant>;
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export declare function servedDormant(sync: Sync<Dormant>): Dormant;
+//# sourceMappingURL=dormant-group.d.ts.map

package/dist/store/sqlite/dormant-group.js

@@ -0,0 +1,29 @@
+// hippo.db's Dormant group: the memories sleep set aside, listed, restored or forgotten for good.
+import { forgetDormantMemory, holdsDormantMemory, loadDormantMemories, restoreDormantMemory } from '../dormant.js';
+import { updateStatsUnlessBusy } from '../index-and-stats.js';
+import { touchableScopeSql } from '../rule-sql.js';
+export function sqliteDormant(hippoRoot) {
+    return {
+        list: (tenantId, ownScope, opts) => loadDormantMemories(hippoRoot, tenantId, opts, touchableScopeSql('', ownScope)),
+        holds: (tenantId, ownScope, id) => holdsDormantMemory(hippoRoot, tenantId, id, touchableScopeSql('', ownScope)),
+        restore: (tenantId, request) => restoreDormantMemory(hippoRoot, { ...request, tenantId }),
+        forget(tenantId, ownScope, id, actor) {
+            const admit = touchableScopeSql('', ownScope);
+            if (!forgetDormantMemory(hippoRoot, { tenantId, id, actor, admit }))
+                return false;
+            // Counted like every other permanent removal (forget, archiveRaw).
+            updateStatsUnlessBusy(hippoRoot, { forgotten: 1 }, `removed ${id}`);
+            return true;
+        },
+    };
+}
+/** The group as a served store answers it: a throw rejects as another store's would. */
+export function servedDormant(sync) {
+    return {
+        list: async (tenantId, ownScope, opts) => sync.list(tenantId, ownScope, opts),
+        holds: async (tenantId, ownScope, id) => sync.holds(tenantId, ownScope, id),
+        restore: async (tenantId, request) => sync.restore(tenantId, request),
+        forget: async (tenantId, ownScope, id, actor) => sync.forget(tenantId, ownScope, id, actor),
+    };
+}
+//# sourceMappingURL=dormant-group.js.map

package/dist/store/sqlite/entry-writes-group.d.ts

@@ -2,17 +2,20 @@ import { type DatabaseSyncLike } from '../../db/index.js';
 import { type MemoryEntry } from '../../core/memory.js';
 import { type ArchiveOpts } from '../raw-archive.js';
 import type { EntryWrite, EntryWrites, OutcomeWrite, RawArchive, Sync } from '../port.js';
-import { type WriteEntryOptions } from '../entry-writes.js';
-/** Each call on its own handle; mirrors and the forgotten counter follow the commit, so a rolled-back write leaves neither. */
+import { type WriteEntryInternalOptions } from '../entry-writes.js';
+/** Each call on its own handle; mirrors and the forgotten counter follow the commit, so a rolled-back write leaves
+ * neither. */
 export declare function sqliteEntryWrites(hippoRoot: string): Sync<EntryWrites>;
 /** A store-side hook writes on the row's handle inside its write scope, so its throw undoes the row. */
-export declare function writeEntryAt(hippoRoot: string, { entry, actor }: EntryWrite, afterWrite?: WriteEntryOptions['afterWrite']): void;
-/** A trace link follows the commit on the same handle and names only the ids applied, so a rolled-back outcome leaves none. */
+export declare function writeEntryAt(hippoRoot: string, { entry, actor }: EntryWrite, afterWrite?: WriteEntryInternalOptions['afterWrite']): void;
+/** A trace link follows the commit on the same handle and names only the ids applied, so a rolled-back outcome leaves
+ * none. */
 export declare function applyOutcomeAt(hippoRoot: string, outcome: OutcomeWrite, traceId?: number): string[];
-/** Reach is checked inside the archive's write scope. A store-side hook writes on the same handle inside that scope, so its throw undoes the archive. */
+/** Reach is checked inside the archive's write scope. A store-side hook writes on the same handle inside that scope, so
+ * its throw undoes the archive. */
 export declare function archiveRawAt(hippoRoot: string, archive: RawArchive, afterArchive?: ArchiveOpts['afterArchive']): string;
 /** The refusal row lands after `write` has rolled back, in a fresh implicit transaction the aborted one cannot undo. */
 export declare function auditingRefusal<T>(db: DatabaseSyncLike, actor: string, write: () => T): T;
 /** writeEntryAt on the caller's handle, so a sibling group can read on it after the scope has unwound. */
-export declare function writeInOwnTenant(db: DatabaseSyncLike, entry: MemoryEntry, actor: string, afterWrite?: WriteEntryOptions['afterWrite']): void;
+export declare function writeInOwnTenant(db: DatabaseSyncLike, entry: MemoryEntry, actor: string, afterWrite?: WriteEntryInternalOptions['afterWrite']): void;
 //# sourceMappingURL=entry-writes-group.d.ts.map