@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/memory/provenance-live.js

@@ -0,0 +1,409 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBSERVATION_COLUMNS = void 0;
+exports.parseSourceRef = parseSourceRef;
+exports.isEventVisibleNow = isEventVisibleNow;
+exports.toIndexedEvent = toIndexedEvent;
+exports.isMessageRefVisible = isMessageRefVisible;
+exports.resolveMemoryProvenanceLive = resolveMemoryProvenanceLive;
+const access_js_1 = require("../knowledge/access.js");
+const provenance_query_js_1 = require("./provenance-query.js");
+const provenance_resolver_js_1 = require("./provenance-resolver.js");
+/** The columns the predicate needs. Shared so a test reads exactly what production does. */
+/**
+ * The evidence columns, read from observations under the names the resolver uses.
+ *
+ * This selected them from the connector event index, which is how "what does this
+ * memory rest on" came to require the connector package. An observation is what a
+ * judgment rests on, and it is the core's own table.
+ */
+exports.OBSERVATION_COLUMNS = `observation_id AS event_index_id, source AS source_connector,
+            source_id, channel, body AS content, observed_at, source_at,
+            memory_scope_kind, memory_scope_id, project_id, tenant_id`;
+/**
+ * Statuses every memory read path excludes (source-readers.ts:293, and recall's own
+ * history exclusion). Mirrored so a citation cannot present a retired record as current.
+ */
+const RETIRED_MEMORY_STATUSES = new Set(['superseded', 'quarantined', 'contradicted', 'stale']);
+/**
+ * Parse a stored source ref into what it actually is.
+ *
+ * The shapes here were measured, not guessed. Of the source refs on this machine 13,403
+ * are `memory:`, 1,748 are `envelope:`, 9 are `message:` and none are `raw:`. An earlier
+ * version of this parser understood only `raw:` and reported every real memory as
+ * `unsupported_ref` - a tool that was wired, callable, and answered nothing.
+ */
+function parseSourceRef(ref) {
+    const separator = ref.indexOf(':');
+    if (separator <= 0 || separator === ref.length - 1) {
+        return { kind: 'unsupported' };
+    }
+    const prefix = ref.slice(0, separator);
+    const rest = ref.slice(separator + 1);
+    if (prefix === 'memory' || prefix === 'envelope' || prefix === 'message') {
+        return { kind: prefix, id: rest };
+    }
+    if (prefix !== 'raw') {
+        return { kind: 'unsupported' };
+    }
+    // `raw:<connector>:<event_index_id>`. Split on the FIRST colon of the remainder so a
+    // colon inside the id cannot shift the boundary.
+    const inner = rest.indexOf(':');
+    if (inner <= 0 || inner === rest.length - 1) {
+        return { kind: 'unsupported' };
+    }
+    return { kind: 'raw', connector: rest.slice(0, inner), eventIndexId: rest.slice(inner + 1) };
+}
+/**
+ * The time bound, shared by both branches.
+ *
+ * An event with no timestamp at all cannot satisfy a bound the reader applies to a
+ * COALESCE of two columns, so it is excluded whenever one is set.
+ */
+function isWithinObservedWindow(event, options) {
+    const min = options.minObservedMs ?? null;
+    const max = options.maxObservedMs ?? null;
+    if (min === null && max === null)
+        return true;
+    const observedMs = event.observedAt === null ? null : Date.parse(event.observedAt);
+    if (observedMs === null || Number.isNaN(observedMs))
+        return false;
+    return (min === null || observedMs >= min) && (max === null || observedMs <= max);
+}
+function isWithinSourceWindow(event, maxSourceMs) {
+    if (maxSourceMs === undefined || maxSourceMs === null)
+        return true;
+    if (!Number.isSafeInteger(maxSourceMs) || maxSourceMs < 0) {
+        throw new Error('Provenance source ceiling must be a nonnegative epoch-millisecond integer');
+    }
+    if (event.sourceAt === null || event.sourceAt === undefined)
+        return false;
+    const sourceMs = Date.parse(event.sourceAt);
+    return Number.isFinite(sourceMs) && sourceMs <= maxSourceMs;
+}
+/**
+ * Whether an event may be shown under the authority active now.
+ *
+ * When a channel grant is supplied this DELEGATES to the shared rule rather than copying
+ * it. The previous version copied the reader clause for clause and said so in a comment,
+ * which held until the reader changed - then the copy silently became a different rule
+ * that refused excerpts for the very events the reader was citing. The differential test
+ * meant to catch that kept passing, because its fixtures never set a grant.
+ *
+ * "A shared predicate would be better than a faithful copy" is what the old comment here
+ * said. It was right.
+ *
+ * Without a grant the pre-grant rule still applies, so callers that have not been given
+ * one behave exactly as before.
+ */
+function isEventVisibleNow(event, options) {
+    const { scopes, connectors } = options;
+    if (options.wideConnectors?.includes(event.connector) && connectors.includes(event.connector)) {
+        return (isWithinSourceWindow(event, options.maxSourceMs) && isWithinObservedWindow(event, options));
+    }
+    if (options.channels) {
+        return ((0, access_js_1.isChannelGranted)(event.connector, event.channel, options.channels) &&
+            isWithinSourceWindow(event, options.maxSourceMs) &&
+            isWithinObservedWindow(event, options));
+    }
+    const projectIds = options.projectIds ?? [];
+    const tenantId = options.tenantId ?? null;
+    // The reader's own guard: no connectors or no scopes means no raw events at all.
+    if (connectors.length === 0 || scopes.length === 0) {
+        return false;
+    }
+    if (!connectors.includes(event.connector)) {
+        return false;
+    }
+    const hasGlobalSystemScope = scopes.some((scope) => scope.kind === 'global' && scope.id === 'system');
+    const hasScopedVisibility = scopes.some((scope) => !(scope.kind === 'global' && scope.id === 'system')) ||
+        projectIds.length > 0 ||
+        Boolean(tenantId);
+    const includesLegacyGlobalSystem = hasGlobalSystemScope && !hasScopedVisibility;
+    if (projectIds.length > 0) {
+        const projectMatches = (event.projectId !== null &&
+            event.projectId !== undefined &&
+            projectIds.includes(event.projectId)) ||
+            (includesLegacyGlobalSystem && (event.projectId ?? null) === null);
+        if (!projectMatches) {
+            return false;
+        }
+    }
+    if (tenantId) {
+        const tenantMatches = event.tenantId === tenantId ||
+            (includesLegacyGlobalSystem && (event.tenantId ?? null) === null);
+        if (!tenantMatches) {
+            return false;
+        }
+    }
+    if (!isWithinSourceWindow(event, options.maxSourceMs) ||
+        !isWithinObservedWindow(event, options)) {
+        return false;
+    }
+    const scope = event.memoryScope ?? null;
+    if (!scope) {
+        return includesLegacyGlobalSystem;
+    }
+    return scopes.some((active) => active.kind === scope.kind &&
+        (active.id === scope.id ||
+            // Rows written before the global/system alignment carry id 'global'.
+            (active.kind === 'global' && active.id === 'system' && scope.id === 'global')));
+}
+/**
+ * One column to epoch ms, with SQL's notion of "absent" and no other.
+ *
+ * `COALESCE` falls through on NULL and nothing else, so 0 and negative values are
+ * PRESENT to the reader. Treating them as missing - which this did, by requiring
+ * `value > 0` - made the mapper judge a different instant than the query: a row with
+ * `event_datetime = 0` compared as 0 in SQL and as its source timestamp here. The
+ * differential caught it the moment it was routed through the production mapper.
+ *
+ * The non-numeric string branch is DEFENSIVE, not faithful: SQLite orders a TEXT value
+ * above every INTEGER regardless of what it spells, so SQL would exclude such a row from
+ * any upper bound while `Date.parse` gives it a real instant. Unreachable - both columns
+ * are INTEGER-affinity, the write path passes a number, and all 30,671 live rows store
+ * integers - but it is a divergence if it ever runs, and better named than implied.
+ */
+function toEpochMs(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    // better-sqlite3 returns bigint when safeIntegers is on. Nothing enables it today, but
+    // without this arm flipping that flag would null every timestamp and silently disable
+    // the time clamp entirely.
+    if (typeof value === 'bigint') {
+        return Number(value);
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) {
+            return numeric;
+        }
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? null : parsed;
+    }
+    return null;
+}
+function coalesceObservedAt(eventDatetime, sourceTimestampMs) {
+    const ms = toEpochMs(eventDatetime) ?? toEpochMs(sourceTimestampMs);
+    return ms === null ? null : new Date(ms).toISOString();
+}
+/**
+ * Row to the struct the predicate judges.
+ *
+ * Exported because it is the layer BELOW the predicate, and a differential that
+ * hand-builds its own struct proves the predicate mirrors the reader while leaving this
+ * mapping unjudged - which is where a scope-column coercion bug already lived once.
+ */
+function toIndexedEvent(row) {
+    const scopeKind = typeof row.memory_scope_kind === 'string' ? row.memory_scope_kind : null;
+    const scopeId = typeof row.memory_scope_id === 'string' ? row.memory_scope_id : null;
+    // Only a row with BOTH columns null is unscoped, because that is the only row the
+    // reader's `IS NULL AND IS NULL` clause matches. Collapsing a half-populated or
+    // empty-string row to "unscoped" would hand it the legacy allowance the reader denies.
+    const unscoped = scopeKind === null && scopeId === null;
+    return {
+        connector: String(row.source_connector ?? ''),
+        eventIndexId: String(row.event_index_id ?? ''),
+        sourceId: String(row.source_id ?? ''),
+        channel: typeof row.channel === 'string' ? row.channel : null,
+        // The capture instant first, the event's own time second -- the same order the
+        // raw reader's COALESCE uses, and pinned against it by a differential test.
+        observedAt: coalesceObservedAt(row.observed_at, row.source_at),
+        sourceAt: (() => {
+            const sourceMs = toEpochMs(row.source_at);
+            return sourceMs === null ? null : new Date(sourceMs).toISOString();
+        })(),
+        content: typeof row.content === 'string' ? row.content : '',
+        memoryScope: unscoped ? null : { kind: scopeKind ?? '', id: scopeId ?? '' },
+        projectId: typeof row.project_id === 'string' ? row.project_id : null,
+        tenantId: typeof row.tenant_id === 'string' ? row.tenant_id : null,
+    };
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : null;
+}
+/**
+ * Fetch a memory's provenance under the scopes active now.
+ *
+ * Two lookups on purpose. The first is scope-strict. Only if that finds nothing do we ask
+ * again admitting records with no scope bindings, and a record that appears only on the
+ * second pass is reported as legacy rather than as support. A memory that appears on
+ * neither is reported as unknown - never as "exists but withheld", which would confirm
+ * the existence of something outside the caller's scope.
+ */
+async function lookupWithLegacyFallback(adapter, memoryId, scopes) {
+    const scoped = await (0, provenance_query_js_1.getMemoryProvenance)(adapter, memoryId, { scopes });
+    if (scoped) {
+        return { record: scoped, legacy: false };
+    }
+    const unbound = await (0, provenance_query_js_1.getMemoryProvenance)(adapter, memoryId, {
+        scopes,
+        includeLegacyUnscoped: true,
+    });
+    return unbound ? { record: unbound, legacy: true } : null;
+}
+/**
+ * The stored record's status. `getMemoryProvenance` selects it nowhere, so this is a
+ * separate read rather than a field that was there all along - which is precisely why the
+ * status filter had no counterpart on this path for four review rounds.
+ */
+async function loadRetirement(adapter, memoryId) {
+    const row = adapter
+        .prepare(`SELECT status, superseded_by FROM decisions WHERE id = ? LIMIT 1`)
+        .get(memoryId);
+    const status = typeof row?.status === 'string' ? row.status : null;
+    const supersededBy = typeof row?.superseded_by === 'string' ? row.superseded_by : null;
+    return {
+        status,
+        // Either signal retires it: the reader filters on status, and recall additionally
+        // requires `superseded_by IS NULL`.
+        retired: (status !== null && RETIRED_MEMORY_STATUSES.has(status)) || supersededBy !== null,
+    };
+}
+async function loadRecord(adapter, memoryId, scopes) {
+    const found = await lookupWithLegacyFallback(adapter, memoryId, scopes);
+    if (!found) {
+        return null;
+    }
+    const record = found.record;
+    const retirement = await loadRetirement(adapter, record.memory_id);
+    const provenance = record.provenance;
+    const sourceRefs = record.source_refs.map(parseSourceRef);
+    // The judgment writer stores agent-chosen derived_from evidence in the
+    // canonical graph. Compact run provenance alone may name only the input that
+    // woke the agent; it must not hide those exact observed supports.
+    const seenObservations = new Set(sourceRefs.flatMap((ref) => (ref.kind === 'raw' ? [ref.eventIndexId] : [])));
+    const links = adapter
+        .prepare(`SELECT object_id FROM twin_edges
+       WHERE subject_kind='memory' AND subject_id=?
+         AND edge_type='derived_from' AND object_kind='observation'
+       ORDER BY created_at, edge_id`)
+        .all(memoryId);
+    for (const link of links) {
+        if (seenObservations.has(link.object_id))
+            continue;
+        seenObservations.add(link.object_id);
+        sourceRefs.push({ kind: 'observation', observationId: link.object_id });
+    }
+    return {
+        status: retirement.status,
+        retired: retirement.retired,
+        modelRunId: record.model_run_id,
+        contextPacketId: stringOrNull(provenance?.context_packet_id),
+        sourceRefs,
+        legacyUnscoped: found.legacy,
+    };
+}
+/**
+ * Which supporting memories the caller may see, resolved up front.
+ *
+ * The pure resolver checks visibility synchronously, so this pre-answers it for the
+ * memory refs a record carries - typically a handful, up to fifty in the live corpus,
+ * and up to two lookups each, so ~100 serial round trips at the tail. Bounded and off
+ * the hot path (agent-invoked, not per-turn); the second lookup fires only for an
+ * ancestor with no scope bindings, of which the live corpus has two. Worth replacing
+ * with one bindings query if a memory ever carries hundreds of ancestors.
+ * Uses the SAME two-pass gate as the record itself, legacy pass included: an ancestor
+ * with no scope bindings is admitted exactly where an unbound record is, rather than
+ * reported out of scope because the second pass was skipped. An earlier docstring
+ * claimed that parity without the code doing it.
+ */
+async function resolveVisibleMemoryRefs(adapter, record, scopes) {
+    const visible = new Set();
+    if (!record) {
+        return visible;
+    }
+    const ids = new Set(record.sourceRefs.flatMap((ref) => (ref.kind === 'memory' ? [ref.id] : [])));
+    for (const id of ids) {
+        if (await lookupWithLegacyFallback(adapter, id, scopes)) {
+            visible.add(id);
+        }
+    }
+    return visible;
+}
+/**
+ * Whether a message ref may be named.
+ *
+ * `sourceMessageRef` is built as `source:channelId:turnId` (message-router.ts), and a
+ * channel scope id as `source:channelId` (scope-context.ts) - so a ref belongs to a
+ * caller's channel exactly when an active channel scope is its prefix. Compared as a
+ * prefix rather than parsed, because a turn id can itself contain a colon
+ * (`generated:<uuid>`) and splitting on the last one would silently mis-attribute it.
+ *
+ * This matters beyond tidiness: every memory carrying such a ref is also bound to
+ * global:system, which every caller holds, so an unchecked ref handed a private channel
+ * identifier to any agent that could read the memory at all.
+ */
+function isMessageRefVisible(ref, scopes) {
+    return scopes.some((scope) => scope.kind === 'channel' && ref.startsWith(`${scope.id}:`));
+}
+// Known limit, stated rather than discovered: the channel id space is not prefix-free.
+// Real channel ids already contain colons, so a channel `S:X` produces refs that a caller
+// scoped to `S` matches. Nothing in the ref format distinguishes "channel S, turn X:99"
+// from "channel S:X, turn 99", so this cannot be resolved by parsing harder - it would
+// take a delimiter the writer does not use. There are no such colliding pairs in the live
+// scope table, so the guarantee holds on today's data rather than structurally.
+/** Resolve one memory's support against the live index and the scopes active now. */
+async function resolveMemoryProvenanceLive(adapter, memoryId, options) {
+    const record = await loadRecord(adapter, memoryId, options.scopes);
+    const visibleMemoryRefs = await resolveVisibleMemoryRefs(adapter, record, options.scopes);
+    const statement = adapter.prepare(`SELECT ${exports.OBSERVATION_COLUMNS}
+       FROM observation_versions
+      WHERE observation_id = ?
+      LIMIT 1`);
+    const ownInput = options.principalId
+        ? adapter.prepare(`SELECT 1 FROM mailbox_inputs
+         WHERE stimulus_id=? AND principal_id=? AND kind IN ('scheduled','source_delta','native_event')
+         LIMIT 1`)
+        : null;
+    return (0, provenance_resolver_js_1.resolveMemoryProvenance)(memoryId, {
+        lookupMemoryProvenance: () => record,
+        lookupEvent: (connector, eventIndexId) => {
+            const row = statement.get(eventIndexId);
+            if (!row) {
+                return null;
+            }
+            const event = toIndexedEvent(row);
+            // The id is a hash of connector plus source id, so a connector mismatch means the
+            // ref was rewritten rather than that the event moved. Treat it as gone, not as data.
+            return event.connector === connector ? event : null;
+        },
+        lookupObservation: (observationId) => {
+            const row = statement.get(observationId);
+            return row ? toIndexedEvent(row) : null;
+        },
+        ...(options.redact === undefined ? {} : { redact: options.redact }),
+        isSupportVisible: (support) => {
+            if (support.kind === 'memory') {
+                return visibleMemoryRefs.has(support.id);
+            }
+            if (support.kind === 'message') {
+                return (isMessageRefVisible(support.id, options.scopes) ||
+                    Boolean(ownInput?.get(support.id, options.principalId)));
+            }
+            // Envelope hashes are emitted. The reason is NOT that the hash is inert - it is a
+            // lookup key into GET /api/memory/provenance, which serves unscoped results by
+            // hash and explicitly refuses scope filters (memory-provenance-handler.ts:26-33).
+            // What makes it safe is that the route sits behind requireAdminAuth
+            // (api/index.ts:215) and no role holding mama_provenance has an admin token or a
+            // shell. That is an access control in another file, so if this tool is ever
+            // granted to a role with either, revisit this line - the hash stops being safe
+            // before anything here changes.
+            return true;
+        },
+        isVisible: (event) => isEventVisibleNow(event, {
+            scopes: options.scopes,
+            connectors: options.connectors,
+            ...(options.wideConnectors ? { wideConnectors: options.wideConnectors } : {}),
+            ...(options.channels ? { channels: options.channels } : {}),
+            ...(options.projectIds === undefined ? {} : { projectIds: options.projectIds }),
+            tenantId: options.tenantId ?? null,
+            minObservedMs: options.minObservedMs ?? null,
+            maxObservedMs: options.maxObservedMs ?? null,
+            maxSourceMs: options.maxSourceMs ?? null,
+        }),
+        ...(options.excerptChars === undefined ? {} : { excerptChars: options.excerptChars }),
+    });
+}
+//# sourceMappingURL=provenance-live.js.map

