hippo-memory 2.0.0 → 2.1.0

package/dist/store/connectors/event-log.d.ts

@@ -1,5 +1,7 @@
 import type { DatabaseSyncLike } from '../../db/index.js';
-import type { ConnectorEventRecord } from '../port.js';
+import type { EntryWrite, RawArchive } from '../port.js';
+import type { GitHubDlqInsert, GitHubRouting } from './github.js';
+import type { SlackDlqInsert, SlackTeamRoute } from './slack.js';
 /** Which log table a connector writes and the column its dedupe key lives in. */
 export interface EventLogSpec {
     readonly table: 'slack_event_log' | 'github_event_log';
@@ -7,7 +9,114 @@ export interface EventLogSpec {
 }
 export declare function eventSeenAt(db: DatabaseSyncLike, log: EventLogSpec, key: string): boolean;
 export declare function eventMemoryAt(db: DatabaseSyncLike, log: EventLogSpec, key: string): string | null;
-/** Records the key unless a row holds it already; false means another writer got there first. `extra` pairs connector-only columns with values. */
+/** Records the key unless a row holds it already; false means another writer got there first. `extra` pairs
+ * connector-only columns with values. */
 export declare function markEventSeenAt(db: DatabaseSyncLike, log: EventLogSpec, key: string, extra: ReadonlyArray<readonly [string, string]>, memoryId: string | null): boolean;
 export declare function eventRecord(hippoRoot: string, log: EventLogSpec, key: string): ConnectorEventRecord;
+/** The source event a connector's write answers, by the source's own key. The store logs each key once per connector,
+ * across every tenant. */
+export type ConnectorEvent = {
+    readonly connector: 'slack';
+    readonly eventId: string;
+} | {
+    readonly connector: 'github';
+    readonly idempotencyKey: string;
+    readonly deliveryId: string;
+    readonly eventName: string;
+};
+/** An entry a connector brings in. `quarantine` is the review record of flagged content, whose entry already carries
+ * its quarantine scope. */
+export interface ConnectorWrite extends EntryWrite {
+    readonly event?: ConnectorEvent;
+    readonly quarantine?: {
+        readonly originalScope: string | null;
+        readonly reason: string;
+    };
+}
+/** 'duplicate': the event's key was logged before; `memoryId` is the id its log row holds, null for an event logged
+ * with no memory. */
+export type ConnectorWriteOutcome = {
+    readonly outcome: 'written';
+} | {
+    readonly outcome: 'duplicate';
+    readonly memoryId: string | null;
+};
+export interface ConnectorArchive extends RawArchive {
+    readonly event: ConnectorEvent;
+}
+/** A connector's writes with the rows that must commit with them: the event log row
+ * that turns a redelivery into a no-op, and the quarantine record of flagged content. */
+export interface ConnectorWrites {
+    /** entryWrites.writeEntry plus, in its transaction: with `quarantine`, one pending record and quarantine row; with
+     * `event`, one log row. All commit or none. A key logged before resolves 'duplicate' and stores nothing (never a
+     * rejection); every other refusal is writeEntry's own, decided first. */
+    writeConnectorEntry(write: ConnectorWrite): Promise<ConnectorWriteOutcome>;
+    /** entryWrites.archiveRaw plus, in its transaction, one log row for `event` naming the archived id, so a redelivery
+     * finds it logged; a failed log write undoes the archive. A key logged before keeps its row and does not stop the
+     * archive. Reach and every rejection are archiveRaw's own. */
+    archiveConnectorEntry(archive: ConnectorArchive): Promise<string>;
+}
+/** What the event log holds for one event's key; `memoryId` is null for an event logged with no memory. */
+export type ConnectorEventRecord = {
+    readonly seen: false;
+} | {
+    readonly seen: true;
+    readonly memoryId: string | null;
+};
+export interface DeletionLookup {
+    readonly event: ConnectorEvent;
+    readonly artifactRef: string;
+    readonly tenantId: string;
+}
+/** `memoryId` is null when the tenant holds no raw row for the artifact. */
+export type DeletionTarget = {
+    readonly seen: true;
+} | {
+    readonly seen: false;
+    readonly memoryId: string | null;
+};
+export interface ArtifactArchive {
+    readonly tenantId: string;
+    readonly actor: string;
+    readonly artifactRef: string;
+    readonly reason: string;
+    readonly event: Extract<ConnectorEvent, {
+        readonly connector: 'github';
+    }>;
+}
+/** One payload a webhook could not use, already redacted, for the dead-letter queue of its connector. */
+export type ConnectorDeadLetter = ({
+    readonly connector: 'slack';
+} & SlackDlqInsert) | ({
+    readonly connector: 'github';
+} & GitHubDlqInsert);
+/** What a connector delivery reads and writes beside connectorWrites: the event log,
+ * tenant routing, the dead-letter queue and the archive of a deleted artifact. */
+export interface ConnectorEvents {
+    /** The log row of the event's key, in its connector's own key space. */
+    eventRecord(event: ConnectorEvent): Promise<ConnectorEventRecord>;
+    /** Logs an event that stored no memory, so its redelivery finds it. A key logged before keeps its row, the memory id
+     * it names included. */
+    markEventSeen(event: ConnectorEvent): Promise<void>;
+    /** Both reads on one snapshot: an event logged before answers `seen`, else the raw row the
+     * tenant holds for the artifact. Another tenant's row under the same ref is never returned. */
+    deletionTarget(lookup: DeletionLookup): Promise<DeletionTarget>;
+    /** A logged event answers `duplicate` and changes nothing. Else one transaction archives every raw row of the
+     * artifact (archive_raw row each, under `actor`) and logs the event naming the first, or no memory if none; one
+     * failed archive undoes all and the log row. No reach check. */
+    archiveDeletedArtifact(archive: ArtifactArchive): Promise<{
+        readonly duplicate: boolean;
+        readonly archived: number;
+    }>;
+    /** The tenant a Slack team is registered to, or how many workspaces are registered when it is not. */
+    slackTeamRoute(teamId: string): Promise<SlackTeamRoute>;
+    /** The tenant of the installation, or of the repository when no installation is named, with the size of both routing
+     * tables. */
+    githubRouting(query: {
+        readonly installationId?: string | null;
+        readonly repoFullName?: string | null;
+    }): Promise<GitHubRouting>;
+    /** Appends the row and answers its id. */
+    parkDeadLetter(letter: ConnectorDeadLetter): Promise<number>;
+}
 //# sourceMappingURL=event-log.d.ts.map

package/dist/store/connectors/event-log.js

@@ -9,7 +9,8 @@ export function eventMemoryAt(db, log, key) {
     const row = db.prepare(`SELECT memory_id FROM ${log.table} WHERE ${log.keyColumn} = ?`).get(key);
     return row?.memory_id ?? null;
 }
-/** Records the key unless a row holds it already; false means another writer got there first. `extra` pairs connector-only columns with values. */
+/** Records the key unless a row holds it already; false means another writer got there first. `extra` pairs
+ * connector-only columns with values. */
 export function markEventSeenAt(db, log, key, extra, memoryId) {
     const names = [log.keyColumn, ...extra.map(([name]) => name), 'ingested_at', 'memory_id'];
     const values = [key, ...extra.map(([, value]) => value), new Date().toISOString(), memoryId];

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

@@ -22,7 +22,8 @@ export interface ArtifactDeletion {
     reason: string;
     who: string;
 }
-/** 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 declare function archiveDeletedArtifact(hippoRoot: string, del: ArtifactDeletion): {
     duplicate: boolean;
     archived: number;
@@ -43,7 +44,8 @@ export interface DlqItem {
     retriedAt: string | null;
     bucket: DlqBucket | string;
 }
-/** One github_dlq row to write, already redacted by the caller; the four GitHub-only columns are stored NULL when left out. */
+/** One github_dlq row to write, already redacted by the caller; the four GitHub-only columns are stored NULL when left
+ * out. */
 export interface GitHubDlqInsert {
     tenantId: string;
     rawPayload: string;
@@ -59,7 +61,8 @@ export declare function insertGitHubDlq(hippoRoot: string, row: GitHubDlqInsert)
 export declare function listGitHubDlq(hippoRoot: string, tenantId: string, limit: number): DlqItem[];
 export declare function githubDlqEntry(hippoRoot: string, id: number): DlqItem | null;
 export declare function markGitHubDlqRetried(hippoRoot: string, id: number): void;
-/** What the routing tables say about one webhook; `tenant` is the installation match, or the repo match when no installation was sent. */
+/** What the routing tables say about one webhook; `tenant` is the installation match, or the repo match when no
+ * installation was sent. */
 export interface GitHubRouting {
     installations: number;
     repositories: number;

package/dist/store/connectors/github.js

@@ -3,7 +3,7 @@ import { withWriteScope } from '../../db/index.js';
 import { archiveRawMemory } from '../raw-archive.js';
 import { onHandle } from '../open.js';
 import { eventMemoryAt, eventRecord, eventSeenAt, markEventSeenAt } from './event-log.js';
-import { getDlqRow, insertDlqRow, listDlqRows, markDlqRetried } from './dlq.js';
+import { dlqAccess } from './dlq.js';
 const GITHUB_LOG = { table: 'github_event_log', keyColumn: 'idempotency_key' };
 export function githubEventSeenAt(db, idempotencyKey) {
     return eventSeenAt(db, GITHUB_LOG, idempotencyKey);
@@ -21,7 +21,8 @@ export function githubEventRecord(hippoRoot, 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))
@@ -45,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) => {
@@ -143,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,8 +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 { eventMemoryAt, eventRecord, eventSeenAt, markEventSeenAt } from './event-log.js';
-import { getDlqRow, insertDlqRow, listDlqRows, markDlqRetried } from './dlq.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.
@@ -13,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));
@@ -40,7 +42,8 @@ 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
@@ -48,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,18 +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';
-// 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, ' +
+// 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}`;
@@ -44,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' ` +
@@ -59,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;
@@ -75,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;