cogmem 3.6.2

package/dist/store/FactStore.d.ts

@@ -0,0 +1,76 @@
+import Database from 'bun:sqlite';
+import type { EncryptionProvider } from '../encryption/index.js';
+export interface FactRecord {
+    factId: string;
+    neuronId: string;
+    unitId?: string;
+    subject: string;
+    predicateFamily: string;
+    predicateValue?: string;
+    object?: string;
+    entityId?: string;
+    timeText?: string;
+    validFrom: number;
+    validTo?: number;
+    certaintyLevel: 'certain' | 'probable' | 'possible' | 'denied';
+    confidence: number;
+    status: 'provisional' | 'verified' | 'superseded' | 'archived' | 'rejected' | 'provisional_enriched' | 'enriched_candidate';
+    sourceText: string;
+    metadata?: Record<string, unknown>;
+}
+export interface EventRecord {
+    eventId: string;
+    neuronId: string;
+    unitId?: string;
+    eventType: string;
+    actor?: string;
+    target?: string;
+    payload?: Record<string, unknown>;
+    timeText?: string;
+    validFrom: number;
+    validTo?: number;
+    confidence: number;
+    status: 'provisional' | 'verified' | 'archived';
+}
+export declare class FactStore {
+    private readonly encryptionProvider?;
+    private db;
+    constructor(dbPath?: string, encryptionProvider?: EncryptionProvider | undefined);
+    private initializeSchema;
+    insertFacts(facts: Array<Omit<FactRecord, 'factId'>>): FactRecord[];
+    insertEvents(events: Array<Omit<EventRecord, 'eventId'>>): EventRecord[];
+    listFactsByNeuron(neuronId: string): FactRecord[];
+    getFactById(factId: string): FactRecord | null;
+    listFactsBySubjectPredicate(subject: string, predicateFamily: string, options?: {
+        limit?: number;
+        statuses?: FactRecord['status'][];
+    }): FactRecord[];
+    listFactsByNeuronIds(neuronIds: string[], limit?: number): FactRecord[];
+    listFactsByEntityIds(entityIds: string[], options?: {
+        predicateFamilies?: string[];
+        limit?: number;
+    }): FactRecord[];
+    listNeuronIdsByEntityIds(entityIds: string[], limit?: number): string[];
+    listEventsByNeuronIds(neuronIds: string[], limit?: number): EventRecord[];
+    listEventsByUnitId(unitId: string): EventRecord[];
+    listEventsByUnitIds(unitIds: string[], limit?: number): EventRecord[];
+    listFactsByTimeRange(startTime: number, endTime: number, options?: {
+        statuses?: FactRecord['status'][];
+        limit?: number;
+    }): FactRecord[];
+    listEventsByTimeRange(startTime: number, endTime: number, options?: {
+        statuses?: EventRecord['status'][];
+        limit?: number;
+    }): EventRecord[];
+    updateFactStatus(factId: string, status: FactRecord['status'], confidence?: number, metadata?: Record<string, unknown>): void;
+    bindFactEntity(factId: string, entityId: string, confidence?: number, metadata?: Record<string, unknown>): void;
+    updateFactMetadata(factId: string, metadata: Record<string, unknown>): void;
+    getDatabase(): Database;
+    updateEventStatus(eventId: string, status: EventRecord['status'], confidence?: number): void;
+    close(): void;
+    private mapFact;
+    private mapEvent;
+    private encodeText;
+    private decodeText;
+}
+//# sourceMappingURL=FactStore.d.ts.map

package/dist/store/FactStore.js

