hippo-memory 2.0.0 → 2.1.0

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.tenant_id, 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,15 +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)
+        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();
     });
@@ -57,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

@@ -3,13 +3,16 @@ 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 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. */
+/** 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?: 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. */
+/** 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;

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

@@ -1,4 +1,5 @@
-// hippo.db's half of the EntryWrites store group: the queries remember, outcome, supersede, archive and forget run today.
+// hippo.db's half of the EntryWrites store group: the queries remember, outcome, supersede, archive and forget run
+// today.
 import { ConflictError, NotFoundError } from '../../core/api-errors.js';
 import { appendAuditEvent } from '../audit.js';
 import { isSqliteBusy, withWriteScope } from '../../db/index.js';
@@ -18,7 +19,8 @@ import { updateStatsUnlessBusy } from '../index-and-stats.js';
 import { purgeMirrorBestEffort, removeEntryMirrors } from '../mirrors.js';
 import { onHandle, openStore } from '../open.js';
 import { selectMemoryReach } from '../tenant-lookup.js';
-/** Each call on its own handle; mirrors and the forgotten counter follow the commit, so a rolled-back write leaves neither. */
+/** Each call on its own handle; mirrors and the forgotten counter follow the commit, so a rolled-back write leaves
+ * neither. */
 export function sqliteEntryWrites(hippoRoot) {
     return {
         writeEntry(write) {
@@ -52,13 +54,19 @@ export function writeEntryAt(hippoRoot, { entry, actor }, afterWrite) {
     onHandle(hippoRoot, (db) => writeInOwnTenant(db, stamped, actor, afterWrite), openStore);
     writeEntryMirrors(hippoRoot, stamped);
 }
-/** A trace link follows the commit on the same handle and names only the ids applied, so a rolled-back outcome leaves none. */
+/** A trace link follows the commit on the same handle and names only the ids applied, so a rolled-back outcome leaves
+ * none. */
 export function applyOutcomeAt(hippoRoot, outcome, traceId) {
     const applied = onHandle(hippoRoot, (db) => {
         const rows = applyOutcomeOn(db, outcome);
         const memoryIds = rows.map((entry) => entry.id);
         if (traceId !== undefined && rows.length > 0) {
-            recordTraceOutcome(db, { traceId, tenantId: outcome.tenantId, outcome: outcome.good ? 'positive' : 'negative', memoryIds });
+            recordTraceOutcome(db, {
+                traceId,
+                tenantId: outcome.tenantId,
+                outcome: outcome.good ? 'positive' : 'negative',
+                memoryIds,
+            });
         }
         return rows;
     }, openStore);
@@ -66,7 +74,8 @@ export function applyOutcomeAt(hippoRoot, outcome, traceId) {
         writeEntryMirrors(hippoRoot, entry);
     return applied.map((entry) => entry.id);
 }
-/** 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 function archiveRawAt(hippoRoot, archive, afterArchive) {
     const archivedAt = onHandle(hippoRoot, (db) => {
         const at = withWriteScope(db, 'archive_raw_in_reach', () => {
@@ -88,11 +97,13 @@ function assertInReach(db, target, id) {
     if (reach?.tenantId !== target.tenantId || !ownScopeTouches(target.ownScope, reach.scope))
         throw notFound(id);
 }
-/** hippo.db's upsert would move the row into the writer's tenant, so a store write refuses an id another tenant holds. */
+/** hippo.db's upsert would move the row into the writer's tenant, so a store write refuses an id another tenant
+ * holds. */
 function assertIdInTenant(db, entry) {
     const holder = selectMemoryReach(db, entry.id)?.tenantId;
-    if (holder !== undefined && holder !== entry.tenant_id)
+    if (holder !== undefined && holder !== entry.tenant_id) {
         throw new ConflictError(`Memory ${entry.id} belongs to another tenant`);
+    }
 }
 /** The refusal row lands after `write` has rolled back, in a fresh implicit transaction the aborted one cannot undo. */
 export function auditingRefusal(db, actor, write) {
@@ -112,7 +123,8 @@ export function writeInOwnTenant(db, entry, actor, afterWrite) {
         writeEntryDbOnly(db, entry, { actor, afterWrite });
     }));
 }
-/** The reads, rewrites and outcome rows share one BEGIN IMMEDIATE transaction, hippo.db's form of the port's row lock; the caller writes the mirrors after. */
+/** The reads, rewrites and outcome rows share one BEGIN IMMEDIATE transaction, hippo.db's form of the port's row lock;
+ * the caller writes the mirrors after. */
 function applyOutcomeOn(db, outcome) {
     return auditingRefusal(db, outcome.actor, () => withWriteScope(db, 'apply_outcome', () => {
         const live = selectEntriesByIds(db, outcome.ids, outcome.tenantId);
@@ -124,20 +136,29 @@ function applyOutcomeOn(db, outcome) {
             const updated = entryAfterOutcome(entry, outcome.good);
             writeEntryDbOnly(db, updated, { actor: outcome.actor });
             live.set(id, updated);
-            appendAuditEvent(db, { tenantId: outcome.tenantId, actor: outcome.actor, op: 'outcome', targetId: id, metadata: { good: outcome.good } });
+            appendAuditEvent(db, {
+                tenantId: outcome.tenantId,
+                actor: outcome.actor,
+                op: 'outcome',
+                targetId: id,
+                metadata: { good: outcome.good },
+            });
             applied.push(updated);
         }
         return applied;
     }));
 }
-/** Reach, the CAS on the old row, the successor's insert and the supersede row in one BEGIN IMMEDIATE transaction. Two racing supersedes: one CAS wins. */
+/** Reach, the CAS on the old row, the successor's insert and the supersede row in one BEGIN IMMEDIATE transaction. Two
+ * racing supersedes: one CAS wins. */
 function commitSupersede(db, write) {
     const { tenantId, actor, oldId, successor } = write;
     // The refusal row lands after the scope has rolled back, in a fresh implicit transaction the aborted one cannot undo.
     auditingRefusal(db, actor, () => withWriteScope(db, 'supersede', () => {
         assertInReach(db, write, oldId);
         // SAFETY: RETURNING names one column, dag_parent_id; no row means another writer got there first.
-        const won = db.prepare('UPDATE memories SET superseded_by = ? WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL RETURNING dag_parent_id')
+        const won = db
+            .prepare('UPDATE memories SET superseded_by = ? WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL RETURNING ' +
+            'dag_parent_id')
             .get(successor.id, oldId, tenantId);
         if (!won)
             throw new ConflictError(`Memory ${oldId} already superseded by another writer`);
@@ -149,13 +170,15 @@ function commitSupersede(db, write) {
         appendAuditEvent(db, { tenantId, actor, op: 'supersede', targetId: oldId, metadata: { newId: successor.id } });
     }));
 }
-/** A mirror left on disk would bring the archived row back on the next import; on failure the reaper retries, as mirror_cleaned_at stays NULL. */
+/** A mirror left on disk would bring the archived row back on the next import; on failure the reaper retries, as
+ * mirror_cleaned_at stays NULL. */
 function cleanArchivedMirrors(db, hippoRoot, id) {
     try {
         removeEntryMirrors(hippoRoot, id);
     }
     catch (mirrorErr) {
-        log.error(`archiveRaw: mirror cleanup failed for ${id} (will retry via reaper on next openHippoDb): ${errorMessage(mirrorErr)}`, errorFields(mirrorErr));
+        log.error(`archiveRaw: mirror cleanup failed for ${id} (will retry via reaper on next openHippoDb): ` +
+            `${errorMessage(mirrorErr)}`, errorFields(mirrorErr));
         return;
     }
     try {
@@ -164,7 +187,7 @@ function cleanArchivedMirrors(db, hippoRoot, id) {
     catch (err) {
         if (!isSqliteBusy(err))
             throw err;
-        log.warnThenDebug('archive-mirror-stamp-busy', `archived ${id}; the store was busy, so the mirror reaper will re-check it on the next open`);
+        log.warnThenDebug('archive-mirror-stamp-busy', `archived ${id}; the store was busy, so the mirror reaper will re-check it on the next open`, errorFields(err));
     }
 }
 //# sourceMappingURL=entry-writes-group.js.map

package/dist/store/sqlite/error-codec.d.ts

@@ -1,7 +1,8 @@
 type FieldValue = string | number | boolean | null;
 /** One error as a thread message can carry it. */
 export interface WireError {
-    /** Constructor names from the thrown class up to Error: several classes set no `name`, so a name alone cannot pick the class. */
+    /** Constructor names from the thrown class up to Error: several classes set no `name`, so a name alone cannot pick
+     * the class. */
     readonly classes: readonly string[];
     readonly message: string;
     readonly stack: string | undefined;
@@ -11,7 +12,8 @@ export interface WireError {
 }
 /** Worker side. A thrown value that is not an Error carries its text and no class. */
 export declare function encodeError<E>(err: E, depth?: number): WireError;
-/** Server side: an instance of the thrown class, or of its nearest ancestor in the table, with the worker's stack, cause and fields. */
+/** Server side: an instance of the thrown class, or of its nearest ancestor in the table, with the worker's stack,
+ * cause and fields. */
 export declare function decodeError(wire: WireError): Error;
 export {};
 //# sourceMappingURL=error-codec.d.ts.map