package/dist/memory/provenance-query.d.ts

@@ -1,11 +1,12 @@
+import type { DatabaseAdapter } from '../db-manager.js';
 import type { MemoryProvenanceRecord, MemoryScopeRef } from './types.js';
 export interface MemoryProvenanceQueryOptions {
     scopes?: MemoryScopeRef[];
     includeLegacyUnscoped?: boolean;
     limit?: number;
 }
-export declare function getMemoryProvenance(memoryId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord | null>;
-export declare function listMemoriesByEnvelopeHash(envelopeHash: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
-export declare function listMemoriesByGatewayCallId(gatewayCallId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
-export declare function listMemoriesByModelRunId(modelRunId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
+export declare function getMemoryProvenance(adapter: DatabaseAdapter, memoryId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord | null>;
+export declare function listMemoriesByEnvelopeHash(adapter: DatabaseAdapter, envelopeHash: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
+export declare function listMemoriesByGatewayCallId(adapter: DatabaseAdapter, gatewayCallId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
+export declare function listMemoriesByModelRunId(adapter: DatabaseAdapter, modelRunId: string, options?: MemoryProvenanceQueryOptions): Promise<MemoryProvenanceRecord[]>;
 //# sourceMappingURL=provenance-query.d.ts.map

package/dist/memory/provenance-query.js

@@ -4,11 +4,8 @@ exports.getMemoryProvenance = getMemoryProvenance;
 exports.listMemoriesByEnvelopeHash = listMemoriesByEnvelopeHash;
 exports.listMemoriesByGatewayCallId = listMemoriesByGatewayCallId;
 exports.listMemoriesByModelRunId = listMemoriesByModelRunId;
-const db_manager_js_1 = require("../db-manager.js");
 const event_store_js_1 = require("./event-store.js");
-async function getMemoryProvenance(memoryId, options = {}) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
+async function getMemoryProvenance(adapter, memoryId, options = {}) {
     const row = adapter
         .prepare(`
         SELECT id, agent_id, model_run_id, envelope_hash, gateway_call_id,
@@ -17,25 +14,23 @@ async function getMemoryProvenance(memoryId, options = {}) {
         WHERE id = ?
       `)
         .get(memoryId);
-    if (!row || !(await isVisibleMemory(row.id, options))) {
+    if (!row || !(await isVisibleMemory(adapter, row.id, options))) {
         return null;
     }
-    return toProvenanceRecord(row);
+    return toProvenanceRecord(adapter, row);
 }
-async function listMemoriesByEnvelopeHash(envelopeHash, options = {}) {
-    return listMemoriesByColumn('envelope_hash', envelopeHash, options);
+async function listMemoriesByEnvelopeHash(adapter, envelopeHash, options = {}) {
+    return listMemoriesByColumn(adapter, 'envelope_hash', envelopeHash, options);
 }
-async function listMemoriesByGatewayCallId(gatewayCallId, options = {}) {
-    return listMemoriesByColumn('gateway_call_id', gatewayCallId, options);
+async function listMemoriesByGatewayCallId(adapter, gatewayCallId, options = {}) {
+    return listMemoriesByColumn(adapter, 'gateway_call_id', gatewayCallId, options);
 }
-async function listMemoriesByModelRunId(modelRunId, options = {}) {
-    return listMemoriesByColumn('model_run_id', modelRunId, options);
+async function listMemoriesByModelRunId(adapter, modelRunId, options = {}) {
+    return listMemoriesByColumn(adapter, 'model_run_id', modelRunId, options);
 }
-async function listMemoriesByColumn(column, value, options) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
+async function listMemoriesByColumn(adapter, column, value, options) {
     const limit = normalizeLimit(options.limit);
-    const visibility = buildVisibilityPredicate(options);
+    const visibility = buildVisibilityPredicate(adapter, options);
     const rows = adapter
         .prepare(`
         SELECT d.id, d.agent_id, d.model_run_id, d.envelope_hash, d.gateway_call_id,
@@ -48,15 +43,15 @@ async function listMemoriesByColumn(column, value, options) {
         .all(value, ...visibility.params, limit);
     const records = [];
     for (const row of rows) {
-        records.push(await toProvenanceRecord(row));
+        records.push(await toProvenanceRecord(adapter, row));
     }
     return records;
 }
-function buildVisibilityPredicate(options) {
+function buildVisibilityPredicate(adapter, options) {
     if (!hasScopeFilter(options)) {
         return { sql: '', params: [] };
     }
-    const scopeIds = resolveMemoryScopeIds(options.scopes);
+    const scopeIds = resolveMemoryScopeIds(adapter, options.scopes);
     const legacyUnscopedPredicate = `
           NOT EXISTS (
             SELECT 1
@@ -89,18 +84,18 @@ function buildVisibilityPredicate(options) {
 function hasScopeFilter(options) {
     return Array.isArray(options.scopes) && options.scopes.length > 0;
 }
-function resolveMemoryScopeIds(scopes) {
+function resolveMemoryScopeIds(adapter, scopes) {
     const scopeIds = [];
     for (const scope of scopes) {
-        const scopeId = resolveMemoryScopeId(scope.kind, scope.id);
+        const scopeId = resolveMemoryScopeId(adapter, scope.kind, scope.id);
         if (scopeId) {
             scopeIds.push(scopeId);
         }
     }
     return scopeIds;
 }
-async function toProvenanceRecord(row) {
-    const events = await (0, event_store_js_1.listMemoryEventsForMemory)(row.id);
+async function toProvenanceRecord(adapter, row) {
+    const events = await (0, event_store_js_1.listMemoryEventsForMemory)(adapter, row.id);
     return {
         memory_id: row.id,
         agent_id: row.agent_id,
@@ -112,13 +107,11 @@ async function toProvenanceRecord(row) {
         latest_event: events[0],
     };
 }
-async function isVisibleMemory(memoryId, options) {
+async function isVisibleMemory(adapter, memoryId, options) {
     if (!hasScopeFilter(options)) {
         return true;
     }
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
-    const scopeIds = resolveMemoryScopeIds(options.scopes);
+    const scopeIds = resolveMemoryScopeIds(adapter, options.scopes);
     const bindingCount = adapter
         .prepare(`
           SELECT COUNT(*) as count
@@ -144,8 +137,7 @@ async function isVisibleMemory(memoryId, options) {
         .get(memoryId, ...scopeIds);
     return row?.visible === 1;
 }
-function resolveMemoryScopeId(kind, externalId) {
-    const adapter = (0, db_manager_js_1.getAdapter)();
+function resolveMemoryScopeId(adapter, kind, externalId) {
     const row = adapter
         .prepare(`
         SELECT id