@@ -0,0 +1,356 @@
+import Database from 'bun:sqlite';
+import { randomUUID } from 'crypto';
+export class FactStore {
+    encryptionProvider;
+    db;
+    constructor(dbPath = ':memory:', encryptionProvider) {
+        this.encryptionProvider = encryptionProvider;
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS facts (
+        fact_id TEXT PRIMARY KEY,
+        neuron_id TEXT NOT NULL,
+        unit_id TEXT,
+        subject TEXT NOT NULL,
+        predicate_family TEXT NOT NULL,
+        predicate_value TEXT,
+        object_value TEXT,
+        entity_id TEXT,
+        time_text TEXT,
+        valid_from INTEGER NOT NULL,
+        valid_to INTEGER,
+        certainty_level TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        status TEXT NOT NULL,
+        source_text TEXT NOT NULL,
+        metadata_json TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_facts_subject_predicate
+        ON facts(subject, predicate_family, valid_from DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_facts_entity_id
+        ON facts(entity_id, valid_from DESC);
+
+      CREATE TABLE IF NOT EXISTS compiled_events (
+        event_id TEXT PRIMARY KEY,
+        neuron_id TEXT NOT NULL,
+        unit_id TEXT,
+        event_type TEXT NOT NULL,
+        actor TEXT,
+        target TEXT,
+        payload_json TEXT,
+        time_text TEXT,
+        valid_from INTEGER NOT NULL,
+        valid_to INTEGER,
+        confidence REAL NOT NULL,
+        status TEXT NOT NULL
+      );
+    `);
+    }
+    insertFacts(facts) {
+        const stmt = this.db.prepare(`
+      INSERT INTO facts (
+        fact_id, neuron_id, unit_id, subject, predicate_family, predicate_value, object_value,
+        entity_id, time_text, valid_from, valid_to, certainty_level, confidence, status, source_text, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        return facts.map((fact) => {
+            const record = {
+                factId: `fact-${randomUUID()}`,
+                ...fact
+            };
+            stmt.run(record.factId, record.neuronId, record.unitId || null, record.subject, record.predicateFamily, record.predicateValue || null, record.object || null, record.entityId || null, record.timeText || null, record.validFrom, record.validTo || null, record.certaintyLevel, record.confidence, record.status, this.encodeText(record.sourceText), record.metadata ? JSON.stringify(record.metadata) : null);
+            return record;
+        });
+    }
+    insertEvents(events) {
+        const stmt = this.db.prepare(`
+      INSERT INTO compiled_events (
+        event_id, neuron_id, unit_id, event_type, actor, target, payload_json,
+        time_text, valid_from, valid_to, confidence, status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        return events.map((event) => {
+            const record = {
+                eventId: `cevt-${randomUUID()}`,
+                ...event
+            };
+            stmt.run(record.eventId, record.neuronId, record.unitId || null, record.eventType, record.actor || null, record.target || null, record.payload ? JSON.stringify(record.payload) : null, record.timeText || null, record.validFrom, record.validTo || null, record.confidence, record.status);
+            return record;
+        });
+    }
+    listFactsByNeuron(neuronId) {
+        const rows = this.db.prepare(`
+      SELECT * FROM facts WHERE neuron_id = ? ORDER BY valid_from DESC, fact_id DESC
+    `).all(neuronId);
+        return rows.map((row) => this.mapFact(row));
+    }
+    getFactById(factId) {
+        const row = this.db.prepare(`
+      SELECT *
+      FROM facts
+      WHERE fact_id = ?
+    `).get(factId);
+        return row ? this.mapFact(row) : null;
+    }
+    listFactsBySubjectPredicate(subject, predicateFamily, options) {
+        const statuses = options?.statuses || [];
+        const params = [subject, predicateFamily];
+        let sql = `
+      SELECT *
+      FROM facts
+      WHERE subject = ?
+        AND predicate_family = ?
+    `;
+        if (statuses.length > 0) {
+            sql += ` AND status IN (${statuses.map(() => '?').join(', ')})`;
+            params.push(...statuses);
+        }
+        sql += ` ORDER BY valid_from DESC, fact_id DESC LIMIT ?`;
+        params.push(options?.limit ?? 100);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.mapFact(row));
+    }
+    listFactsByNeuronIds(neuronIds, limit = 50) {
+        if (neuronIds.length === 0)
+            return [];
+        const placeholders = neuronIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM facts
+      WHERE neuron_id IN (${placeholders})
+      ORDER BY valid_from DESC, fact_id DESC
+      LIMIT ?
+    `).all(...neuronIds, limit);
+        return rows.map((row) => this.mapFact(row));
+    }
+    listFactsByEntityIds(entityIds, options) {
+        if (entityIds.length === 0)
+            return [];
+        const limit = options?.limit ?? 50;
+        const entityPlaceholders = entityIds.map(() => '?').join(', ');
+        const predicateFamilies = options?.predicateFamilies || [];
+        const rows = predicateFamilies.length > 0
+            ? this.db.prepare(`
+          SELECT *
+          FROM facts
+          WHERE entity_id IN (${entityPlaceholders})
+            AND predicate_family IN (${predicateFamilies.map(() => '?').join(', ')})
+          ORDER BY valid_from DESC, fact_id DESC
+          LIMIT ?
+        `).all(...entityIds, ...predicateFamilies, limit)
+            : this.db.prepare(`
+          SELECT *
+          FROM facts
+          WHERE entity_id IN (${entityPlaceholders})
+          ORDER BY valid_from DESC, fact_id DESC
+          LIMIT ?
+        `).all(...entityIds, limit);
+        return rows.map((row) => this.mapFact(row));
+    }
+    listNeuronIdsByEntityIds(entityIds, limit = 50) {
+        if (entityIds.length === 0)
+            return [];
+        const placeholders = entityIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+      SELECT DISTINCT neuron_id
+      FROM facts
+      WHERE entity_id IN (${placeholders})
+      ORDER BY valid_from DESC
+      LIMIT ?
+    `).all(...entityIds, limit);
+        return rows.map((row) => row.neuron_id);
+    }
+    listEventsByNeuronIds(neuronIds, limit = 50) {
+        if (neuronIds.length === 0)
+            return [];
+        const placeholders = neuronIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM compiled_events
+      WHERE neuron_id IN (${placeholders})
+      ORDER BY valid_from DESC, event_id DESC
+      LIMIT ?
+    `).all(...neuronIds, limit);
+        return rows.map((row) => this.mapEvent(row));
+    }
+    listEventsByUnitId(unitId) {
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM compiled_events
+      WHERE unit_id = ?
+      ORDER BY valid_from DESC, event_id DESC
+    `).all(unitId);
+        return rows.map((row) => this.mapEvent(row));
+    }
+    listEventsByUnitIds(unitIds, limit = 50) {
+        if (unitIds.length === 0)
+            return [];
+        const placeholders = unitIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM compiled_events
+      WHERE unit_id IN (${placeholders})
+      ORDER BY valid_from DESC, event_id DESC
+      LIMIT ?
+    `).all(...unitIds, limit);
+        return rows.map((row) => this.mapEvent(row));
+    }
+    listFactsByTimeRange(startTime, endTime, options) {
+        const statuses = options?.statuses || [];
+        const params = [startTime, endTime];
+        let sql = `
+      SELECT *
+      FROM facts
+      WHERE valid_from >= ?
+        AND valid_from < ?
+    `;
+        if (statuses.length > 0) {
+            sql += ` AND status IN (${statuses.map(() => '?').join(', ')})`;
+            params.push(...statuses);
+        }
+        sql += ` ORDER BY valid_from DESC, fact_id DESC LIMIT ?`;
+        params.push(options?.limit ?? 500);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.mapFact(row));
+    }
+    listEventsByTimeRange(startTime, endTime, options) {
+        const statuses = options?.statuses || [];
+        const params = [startTime, endTime];
+        let sql = `
+      SELECT *
+      FROM compiled_events
+      WHERE valid_from >= ?
+        AND valid_from < ?
+    `;
+        if (statuses.length > 0) {
+            sql += ` AND status IN (${statuses.map(() => '?').join(', ')})`;
+            params.push(...statuses);
+        }
+        sql += ` ORDER BY valid_from DESC, event_id DESC LIMIT ?`;
+        params.push(options?.limit ?? 500);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((row) => this.mapEvent(row));
+    }
+    updateFactStatus(factId, status, confidence, metadata) {
+        const existing = this.db.prepare(`
+      SELECT metadata_json
+      FROM facts
+      WHERE fact_id = ?
+    `).get(factId);
+        const mergedMetadata = metadata
+            ? JSON.stringify({
+                ...(existing?.metadata_json ? JSON.parse(existing.metadata_json) : {}),
+                ...metadata
+            })
+            : existing?.metadata_json || null;
+        this.db.prepare(`
+      UPDATE facts
+      SET status = ?,
+          confidence = COALESCE(?, confidence),
+          metadata_json = ?,
+          valid_to = CASE
+            WHEN ? IN ('archived', 'rejected', 'superseded') THEN COALESCE(valid_to, ?)
+            ELSE valid_to
+          END
+      WHERE fact_id = ?
+    `).run(status, confidence ?? null, mergedMetadata, status, Date.now(), factId);
+    }
+    bindFactEntity(factId, entityId, confidence, metadata) {
+        const existing = this.db.prepare(`
+      SELECT metadata_json
+      FROM facts
+      WHERE fact_id = ?
+    `).get(factId);
+        const mergedMetadata = metadata
+            ? JSON.stringify({
+                ...(existing?.metadata_json ? JSON.parse(existing.metadata_json) : {}),
+                ...metadata
+            })
+            : existing?.metadata_json || null;
+        this.db.prepare(`
+      UPDATE facts
+      SET entity_id = ?,
+          confidence = COALESCE(?, confidence),
+          metadata_json = ?
+      WHERE fact_id = ?
+    `).run(entityId, confidence ?? null, mergedMetadata, factId);
+    }
+    updateFactMetadata(factId, metadata) {
+        const existing = this.db.prepare(`
+      SELECT metadata_json
+      FROM facts
+      WHERE fact_id = ?
+    `).get(factId);
+        const mergedMetadata = JSON.stringify({
+            ...(existing?.metadata_json ? JSON.parse(existing.metadata_json) : {}),
+            ...metadata
+        });
+        this.db.prepare(`
+      UPDATE facts
+      SET metadata_json = ?
+      WHERE fact_id = ?
+    `).run(mergedMetadata, factId);
+    }
+    getDatabase() {
+        return this.db;
+    }
+    updateEventStatus(eventId, status, confidence) {
+        this.db.prepare(`
+      UPDATE compiled_events
+      SET status = ?,
+          confidence = COALESCE(?, confidence),
+          valid_to = CASE WHEN ? = 'archived' THEN COALESCE(valid_to, ?) ELSE valid_to END
+      WHERE event_id = ?
+    `).run(status, confidence ?? null, status, Date.now(), eventId);
+    }
+    close() {
+        this.db.close();
+    }
+    mapFact(row) {
+        return {
+            factId: row.fact_id,
+            neuronId: row.neuron_id,
+            unitId: row.unit_id || undefined,
+            subject: row.subject,
+            predicateFamily: row.predicate_family,
+            predicateValue: row.predicate_value || undefined,
+            object: row.object_value || undefined,
+            entityId: row.entity_id || undefined,
+            timeText: row.time_text || undefined,
+            validFrom: row.valid_from,
+            validTo: row.valid_to || undefined,
+            certaintyLevel: row.certainty_level,
+            confidence: row.confidence,
+            status: row.status,
+            sourceText: this.decodeText(row.source_text),
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined
+        };
+    }
+    mapEvent(row) {
+        return {
+            eventId: row.event_id,
+            neuronId: row.neuron_id,
+            unitId: row.unit_id || undefined,
+            eventType: row.event_type,
+            actor: row.actor || undefined,
+            target: row.target || undefined,
+            payload: row.payload_json ? JSON.parse(row.payload_json) : undefined,
+            timeText: row.time_text || undefined,
+            validFrom: row.valid_from,
+            validTo: row.valid_to || undefined,
+            confidence: row.confidence,
+            status: row.status
+        };
+    }
+    encodeText(value) {
+        return this.encryptionProvider?.encrypt(value) ?? value;
+    }
+    decodeText(value) {
+        return this.encryptionProvider?.decrypt(value) ?? value;
+    }
+}

