@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/memory/event-store.d.ts

@@ -1,5 +1,8 @@
+import type { DatabaseAdapter } from '../db-manager.js';
 import type { MemoryEventRecord } from './types.js';
 export declare function appendMemoryEvent(input: Omit<MemoryEventRecord, 'event_id'>): Promise<string>;
+export declare function insertMemoryEventInTransaction(adapter: Pick<DatabaseAdapter, 'prepare'>, input: Omit<MemoryEventRecord, 'event_id'>): string;
 export declare function listMemoryEventsForTopic(topic: string): Promise<MemoryEventRecord[]>;
+export declare function listMemoryEventsForMemory(memoryId: string): Promise<MemoryEventRecord[]>;
 export declare function listRecentMemoryEvents(limit?: number): Promise<MemoryEventRecord[]>;
 //# sourceMappingURL=event-store.d.ts.map

package/dist/memory/event-store.js

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.appendMemoryEvent = appendMemoryEvent;
+exports.insertMemoryEventInTransaction = insertMemoryEventInTransaction;
 exports.listMemoryEventsForTopic = listMemoryEventsForTopic;
+exports.listMemoryEventsForMemory = listMemoryEventsForMemory;
 exports.listRecentMemoryEvents = listRecentMemoryEvents;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const db_manager_js_1 = require("../db-manager.js");
