cogmem 3.6.2

package/dist/store/ProjectionObservabilityStore.js

@@ -0,0 +1,310 @@
+import Database from 'bun:sqlite';
+export class ProjectionObservabilityStore {
+    db;
+    constructor(dbPath = ':memory:') {
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projection_observability_samples (
+        sample_id TEXT PRIMARY KEY,
+        projection_type TEXT NOT NULL,
+        projection_name TEXT NOT NULL,
+        checkpoint_status TEXT NOT NULL,
+        pending_events INTEGER NOT NULL,
+        materialized_count INTEGER NOT NULL,
+        metadata_json TEXT,
+        sampled_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_projection_observability_type_time
+        ON projection_observability_samples(projection_type, sampled_at DESC);
+
+      CREATE TABLE IF NOT EXISTS projection_observability_rollups (
+        rollup_id TEXT PRIMARY KEY,
+        projection_type TEXT NOT NULL,
+        projection_name TEXT NOT NULL,
+        checkpoint_status TEXT NOT NULL,
+        pending_events INTEGER NOT NULL,
+        materialized_count INTEGER NOT NULL,
+        bucket_ms INTEGER NOT NULL,
+        sample_count INTEGER NOT NULL,
+        metadata_json TEXT,
+        sampled_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_projection_observability_rollups_type_time
+        ON projection_observability_rollups(projection_type, sampled_at DESC);
+    `);
+    }
+    insertSample(input) {
+        const sampledAt = input.sampledAt ?? Date.now();
+        const sampleId = `${input.projectionType}:${input.projectionName}:${sampledAt}:${Math.random().toString(36).slice(2, 8)}`;
+        this.db.prepare(`
+      INSERT INTO projection_observability_samples (
+        sample_id, projection_type, projection_name, checkpoint_status,
+        pending_events, materialized_count, metadata_json, sampled_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(sampleId, input.projectionType, input.projectionName, input.checkpointStatus, input.pendingEvents, input.materializedCount, input.metadata ? JSON.stringify(input.metadata) : null, sampledAt);
+    }
+    deleteOlderThan(cutoffTime) {
+        const result = this.db.prepare(`
+      DELETE FROM projection_observability_samples
+      WHERE sampled_at < ?
+    `).run(cutoffTime);
+        return Number(result.changes || 0);
+    }
+    compactOlderThan(cutoffTime, bucketMs = 60 * 60 * 1000) {
+        const safeBucketMs = Math.max(60_000, bucketMs);
+        const rows = this.db.prepare(`
+      SELECT
+        projection_type,
+        projection_name,
+        checkpoint_status,
+        CAST(sampled_at / ? AS INTEGER) * ? AS bucket_start,
+        AVG(pending_events) AS avg_pending_events,
+        AVG(materialized_count) AS avg_materialized_count,
+        COUNT(*) AS sample_count
+      FROM projection_observability_samples
+      WHERE sampled_at < ?
+      GROUP BY projection_type, projection_name, checkpoint_status, bucket_start
+      ORDER BY bucket_start ASC
+    `).all(safeBucketMs, safeBucketMs, cutoffTime);
+        const insertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO projection_observability_rollups (
+        rollup_id, projection_type, projection_name, checkpoint_status,
+        pending_events, materialized_count, bucket_ms, sample_count, metadata_json, sampled_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const row of rows) {
+            const rollupId = [
+                row.projection_type,
+                row.projection_name,
+                row.checkpoint_status,
+                safeBucketMs,
+                row.bucket_start
+            ].join(':');
+            insertStmt.run(rollupId, row.projection_type, row.projection_name, row.checkpoint_status, Math.round(row.avg_pending_events), Math.round(row.avg_materialized_count), safeBucketMs, row.sample_count, JSON.stringify({ storageTier: 'rollup' }), row.bucket_start);
+        }
+        const prunedSamples = this.deleteOlderThan(cutoffTime);
+        return {
+            insertedRollups: rows.length,
+            prunedSamples
+        };
+    }
+    compactRollupsOlderThan(cutoffTime, sourceBucketMs, targetBucketMs) {
+        if (targetBucketMs <= sourceBucketMs) {
+            return { insertedRollups: 0, prunedRollups: 0 };
+        }
+        const rows = this.db.prepare(`
+      SELECT
+        projection_type,
+        projection_name,
+        checkpoint_status,
+        CAST(sampled_at / ? AS INTEGER) * ? AS bucket_start,
+        AVG(pending_events) AS avg_pending_events,
+        AVG(materialized_count) AS avg_materialized_count,
+        SUM(sample_count) AS sample_count
+      FROM projection_observability_rollups
+      WHERE sampled_at < ?
+        AND bucket_ms = ?
+      GROUP BY projection_type, projection_name, checkpoint_status, bucket_start
+      ORDER BY bucket_start ASC
+    `).all(targetBucketMs, targetBucketMs, cutoffTime, sourceBucketMs);
+        const insertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO projection_observability_rollups (
+        rollup_id, projection_type, projection_name, checkpoint_status,
+        pending_events, materialized_count, bucket_ms, sample_count, metadata_json, sampled_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const row of rows) {
+            const rollupId = [
+                row.projection_type,
+                row.projection_name,
+                row.checkpoint_status,
+                targetBucketMs,
+                row.bucket_start
+            ].join(':');
+            insertStmt.run(rollupId, row.projection_type, row.projection_name, row.checkpoint_status, Math.round(row.avg_pending_events), Math.round(row.avg_materialized_count), targetBucketMs, row.sample_count, JSON.stringify({ storageTier: 'rollup', sourceBucketMs }), row.bucket_start);
+        }
+        const deleteResult = this.db.prepare(`
+      DELETE FROM projection_observability_rollups
+      WHERE sampled_at < ?
+        AND bucket_ms = ?
+    `).run(cutoffTime, sourceBucketMs);
+        return {
+            insertedRollups: rows.length,
+            prunedRollups: Number(deleteResult.changes || 0)
+        };
+    }
+    getSampleCount() {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS count FROM projection_observability_samples
+    `).get();
+        return row?.count || 0;
+    }
+    getRollupCount() {
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS count FROM projection_observability_rollups
+    `).get();
+        return row?.count || 0;
+    }
+    getStorageStats() {
+        const bucketRows = this.db.prepare(`
+      SELECT DISTINCT bucket_ms FROM projection_observability_rollups ORDER BY bucket_ms ASC
+    `).all();
+        return {
+            rawSampleCount: this.getSampleCount(),
+            rollupCount: this.getRollupCount(),
+            rollupBuckets: bucketRows.map((row) => row.bucket_ms)
+        };
+    }
+    getHistoryPage(page = 1, pageSize = 20, filters) {
+        const safePage = Math.max(1, page);
+        const safePageSize = Math.max(1, pageSize);
+        const offset = (safePage - 1) * safePageSize;
+        const conditions = [];
+        const params = [];
+        if (filters?.projectionType?.length) {
+            conditions.push(`projection_type IN (${filters.projectionType.map(() => '?').join(', ')})`);
+            params.push(...filters.projectionType);
+        }
+        if (filters?.checkpointStatus?.length) {
+            conditions.push(`checkpoint_status IN (${filters.checkpointStatus.map(() => '?').join(', ')})`);
+            params.push(...filters.checkpointStatus);
+        }
+        if (filters?.startTime !== undefined) {
+            conditions.push('sampled_at >= ?');
+            params.push(filters.startTime);
+        }
+        if (filters?.endTime !== undefined) {
+            conditions.push('sampled_at <= ?');
+            params.push(filters.endTime);
+        }
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const bucketMs = filters?.bucketMs && filters.bucketMs > 0 ? filters.bucketMs : undefined;
+        const aggregateMode = filters?.aggregateMode || 'latest';
+        const useAggregation = Boolean(bucketMs);
+        const includeRollups = filters?.includeRollups !== false;
+        let total = 0;
+        let rows = [];
+        if (useAggregation) {
+            const sourceSql = includeRollups
+                ? `
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, sampled_at, metadata_json
+          FROM projection_observability_samples
+          ${where}
+          UNION ALL
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, sampled_at, metadata_json
+          FROM projection_observability_rollups
+          ${where}
+        `
+                : `
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, sampled_at, metadata_json
+          FROM projection_observability_samples
+          ${where}
+        `;
+            const sourceParams = includeRollups ? [...params, ...params] : [...params];
+            const bucketExpr = `CAST(sampled_at / ${bucketMs} AS INTEGER) * ${bucketMs}`;
+            const totalRow = this.db.prepare(`
+        SELECT COUNT(*) AS count FROM (
+          SELECT projection_type, projection_name, ${bucketExpr} AS bucket_start
+          FROM (${sourceSql})
+          GROUP BY projection_type, projection_name, bucket_start
+        )
+      `).get(...sourceParams);
+            total = totalRow?.count || 0;
+            rows = this.db.prepare(`
+        SELECT
+          projection_type,
+          projection_name,
+          CASE
+            WHEN ? = 'avg' THEN 'ready'
+            ELSE (
+              SELECT s2.checkpoint_status
+              FROM (${sourceSql}) s2
+              WHERE s2.projection_type = s1.projection_type
+                AND s2.projection_name = s1.projection_name
+                AND CAST(s2.sampled_at / ${bucketMs} AS INTEGER) * ${bucketMs} = ${bucketExpr}
+              ORDER BY s2.sampled_at DESC
+              LIMIT 1
+            )
+          END AS checkpoint_status,
+          CAST(AVG(pending_events) AS INTEGER) AS pending_events,
+          CAST(AVG(materialized_count) AS INTEGER) AS materialized_count,
+          MAX(sampled_at) AS sampled_at,
+          JSON_OBJECT('storageTier', 'aggregated') AS metadata_json
+        FROM (${sourceSql}) s1
+        GROUP BY projection_type, projection_name, ${bucketExpr}
+        ORDER BY sampled_at DESC, projection_name DESC
+        LIMIT ? OFFSET ?
+      `).all(aggregateMode, ...sourceParams, ...sourceParams, safePageSize, offset);
+        }
+        else {
+            const sourceSql = includeRollups
+                ? `
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, metadata_json, sampled_at
+          FROM projection_observability_samples
+          ${where}
+          UNION ALL
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, metadata_json, sampled_at
+          FROM projection_observability_rollups
+          ${where}
+        `
+                : `
+          SELECT
+            projection_type, projection_name, checkpoint_status, pending_events,
+            materialized_count, metadata_json, sampled_at
+          FROM projection_observability_samples
+          ${where}
+        `;
+            const sourceParams = includeRollups ? [...params, ...params] : [...params];
+            const totalRow = this.db.prepare(`
+        SELECT COUNT(*) AS count FROM (${sourceSql})
+      `).get(...sourceParams);
+            total = totalRow?.count || 0;
+            rows = this.db.prepare(`
+        SELECT * FROM (${sourceSql})
+        ORDER BY sampled_at DESC, projection_name DESC
+        LIMIT ? OFFSET ?
+      `).all(...sourceParams, safePageSize, offset);
+        }
+        return {
+            page: safePage,
+            pageSize: safePageSize,
+            total,
+            samples: rows.map((row) => ({
+                projectionType: row.projection_type,
+                projectionName: row.projection_name,
+                checkpointStatus: row.checkpoint_status,
+                pendingEvents: row.pending_events,
+                materializedCount: row.materialized_count,
+                sampledAt: row.sampled_at,
+                metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined
+            })),
+            appliedFilters: {
+                projectionType: filters?.projectionType,
+                checkpointStatus: filters?.checkpointStatus,
+                bucketMs: filters?.bucketMs,
+                aggregateMode,
+                startTime: filters?.startTime,
+                endTime: filters?.endTime,
+                includeRollups
+            }
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/store/ReasoningChainStore.d.ts

@@ -0,0 +1,13 @@
+import Database from 'bun:sqlite';
+import type { ReasoningChain } from '../types/reasoning.js';
+export declare class ReasoningChainStore {
+    private db;
+    constructor(db: Database);
+    private initSchema;
+    addChain(chain: ReasoningChain): void;
+    getChain(chainId: string): ReasoningChain | null;
+    getChainIdForNeuron(neuronId: string): string | null;
+    areNeuronsInSameChain(neuronId1: string, neuronId2: string): boolean;
+    getChainsByProject(projectId: string): ReasoningChain[];
+}
+//# sourceMappingURL=ReasoningChainStore.d.ts.map

package/dist/store/ReasoningChainStore.js

@@ -0,0 +1,74 @@
+// ============================================
+// ReasoningChainStore - 推理链存储（SQLite）
+// ============================================
+import { logger } from '../utils/Logger.js';
+export class ReasoningChainStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS reasoning_chains (
+        id TEXT PRIMARY KEY,
+        outcome TEXT NOT NULL,
+        project_id TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS reasoning_steps (
+        chain_id TEXT NOT NULL,
+        neuron_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        step_order INTEGER NOT NULL,
+        PRIMARY KEY (chain_id, neuron_id),
+        FOREIGN KEY (chain_id) REFERENCES reasoning_chains(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chain_project ON reasoning_chains(project_id);
+      CREATE INDEX IF NOT EXISTS idx_step_neuron ON reasoning_steps(neuron_id);
+    `);
+    }
+    addChain(chain) {
+        this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO reasoning_chains (id, outcome, project_id, created_at)
+        VALUES (?, ?, ?, ?)
+      `).run(chain.id, chain.outcome, chain.projectId || null, chain.createdAt);
+            for (const step of chain.steps) {
+                this.db.prepare(`
+          INSERT INTO reasoning_steps (chain_id, neuron_id, role, step_order)
+          VALUES (?, ?, ?, ?)
+        `).run(chain.id, step.neuronId, step.role, step.order);
+            }
+        })();
+        logger.debug(`ReasoningChain ${chain.id} added`);
+    }
+    getChain(chainId) {
+        const row = this.db.prepare(`SELECT * FROM reasoning_chains WHERE id = ?`).get(chainId);
+        if (!row)
+            return null;
+        const steps = this.db.prepare(`SELECT * FROM reasoning_steps WHERE chain_id = ? ORDER BY step_order`).all(chainId);
+        return {
+            id: row.id,
+            steps: steps.map(s => ({ neuronId: s.neuron_id, role: s.role, order: s.step_order })),
+            outcome: row.outcome,
+            projectId: row.project_id,
+            createdAt: row.created_at
+        };
+    }
+    getChainIdForNeuron(neuronId) {
+        const row = this.db.prepare(`SELECT chain_id FROM reasoning_steps WHERE neuron_id = ?`).get(neuronId);
+        return row?.chain_id || null;
+    }
+    areNeuronsInSameChain(neuronId1, neuronId2) {
+        const chain1 = this.getChainIdForNeuron(neuronId1);
+        const chain2 = this.getChainIdForNeuron(neuronId2);
+        return chain1 !== null && chain1 === chain2;
+    }
+    getChainsByProject(projectId) {
+        const rows = this.db.prepare(`SELECT id FROM reasoning_chains WHERE project_id = ?`).all(projectId);
+        return rows.map(r => this.getChain(r.id)).filter(Boolean);
+    }
+}

package/dist/store/RuntimeProjectionStore.d.ts

@@ -0,0 +1,18 @@
+import type { ProjectionCheckpoint } from './EventStore.js';
+export declare class RuntimeProjectionStore {
+    private db;
+    constructor(dbPath?: string);
+    private initializeSchema;
+    getCheckpoint(projectionName: string): ProjectionCheckpoint | null;
+    upsertCheckpoint(checkpoint: ProjectionCheckpoint): void;
+    getStats(projectionName: string): {
+        projectionName: string;
+        checkpointStatus: 'idle' | 'building' | 'ready' | 'degraded' | 'failed';
+        lastEventId?: string;
+        lastEventTime?: number;
+        lastRebuildAt?: number;
+        lastFullCount: number;
+    };
+    close(): void;
+}
+//# sourceMappingURL=RuntimeProjectionStore.d.ts.map

package/dist/store/RuntimeProjectionStore.js

@@ -0,0 +1,61 @@
+import Database from 'bun:sqlite';
+export class RuntimeProjectionStore {
+    db;
+    constructor(dbPath = ':memory:') {
+        this.db = new Database(dbPath);
+        this.initializeSchema();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runtime_projection_state (
+        projection_name TEXT PRIMARY KEY,
+        last_event_id TEXT,
+        last_event_time INTEGER,
+        last_rebuild_at INTEGER,
+        last_full_count INTEGER NOT NULL DEFAULT 0,
+        last_checksum TEXT,
+        status TEXT NOT NULL DEFAULT 'idle',
+        metadata_json TEXT
+      );
+    `);
+    }
+    getCheckpoint(projectionName) {
+        const row = this.db.prepare(`
+      SELECT * FROM runtime_projection_state WHERE projection_name = ?
+    `).get(projectionName);
+        if (!row)
+            return null;
+        return {
+            projectionName: row.projection_name,
+            lastEventId: row.last_event_id || undefined,
+            lastEventTime: row.last_event_time || undefined,
+            lastRebuildAt: row.last_rebuild_at || undefined,
+            lastFullCount: row.last_full_count || 0,
+            lastChecksum: row.last_checksum || undefined,
+            status: row.status,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined
+        };
+    }
+    upsertCheckpoint(checkpoint) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO runtime_projection_state (
+        projection_name, last_event_id, last_event_time, last_rebuild_at,
+        last_full_count, last_checksum, status, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(checkpoint.projectionName, checkpoint.lastEventId || null, checkpoint.lastEventTime || null, checkpoint.lastRebuildAt || null, checkpoint.lastFullCount, checkpoint.lastChecksum || null, checkpoint.status, checkpoint.metadata ? JSON.stringify(checkpoint.metadata) : null);
+    }
+    getStats(projectionName) {
+        const checkpoint = this.getCheckpoint(projectionName);
+        return {
+            projectionName,
+            checkpointStatus: checkpoint?.status || 'idle',
+            lastEventId: checkpoint?.lastEventId,
+            lastEventTime: checkpoint?.lastEventTime,
+            lastRebuildAt: checkpoint?.lastRebuildAt,
+            lastFullCount: checkpoint?.lastFullCount || 0
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/store/RuntimeProjector.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryEvent } from '../types/index.js';
+import { EventStore } from './EventStore.js';
+import { PlanRuntimeStore } from './PlanRuntimeStore.js';
+import { RuntimeProjectionStore } from './RuntimeProjectionStore.js';
+export declare class RuntimeProjector {
+    private eventStore;
+    private runtimeStore;
+    private projectionStore;
+    private projectionName;
+    constructor(eventStore: EventStore, runtimeStore: PlanRuntimeStore, projectionStore: RuntimeProjectionStore, projectionName?: string);
+    bootstrap(): Promise<void>;
+    fullRebuild(reason: string): Promise<void>;
+    replay(events: MemoryEvent[], previousRebuildAt?: number): Promise<void>;
+    private applyEvent;
+    private isRuntimeEvent;
+}
+//# sourceMappingURL=RuntimeProjector.d.ts.map

package/dist/store/RuntimeProjector.js

@@ -0,0 +1,119 @@
+import { logger } from '../utils/Logger.js';
+export class RuntimeProjector {
+    eventStore;
+    runtimeStore;
+    projectionStore;
+    projectionName;
+    constructor(eventStore, runtimeStore, projectionStore, projectionName = 'runtime_projection_main') {
+        this.eventStore = eventStore;
+        this.runtimeStore = runtimeStore;
+        this.projectionStore = projectionStore;
+        this.projectionName = projectionName;
+    }
+    async bootstrap() {
+        const checkpoint = this.projectionStore.getCheckpoint(this.projectionName);
+        const pendingEvents = this.eventStore.getEventsAfter(checkpoint?.lastEventTime)
+            .filter((event) => this.isRuntimeEvent(event));
+        if (!checkpoint) {
+            await this.fullRebuild('initial_build');
+            return;
+        }
+        if (checkpoint.status !== 'ready') {
+            await this.fullRebuild(`checkpoint_${checkpoint.status}`);
+            return;
+        }
+        if (pendingEvents.length === 0) {
+            logger.info(`Runtime projection ready: projection=${this.projectionName}`);
+            return;
+        }
+        try {
+            await this.replay(pendingEvents, checkpoint.lastRebuildAt);
+        }
+        catch (error) {
+            logger.warn('Runtime replay failed, falling back to full rebuild', error);
+            await this.fullRebuild('replay_failed');
+        }
+    }
+    async fullRebuild(reason) {
+        logger.warn(`Rebuilding runtime projection: reason=${reason}`);
+        this.projectionStore.upsertCheckpoint({
+            projectionName: this.projectionName,
+            status: 'building',
+            lastFullCount: 0,
+            metadata: { reason }
+        });
+        this.runtimeStore.clearAll();
+        const runtimeEvents = this.eventStore.getEventsAfter(undefined).filter((event) => this.isRuntimeEvent(event));
+        await this.replay(runtimeEvents);
+    }
+    async replay(events, previousRebuildAt) {
+        if (events.length === 0) {
+            const latestEvent = this.eventStore.getLatestEvent();
+            this.projectionStore.upsertCheckpoint({
+                projectionName: this.projectionName,
+                lastEventId: latestEvent?.eventId,
+                lastEventTime: latestEvent?.occurredAt,
+                lastRebuildAt: previousRebuildAt ?? Date.now(),
+                lastFullCount: this.runtimeStore.getStateCount(),
+                status: 'ready',
+                metadata: { mode: 'incremental_replay', replayedEventCount: 0 }
+            });
+            return;
+        }
+        logger.info(`Replaying runtime projection events: count=${events.length}`);
+        for (const event of events) {
+            this.applyEvent(event);
+            await Promise.resolve();
+        }
+        const lastEvent = events[events.length - 1];
+        this.projectionStore.upsertCheckpoint({
+            projectionName: this.projectionName,
+            lastEventId: lastEvent?.eventId,
+            lastEventTime: lastEvent?.occurredAt,
+            lastRebuildAt: previousRebuildAt ?? Date.now(),
+            lastFullCount: this.runtimeStore.getStateCount(),
+            status: 'ready',
+            metadata: {
+                mode: 'incremental_replay',
+                replayedEventCount: events.length
+            }
+        });
+    }
+    applyEvent(event) {
+        const payload = (event.payload || {});
+        switch (event.eventType) {
+            case 'RUNTIME_STATE_UPDATED':
+                if (!payload.runtimeId || !payload.entityType || !payload.entityKey || !payload.status)
+                    return;
+                this.runtimeStore.upsertState({
+                    runtimeId: String(payload.runtimeId),
+                    entityType: String(payload.entityType),
+                    entityKey: String(payload.entityKey),
+                    status: String(payload.status),
+                    metadata: payload.metadata || undefined,
+                    updatedAt: event.occurredAt
+                }, { emitEvent: false });
+                return;
+            case 'RUNTIME_TRANSITION_RECORDED':
+                if (!payload.runtimeId || !payload.entityType || !payload.entityKey || !payload.transitionType || !payload.toStatus)
+                    return;
+                this.runtimeStore.recordTransition({
+                    runtimeId: String(payload.runtimeId),
+                    entityType: String(payload.entityType),
+                    entityKey: String(payload.entityKey),
+                    transitionType: String(payload.transitionType),
+                    fromStatus: payload.fromStatus ? String(payload.fromStatus) : undefined,
+                    toStatus: String(payload.toStatus),
+                    payload: payload.data || undefined,
+                    occurredAt: event.occurredAt
+                }, { emitEvent: false });
+                return;
+            default:
+                return;
+        }
+    }
+    isRuntimeEvent(event) {
+        return event.eventType === 'RUNTIME_STATE_UPDATED'
+            || event.eventType === 'RUNTIME_TRANSITION_RECORDED';
+    }
+}

package/dist/store/SqliteVecStore.d.ts

@@ -0,0 +1,25 @@
+import type Database from 'bun:sqlite';
+import type { IVectorStore, VectorSearchResult, VectorStoreStats } from './IVectorStore.js';
+export declare class SqliteVecStore implements IVectorStore {
+    private readonly db;
+    private readonly dimension;
+    constructor(db: Database, dimension?: number);
+    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>;
+    private initSchema;
+    private assertDimension;
+}
+//# sourceMappingURL=SqliteVecStore.d.ts.map