package/dist/store/HnswlibVectorStore.d.ts

@@ -0,0 +1,2 @@
+export { VectorStore as HnswlibVectorStore } from './VectorStore.js';
+//# sourceMappingURL=HnswlibVectorStore.d.ts.map

package/dist/store/HnswlibVectorStore.js

@@ -0,0 +1 @@
+export { VectorStore as HnswlibVectorStore } from './VectorStore.js';

package/dist/store/IVectorStore.d.ts

@@ -0,0 +1,32 @@
+export interface VectorSearchResult {
+    id: string;
+    score: number;
+}
+export interface VectorStoreStats {
+    backend: VectorBackend;
+    size: number;
+    dimension: number;
+    maxElements?: number;
+    efConstruction?: number;
+    efSearch?: number;
+    tombstones?: number;
+}
+export type VectorBackend = 'hnswlib' | 'sqlite-vec';
+export interface IVectorStore {
+    addVector(neuronId: string, vector: number[]): void;
+    addVectors?(vectors: Array<{
+        id: string;
+        vector: number[];
+    }>): void;
+    removePoint(neuronId: string): void;
+    search(queryVector: number[], k: number): VectorSearchResult[];
+    getStats(): VectorStoreStats;
+    getCurrentCount(): number;
+    clear(): void;
+    checkIntegrity?(): boolean;
+    rebuildIndex?(neurons: Array<{
+        id: string;
+        vector: number[];
+    }>): Promise<void>;
+}
+//# sourceMappingURL=IVectorStore.d.ts.map