@@ -29,6 +31,9 @@ function deserializeEvent(row) {
 async function appendMemoryEvent(input) {
     await (0, db_manager_js_1.initDB)();
     const adapter = (0, db_manager_js_1.getAdapter)();
+    return insertMemoryEventInTransaction(adapter, input);
+}
+function insertMemoryEventInTransaction(adapter, input) {
     const eventId = `evt_${node_crypto_1.default.randomUUID().replace(/-/g, '')}`;
     adapter
         .prepare(`
@@ -50,11 +55,25 @@ async function listMemoryEventsForTopic(topic) {
                scope_refs, evidence_refs, reason, created_at
         FROM memory_events
         WHERE topic = ?
-        ORDER BY created_at DESC
+        ORDER BY created_at DESC, rowid DESC
       `)
         .all(topic);
     return rows.map(deserializeEvent);
 }
+async function listMemoryEventsForMemory(memoryId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT event_id, event_type, actor, source_turn_id, memory_id, topic,
+               scope_refs, evidence_refs, reason, created_at
+        FROM memory_events
+        WHERE memory_id = ?
+        ORDER BY created_at DESC, rowid DESC
+      `)
+        .all(memoryId);
+    return rows.map(deserializeEvent);
+}
 async function listRecentMemoryEvents(limit = 10) {
     await (0, db_manager_js_1.initDB)();
     const adapter = (0, db_manager_js_1.getAdapter)();
@@ -63,7 +82,7 @@ async function listRecentMemoryEvents(limit = 10) {
         SELECT event_id, event_type, actor, source_turn_id, memory_id, topic,
                scope_refs, evidence_refs, reason, created_at
         FROM memory_events
-        ORDER BY created_at DESC
+        ORDER BY created_at DESC, rowid DESC
         LIMIT ?
       `)
         .all(limit);

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

@@ -0,0 +1,22 @@
+import type { MemoryEventRecord, MemoryScopeRef } from './types.js';
+export interface MemoryProvenanceAuditRecord {
+    memory_id: string;
+    topic: string;
+    summary: string;
+    envelope_hash: string | null;
+    model_run_id: string | null;
+    gateway_call_id: string | null;
+    tool_name: string | null;
+    latest_event?: MemoryEventRecord;
+    scope_refs: MemoryScopeRef[];
+    legacy_caveats: string[];
+}
+export interface MemoryProvenanceAuditListOptions {
+    envelope_hash?: string;
+    model_run_id?: string;
+    gateway_call_id?: string;
+    limit?: number;
+}
+export declare function getMemoryProvenanceAudit(memoryId: string): Promise<MemoryProvenanceAuditRecord | null>;
+export declare function listMemoryProvenanceAudit(options: MemoryProvenanceAuditListOptions): Promise<MemoryProvenanceAuditRecord[]>;
+//# sourceMappingURL=provenance-audit.d.ts.map

package/dist/memory/provenance-audit.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemoryProvenanceAudit = getMemoryProvenanceAudit;
+exports.listMemoryProvenanceAudit = listMemoryProvenanceAudit;
+const db_manager_js_1 = require("../db-manager.js");
+const event_store_js_1 = require("./event-store.js");
+async function getMemoryProvenanceAudit(memoryId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter
+        .prepare(`
+        SELECT id, topic, decision, summary, envelope_hash, model_run_id, gateway_call_id,
+               provenance_json
+        FROM decisions
+        WHERE id = ?
+      `)
+        .get(memoryId);
+    return row ? toAuditRecord(row) : null;
+}
+async function listMemoryProvenanceAudit(options) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const filter = buildAuditFilter(options);
+    const rows = adapter
+        .prepare(`
+        SELECT id, topic, decision, summary, envelope_hash, model_run_id, gateway_call_id,
+               provenance_json
+        FROM decisions
+        WHERE ${filter.sql}
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
+      `)
+        .all(...filter.params, normalizeLimit(options.limit));
+    const records = [];
+    for (const row of rows) {
+        records.push(await toAuditRecord(row));
+    }
+    return records;
+}
+function buildAuditFilter(options) {
+    const filters = [];
+    const params = [];
+    for (const column of ['envelope_hash', 'model_run_id', 'gateway_call_id']) {
+        const value = options[column];
+        if (value !== undefined) {
+            filters.push(`${column} = ?`);
+            params.push(value);
+        }
+    }
+    if (filters.length !== 1) {
+        throw new Error('Exactly one provenance audit filter is required.');
+    }
+    return { sql: filters[0], params };
+}
+async function toAuditRecord(row) {
+    const events = await (0, event_store_js_1.listMemoryEventsForMemory)(row.id);
+    const scopeRefs = listScopeRefs(row.id);
+    const provenance = parseObject(row.provenance_json);
+    const legacyCaveats = [];
+    if (provenance.source_type === 'legacy') {
+        legacyCaveats.push('legacy_provenance_backfill');
+    }
+    if (scopeRefs.length === 0) {
+        legacyCaveats.push('unscoped_memory');
+    }
+    return {
+        memory_id: row.id,
+        topic: row.topic,
+        summary: row.summary ?? row.decision ?? '',
+        envelope_hash: row.envelope_hash,
+        model_run_id: row.model_run_id,
+        gateway_call_id: row.gateway_call_id,
+        tool_name: typeof provenance.tool_name === 'string' ? provenance.tool_name : null,
+        latest_event: events[0],
+        scope_refs: scopeRefs,
+        legacy_caveats: legacyCaveats,
+    };
+}
+function listScopeRefs(memoryId) {
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const rows = adapter
+        .prepare(`
+        SELECT ms.kind, ms.external_id
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id = ?
+        ORDER BY msb.is_primary DESC, ms.kind ASC, ms.external_id ASC
+      `)
+        .all(memoryId);
+    return rows.map((row) => ({ kind: row.kind, id: row.external_id }));
+}
+function normalizeLimit(limit) {
+    if (!Number.isFinite(limit)) {
+        return 50;
+    }
+    return Math.max(1, Math.min(200, Math.floor(limit)));
+}
+function parseObject(value) {
+    if (!value) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=provenance-audit.js.map

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

@@ -0,0 +1,11 @@
+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[]>;
+//# sourceMappingURL=provenance-query.d.ts.map

package/dist/memory/provenance-query.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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)();
+    const row = adapter
+        .prepare(`
+        SELECT id, agent_id, model_run_id, envelope_hash, gateway_call_id,
+               source_refs_json, provenance_json, created_at
+        FROM decisions
+        WHERE id = ?
+      `)
+        .get(memoryId);
+    if (!row || !(await isVisibleMemory(row.id, options))) {
+        return null;
+    }
+    return toProvenanceRecord(row);
+}
+async function listMemoriesByEnvelopeHash(envelopeHash, options = {}) {
+    return listMemoriesByColumn('envelope_hash', envelopeHash, options);
+}
+async function listMemoriesByGatewayCallId(gatewayCallId, options = {}) {
+    return listMemoriesByColumn('gateway_call_id', gatewayCallId, options);
+}
+async function listMemoriesByModelRunId(modelRunId, options = {}) {
+    return listMemoriesByColumn('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)();
+    const limit = normalizeLimit(options.limit);
+    const visibility = buildVisibilityPredicate(options);
+    const rows = adapter
+        .prepare(`
+        SELECT d.id, d.agent_id, d.model_run_id, d.envelope_hash, d.gateway_call_id,
+               d.source_refs_json, d.provenance_json, d.created_at
+        FROM decisions d
+        WHERE d.${column} = ?${visibility.sql}
+        ORDER BY d.created_at DESC, d.id DESC
+        LIMIT ?
+      `)
+        .all(value, ...visibility.params, limit);
+    const records = [];
+    for (const row of rows) {
+        records.push(await toProvenanceRecord(row));
+    }
+    return records;
+}
+function buildVisibilityPredicate(options) {
+    if (!hasScopeFilter(options)) {
+        return { sql: '', params: [] };
+    }
+    const scopeIds = resolveMemoryScopeIds(options.scopes);
+    const legacyUnscopedPredicate = `
+          NOT EXISTS (
+            SELECT 1
+            FROM memory_scope_bindings msb_legacy
+            WHERE msb_legacy.memory_id = d.id
+          )
+        `;
+    if (scopeIds.length === 0) {
+        return options.includeLegacyUnscoped === true
+            ? { sql: ` AND ${legacyUnscopedPredicate}`, params: [] }
+            : { sql: ' AND 0 = 1', params: [] };
+    }
+    const placeholders = scopeIds.map(() => '?').join(', ');
+    const scopedPredicate = `
+        EXISTS (
+          SELECT 1
+          FROM memory_scope_bindings msb_scope
+          WHERE msb_scope.memory_id = d.id
+            AND msb_scope.scope_id IN (${placeholders})
+        )
+      `;
+    if (options.includeLegacyUnscoped === true) {
+        return {
+            sql: ` AND (${scopedPredicate} OR ${legacyUnscopedPredicate})`,
+            params: scopeIds,
+        };
+    }
+    return { sql: ` AND ${scopedPredicate}`, params: scopeIds };
+}
+function hasScopeFilter(options) {
+    return Array.isArray(options.scopes) && options.scopes.length > 0;
+}
+function resolveMemoryScopeIds(scopes) {
+    const scopeIds = [];
+    for (const scope of scopes) {
+        const scopeId = resolveMemoryScopeId(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);
+    return {
+        memory_id: row.id,
+        agent_id: row.agent_id,
+        model_run_id: row.model_run_id,
+        envelope_hash: row.envelope_hash,
+        gateway_call_id: row.gateway_call_id,
+        source_refs: parseStringArray(row.source_refs_json),
+        provenance: parseObject(row.provenance_json),
+        latest_event: events[0],
+    };
+}
+async function isVisibleMemory(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 bindingCount = adapter
+        .prepare(`
+          SELECT COUNT(*) as count
+          FROM memory_scope_bindings
+          WHERE memory_id = ?
+        `)
+        .get(memoryId);
+    const count = bindingCount.count;
+    if (count === 0) {
+        return options.includeLegacyUnscoped === true;
+    }
+    if (scopeIds.length === 0) {
+        return false;
+    }
+    const placeholders = scopeIds.map(() => '?').join(', ');
+    const row = adapter
+        .prepare(`
+        SELECT 1 as visible
+        FROM memory_scope_bindings
+        WHERE memory_id = ? AND scope_id IN (${placeholders})
+        LIMIT 1
+      `)
+        .get(memoryId, ...scopeIds);
+    return row?.visible === 1;
+}
+function resolveMemoryScopeId(kind, externalId) {
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter
+        .prepare(`
+        SELECT id
+        FROM memory_scopes
+        WHERE kind = ? AND external_id = ?
+        LIMIT 1
+      `)
+        .get(kind, externalId);
+    return row?.id ?? null;
+}
+function normalizeLimit(limit) {
+    if (!Number.isFinite(limit)) {
+        return 50;
+    }
+    return Math.max(1, Math.min(200, Math.floor(limit)));
+}
+function parseStringArray(value) {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((item) => typeof item === 'string')
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseObject(value) {
+    if (!value) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=provenance-query.js.map

package/dist/memory/provenance.d.ts

@@ -0,0 +1,29 @@
+import type { MemoryEventRecord, MemoryWriteProvenance, PublicIngestConversationInput, PublicIngestMemoryInput, PublicSaveMemoryInput } from './types.js';
+export interface TrustedProvenanceCapability {
+    readonly __trustedProvenanceCapability: 'mama-core';
+}
+export interface TrustedMemoryWriteOptions {
+    provenance: MemoryWriteProvenance;
+    capability: TrustedProvenanceCapability;
+}
+export interface NormalizedMemoryProvenance {
+    actor: MemoryEventRecord['actor'];
+    agent_id: string | null;
+    model_run_id: string | null;
+    envelope_hash: string | null;
+    tool_name: string | null;
+    gateway_call_id: string | null;
+    source_turn_id: string | null;
+    source_message_ref: string | null;
+    source_refs: string[];
+    provenance: Record<string, unknown>;
+}
+export declare function createTrustedProvenanceCapability(): TrustedProvenanceCapability;
+export declare function assertTrustedProvenanceCapability(capability: TrustedProvenanceCapability | undefined): asserts capability is TrustedProvenanceCapability;
+export declare function stripCallerProvenance<T extends Record<string, unknown>>(input: T): T;
+export declare function sanitizePublicSaveMemoryInput(input: PublicSaveMemoryInput): PublicSaveMemoryInput;
+export declare function sanitizePublicIngestMemoryInput(input: PublicIngestMemoryInput): PublicIngestMemoryInput;
+export declare function sanitizePublicIngestConversationInput(input: PublicIngestConversationInput): PublicIngestConversationInput;
+export declare function normalizeMemoryWriteProvenance(options?: TrustedMemoryWriteOptions): NormalizedMemoryProvenance;
+export declare function appendProvenanceSourceRefs(options: TrustedMemoryWriteOptions | undefined, refs: string[]): TrustedMemoryWriteOptions | undefined;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/memory/provenance.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrustedProvenanceCapability = createTrustedProvenanceCapability;
+exports.assertTrustedProvenanceCapability = assertTrustedProvenanceCapability;
+exports.stripCallerProvenance = stripCallerProvenance;
+exports.sanitizePublicSaveMemoryInput = sanitizePublicSaveMemoryInput;
+exports.sanitizePublicIngestMemoryInput = sanitizePublicIngestMemoryInput;
+exports.sanitizePublicIngestConversationInput = sanitizePublicIngestConversationInput;
+exports.normalizeMemoryWriteProvenance = normalizeMemoryWriteProvenance;
+exports.appendProvenanceSourceRefs = appendProvenanceSourceRefs;
+const issuedCapabilities = new WeakSet();
+const ALLOWED_PROVENANCE_FIELDS = new Set([
+    'actor',
+    'agent_id',
+    'model_run_id',
+    'envelope_hash',
+    'tool_name',
+    'gateway_call_id',
+    'source_turn_id',
+    'source_message_ref',
+    'source_refs',
+]);
+function createTrustedProvenanceCapability() {
+    const capability = Object.freeze({
+        __trustedProvenanceCapability: 'mama-core',
+    });
+    issuedCapabilities.add(capability);
+    return capability;
+}
+function assertTrustedProvenanceCapability(capability) {
+    if (!capability || typeof capability !== 'object' || !issuedCapabilities.has(capability)) {
+        throw new Error('Invalid trusted provenance capability');
+    }
+}
+function stripCallerProvenance(input) {
+    if (!Object.prototype.hasOwnProperty.call(input, 'provenance')) {
+        return input;
+    }
+    const { provenance: _provenance, ...rest } = input;
+    return rest;
+}
+function sanitizePublicSaveMemoryInput(input) {
+    return stripCallerProvenance(input);
+}
+function sanitizePublicIngestMemoryInput(input) {
+    return stripCallerProvenance(input);
+}
+function sanitizePublicIngestConversationInput(input) {
+    return stripCallerProvenance(input);
+}
+function normalizeMemoryWriteProvenance(options) {
+    if (!options) {
+        return buildFallbackProvenance();
+    }
+    assertTrustedProvenanceCapability(options.capability);
+    const provenance = options.provenance ?? {};
+    const actor = provenance.actor ?? 'main_agent';
+    const sourceRefs = normalizeStringArray(provenance.source_refs);
+    const compact = {
+        actor,
+    };
+    for (const [key, value] of Object.entries(provenance)) {
+        if (!ALLOWED_PROVENANCE_FIELDS.has(key)) {
+            continue;
+        }
+        if (key === 'source_refs') {
+            compact.source_refs = sourceRefs;
+            continue;
+        }
+        if (isCompactValue(value)) {
+            compact[key] = value;
+        }
+    }
+    return {
+        actor,
+        agent_id: normalizeNullableString(provenance.agent_id),
+        model_run_id: normalizeNullableString(provenance.model_run_id),
+        envelope_hash: normalizeNullableString(provenance.envelope_hash),
+        tool_name: normalizeNullableString(provenance.tool_name),
+        gateway_call_id: normalizeNullableString(provenance.gateway_call_id),
+        source_turn_id: normalizeNullableString(provenance.source_turn_id),
+        source_message_ref: normalizeNullableString(provenance.source_message_ref),
+        source_refs: sourceRefs,
+        provenance: compact,
+    };
+}
+function appendProvenanceSourceRefs(options, refs) {
+    if (!options) {
+        return undefined;
+    }
+    assertTrustedProvenanceCapability(options.capability);
+    return {
+        capability: options.capability,
+        provenance: {
+            ...options.provenance,
+            source_refs: [...(options.provenance.source_refs ?? []), ...refs],
+        },
+    };
+}
+function buildFallbackProvenance() {
+    const actor = 'actor:direct_client';
+    return {
+        actor,
+        agent_id: null,
+        model_run_id: null,
+        envelope_hash: null,
+        tool_name: null,
+        gateway_call_id: null,
+        source_turn_id: null,
+        source_message_ref: null,
+        source_refs: [],
+        provenance: {
+            actor,
+            source_type: 'direct_client',
+        },
+    };
+}
+function normalizeNullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string' && item.length > 0);
+}
+function isCompactValue(value) {
+    if (value === null) {
+        return true;
+    }
+    if (['string', 'number', 'boolean'].includes(typeof value)) {
+        return true;
+    }
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+//# sourceMappingURL=provenance.js.map

package/dist/memory/scope-backfill.d.ts

@@ -0,0 +1,17 @@
+import { type DatabaseAdapter } from '../db-manager.js';
+export interface BackfillResult {
+    scanned: number;
+    updated: number;
+}
+export interface ConnectorEventScopeBackfillInput {
+    source_connector?: string;
+    source_id?: string;
+    source_cursor?: string;
+    tenant_id?: string;
+    project_id?: string;
+    memory_scope_kind?: string;
+    memory_scope_id?: string;
+}
+export declare function backfillLegacyMemoryProvenance(adapter?: DatabaseAdapter | null): Promise<BackfillResult>;
+export declare function backfillConnectorEventScopeMetadata(input: ConnectorEventScopeBackfillInput, adapter?: DatabaseAdapter | null): Promise<BackfillResult>;
+//# sourceMappingURL=scope-backfill.d.ts.map

package/dist/memory/scope-backfill.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backfillLegacyMemoryProvenance = backfillLegacyMemoryProvenance;
+exports.backfillConnectorEventScopeMetadata = backfillConnectorEventScopeMetadata;
+const db_manager_js_1 = require("../db-manager.js");
+const LEGACY_PROVENANCE_JSON = JSON.stringify({
+    actor: 'actor:legacy',
+    source_type: 'legacy',
+});
+async function backfillLegacyMemoryProvenance(adapter = null) {
+    await (0, db_manager_js_1.initDB)();
+    const db = adapter ?? (0, db_manager_js_1.getAdapter)();
+    const row = db
+        .prepare(`
+        SELECT COUNT(*) AS count
+        FROM decisions
+        WHERE provenance_json IS NULL
+      `)
+        .get();
+    const result = db
+        .prepare(`
+        UPDATE decisions
+        SET
+          source_refs_json = COALESCE(source_refs_json, '[]'),
+          provenance_json = ?
+        WHERE provenance_json IS NULL
+      `)
+        .run(LEGACY_PROVENANCE_JSON);
+    return {
+        scanned: row.count,
+        updated: result.changes,
+    };
+}
+async function backfillConnectorEventScopeMetadata(input, adapter = null) {
+    await (0, db_manager_js_1.initDB)();
+    const db = adapter ?? (0, db_manager_js_1.getAdapter)();
+    const assignments = [];
+    const assignmentParams = [];
+    for (const column of [
+        'source_cursor',
+        'tenant_id',
+        'project_id',
+        'memory_scope_kind',
+        'memory_scope_id',
+    ]) {
+        const value = input[column];
+        if (value !== undefined) {
+            assignments.push(`${column} = COALESCE(${column}, ?)`);
+            assignmentParams.push(value);
+        }
+    }
+    if (assignments.length === 0) {
+        return { scanned: 0, updated: 0 };
+    }
+    const where = [];
+    const whereParams = [];
+    if (input.source_connector !== undefined) {
+        where.push('source_connector = ?');
+        whereParams.push(input.source_connector);
+    }
+    if (input.source_id !== undefined) {
+        where.push('source_id = ?');
+        whereParams.push(input.source_id);
+    }
+    const whereSql = where.length > 0 ? ` WHERE ${where.join(' AND ')}` : '';
+    const scanned = db
+        .prepare(`SELECT COUNT(*) AS count FROM connector_event_index${whereSql}`)
+        .get(...whereParams);
+    const result = db
+        .prepare(`UPDATE connector_event_index SET ${assignments.join(', ')}${whereSql}`)
+        .run(...assignmentParams, ...whereParams);
+    return {
+        scanned: scanned.count,
+        updated: result.changes,
+    };
+}
+//# sourceMappingURL=scope-backfill.js.map