package/dist/store/IVectorStore.js

@@ -0,0 +1 @@
+export {};

package/dist/store/InteractionUnitStore.d.ts

@@ -0,0 +1,52 @@
+export type InteractionUnitType = 'statement' | 'question' | 'proposal' | 'bound_reply';
+export type PendingBindingType = 'action' | 'entity' | 'question';
+export declare const BINDING_PRIORITY: Record<PendingBindingType, number>;
+export interface InteractionUnitRecord {
+    unitId: string;
+    type: InteractionUnitType;
+    messageNeuronIds: string[];
+    semanticText: string;
+    status: 'pending' | 'resolved';
+    createdAt: number;
+    updatedAt: number;
+}
+export interface PendingBindingRecord {
+    pendingId: string;
+    bindingType: PendingBindingType;
+    unitId: string;
+    referenceText: string;
+    status: 'pending' | 'resolved';
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class InteractionUnitStore {
+    private db;
+    constructor(dbPath?: string);
+    private initializeSchema;
+    createUnit(input: {
+        type: InteractionUnitType;
+        messageNeuronIds: string[];
+        semanticText: string;
+        status?: 'pending' | 'resolved';
+        createdAt?: number;
+    }): InteractionUnitRecord;
+    registerPending(input: {
+        bindingType: PendingBindingType;
+        unitId: string;
+        referenceText: string;
+        createdAt?: number;
+    }): PendingBindingRecord;
+    getLatestPending(bindingTypes?: PendingBindingType[], maxAgeMs?: number, now?: number): PendingBindingRecord | null;
+    getUnit(unitId: string): InteractionUnitRecord | null;
+    listUnitsByNeuronIds(neuronIds: string[]): InteractionUnitRecord[];
+    resolvePendingWithReply(input: {
+        pendingId: string;
+        replyNeuronId: string;
+        semanticText: string;
+        resolvedAt?: number;
+    }): InteractionUnitRecord | null;
+    close(): void;
+    private mapUnit;
+    private mapPending;
+}
+//# sourceMappingURL=InteractionUnitStore.d.ts.map

package/dist/store/InteractionUnitStore.js

@@ -0,0 +1,167 @@
+import Database from 'bun:sqlite';
+import { randomUUID } from 'crypto';
+export const BINDING_PRIORITY = {
+    entity: 3,
+    action: 2,
+    question: 1
+};
+export class InteractionUnitStore {
+    db;
+    constructor(dbPath = ':memory:') {
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS interaction_units (
+        unit_id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        message_neuron_ids_json TEXT NOT NULL,
+        semantic_text TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pending_bindings (
+        pending_id TEXT PRIMARY KEY,
+        binding_type TEXT NOT NULL,
+        unit_id TEXT NOT NULL,
+        reference_text TEXT NOT NULL,
+        status TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pending_bindings_status_time
+        ON pending_bindings(status, updated_at DESC);
+    `);
+    }
+    createUnit(input) {
+        const createdAt = input.createdAt ?? Date.now();
+        const record = {
+            unitId: `unit-${randomUUID()}`,
+            type: input.type,
+            messageNeuronIds: input.messageNeuronIds,
+            semanticText: input.semanticText,
+            status: input.status ?? 'resolved',
+            createdAt,
+            updatedAt: createdAt
+        };
+        this.db.prepare(`
+      INSERT INTO interaction_units (
+        unit_id, type, message_neuron_ids_json, semantic_text, status, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(record.unitId, record.type, JSON.stringify(record.messageNeuronIds), record.semanticText, record.status, record.createdAt, record.updatedAt);
+        return record;
+    }
+    registerPending(input) {
+        const createdAt = input.createdAt ?? Date.now();
+        const record = {
+            pendingId: `pending-${randomUUID()}`,
+            bindingType: input.bindingType,
+            unitId: input.unitId,
+            referenceText: input.referenceText,
+            status: 'pending',
+            createdAt,
+            updatedAt: createdAt
+        };
+        this.db.prepare(`
+      INSERT INTO pending_bindings (
+        pending_id, binding_type, unit_id, reference_text, status, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(record.pendingId, record.bindingType, record.unitId, record.referenceText, record.status, record.createdAt, record.updatedAt);
+        return record;
+    }
+    getLatestPending(bindingTypes = ['action', 'entity', 'question'], maxAgeMs = 10 * 60 * 1000, now = Date.now()) {
+        const safeTypes = bindingTypes.length ? bindingTypes : ['action', 'entity', 'question'];
+        const placeholders = safeTypes.map(() => '?').join(', ');
+        const row = this.db.prepare(`
+      SELECT *
+      FROM pending_bindings
+      WHERE status = 'pending'
+        AND binding_type IN (${placeholders})
+        AND created_at >= ?
+      ORDER BY CASE binding_type
+        WHEN 'entity' THEN ${BINDING_PRIORITY.entity}
+        WHEN 'action' THEN ${BINDING_PRIORITY.action}
+        ELSE ${BINDING_PRIORITY.question}
+      END DESC,
+      updated_at DESC,
+      created_at DESC
+      LIMIT 1
+    `).get(...safeTypes, now - maxAgeMs);
+        return row ? this.mapPending(row) : null;
+    }
+    getUnit(unitId) {
+        const row = this.db.prepare(`
+      SELECT * FROM interaction_units WHERE unit_id = ?
+    `).get(unitId);
+        return row ? this.mapUnit(row) : null;
+    }
+    listUnitsByNeuronIds(neuronIds) {
+        if (neuronIds.length === 0)
+            return [];
+        const rows = this.db.prepare(`
+      SELECT *
+      FROM interaction_units
+      ORDER BY updated_at DESC, created_at DESC
+    `).all();
+        const neuronIdSet = new Set(neuronIds);
+        return rows
+            .map((row) => this.mapUnit(row))
+            .filter((unit) => unit.messageNeuronIds.some((neuronId) => neuronIdSet.has(neuronId)));
+    }
+    resolvePendingWithReply(input) {
+        const pending = this.db.prepare(`
+      SELECT * FROM pending_bindings WHERE pending_id = ?
+    `).get(input.pendingId);
+        if (!pending)
+            return null;
+        const unit = this.getUnit(pending.unit_id);
+        if (!unit)
+            return null;
+        const resolvedAt = input.resolvedAt ?? Date.now();
+        const mergedIds = Array.from(new Set([...unit.messageNeuronIds, input.replyNeuronId]));
+        this.db.prepare(`
+      UPDATE interaction_units
+      SET type = 'bound_reply',
+          message_neuron_ids_json = ?,
+          semantic_text = ?,
+          status = 'resolved',
+          updated_at = ?
+      WHERE unit_id = ?
+    `).run(JSON.stringify(mergedIds), input.semanticText, resolvedAt, unit.unitId);
+        this.db.prepare(`
+      UPDATE pending_bindings
+      SET status = 'resolved', updated_at = ?
+      WHERE pending_id = ?
+    `).run(resolvedAt, input.pendingId);
+        return this.getUnit(unit.unitId);
+    }
+    close() {
+        this.db.close();
+    }
+    mapUnit(row) {
+        return {
+            unitId: row.unit_id,
+            type: row.type,
+            messageNeuronIds: JSON.parse(row.message_neuron_ids_json),
+            semanticText: row.semantic_text,
+            status: row.status,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+    mapPending(row) {
+        return {
+            pendingId: row.pending_id,
+            bindingType: row.binding_type,
+            unitId: row.unit_id,
+            referenceText: row.reference_text,
+            status: row.status,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at
+        };
+    }
+}