cognitive-core 0.2.5 → 0.3.1

package/src/persistence/sqlite-persistence.ts

@@ -1,925 +0,0 @@
-/**
- * SqlitePersistence — Unified SQLite database for all system-internal state.
- *
- * Single database file at `{baseDir}/cognitive-core.db` (configurable).
- * Replaces JsonStore/PartitionedStore for system-internal data.
- *
- * Agent-accessible data (knowledge notes, published skills) stays as files.
- * This DB is the system's internal brain — experiences, playbooks, causal edges,
- * meta state, routing weights, vector embeddings.
- */
-
-import Database from 'better-sqlite3';
-import { join } from 'node:path';
-import { mkdirSync, existsSync } from 'node:fs';
-import { toISO, toJSON, fromJSON, toInt, fromInt, embeddingToBlob, blobToEmbedding, fromISO } from './serializers.js';
-import type { Experience } from '../types/memory.js';
-import type { Playbook } from '../types/playbook.js';
-import type { ReflexionEpisode } from '../types/memory.js';
-import type { MetaObservation, MetaStrategy } from '../types/meta.js';
-
-// Re-export serializers for use by consumers
-export { toISO, toJSON, fromJSON, toInt, fromInt, embeddingToBlob, blobToEmbedding, fromISO };
-
-/**
- * Configuration for SqlitePersistence
- */
-export interface SqlitePersistenceConfig {
-  /** Base directory for storage (default: '.atlas') */
-  baseDir: string;
-  /** Database filename (default: 'cognitive-core.db') */
-  dbName: string;
-  /** Enable WAL mode (default: true) */
-  enableWAL?: boolean;
-  /** Embedding dimension for sqlite-vec (0 = skip vector table) */
-  vectorDimension?: number;
-}
-
-const DEFAULT_CONFIG: SqlitePersistenceConfig = {
-  baseDir: '.atlas',
-  dbName: 'cognitive-core.db',
-  enableWAL: true,
-  vectorDimension: 0,
-};
-
-// ============================================================================
-// Row types (SQLite representation)
-// ============================================================================
-
-export interface ExperienceRow {
-  id: string;
-  task_input: string;
-  solution_output: string;
-  feedback: string;
-  success: number;
-  domain: string;
-  embedding: Buffer | null;
-  trajectory_id: string;
-  usage_count: number;
-  access_score: number;
-  retrieval_count: number;
-  tier: string;
-  compressed: string | null;
-  metadata: string;
-  created_at: string;
-  last_accessed_at: string | null;
-}
-
-export interface PlaybookRow {
-  id: string;
-  name: string;
-  confidence: number;
-  complexity: string;
-  estimated_effort: number;
-  primary_domain: string | null;
-  success_count: number;
-  failure_count: number;
-  version: string;
-  origin: string | null;
-  applicability: string;
-  guidance: string;
-  verification: string;
-  evolution: string;
-  provenance: string | null;
-  embedding: Buffer | null;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface ReflexionRow {
-  id: string;
-  trajectory_id: string;
-  task_summary: string;
-  outcome: string;
-  self_critique: string;
-  key_insights: string;
-  strategy_assessment: string;
-  suggested_playbook_updates: string;
-  domain: string;
-  created_at: string;
-}
-
-export interface CausalEdgeRow {
-  id: string;
-  cause: string;
-  effect: string;
-  confidence: number;
-  domain: string;
-  source_trajectory_ids: string;
-  observed_count: number;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface MetaObservationRow {
-  id: string;
-  trajectory_id: string;
-  routing: string;
-  memory_usage: string;
-  execution: string;
-  outcome: string;
-  lessons: string;
-  routing_decision: string;
-  outcome_success: number;
-  timestamp: string;
-}
-
-export interface MetaStrategyRow {
-  id: string;
-  name: string;
-  condition: string;
-  adjustment: string;
-  application_count: number;
-  success_rate: number;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface SystemStateRow {
-  key: string;
-  value: string;
-  updated_at: string;
-}
-
-// ============================================================================
-// SqlitePersistence class
-// ============================================================================
-
-export class SqlitePersistence {
-  private db!: Database.Database;
-  private config: SqlitePersistenceConfig;
-  private initialized = false;
-
-  // Cached prepared statements (lazy-initialized)
-  private stmts: Record<string, Database.Statement> = {};
-
-  constructor(config?: Partial<SqlitePersistenceConfig>) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Initialize: open DB, run schema DDL, run migration if needed.
-   */
-  async init(): Promise<void> {
-    if (this.initialized) return;
-
-    const dir = this.config.baseDir;
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-
-    const dbPath = join(dir, this.config.dbName);
-    this.db = new Database(dbPath);
-
-    // PRAGMAs
-    if (this.config.enableWAL) {
-      this.db.pragma('journal_mode = WAL');
-    }
-    this.db.pragma('foreign_keys = ON');
-    this.db.pragma('busy_timeout = 5000');
-
-    this.createSchema();
-    this.initialized = true;
-  }
-
-  /**
-   * Get the raw database connection (for SqliteVectorStore sharing).
-   */
-  getDatabase(): Database.Database {
-    if (!this.initialized) throw new Error('SqlitePersistence not initialized');
-    return this.db;
-  }
-
-  /**
-   * Run a function inside a transaction.
-   */
-  transaction<T>(fn: () => T): T {
-    const tx = this.db.transaction(fn);
-    return tx();
-  }
-
-  // ==========================================================================
-  // Schema DDL
-  // ==========================================================================
-
-  private createSchema(): void {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS experiences (
-        id               TEXT PRIMARY KEY,
-        task_input       TEXT NOT NULL,
-        solution_output  TEXT NOT NULL,
-        feedback         TEXT NOT NULL,
-        success          INTEGER NOT NULL,
-        domain           TEXT NOT NULL,
-        embedding        BLOB,
-        trajectory_id    TEXT NOT NULL,
-        usage_count      INTEGER NOT NULL DEFAULT 0,
-        access_score     REAL NOT NULL DEFAULT 0,
-        retrieval_count  INTEGER NOT NULL DEFAULT 0,
-        tier             TEXT NOT NULL DEFAULT 'hot',
-        compressed       TEXT,
-        metadata         TEXT NOT NULL DEFAULT '{}',
-        created_at       TEXT NOT NULL,
-        last_accessed_at TEXT
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_experiences_domain ON experiences(domain);
-      CREATE INDEX IF NOT EXISTS idx_experiences_trajectory ON experiences(trajectory_id);
-      CREATE INDEX IF NOT EXISTS idx_experiences_success ON experiences(success);
-      CREATE INDEX IF NOT EXISTS idx_experiences_tier ON experiences(tier);
-      CREATE INDEX IF NOT EXISTS idx_experiences_access_score ON experiences(access_score);
-      CREATE INDEX IF NOT EXISTS idx_experiences_created_at ON experiences(created_at);
-
-      CREATE TABLE IF NOT EXISTS playbooks (
-        id                TEXT PRIMARY KEY,
-        name              TEXT NOT NULL,
-        confidence        REAL NOT NULL DEFAULT 0.3,
-        complexity        TEXT NOT NULL DEFAULT 'moderate',
-        estimated_effort  INTEGER NOT NULL DEFAULT 3,
-        primary_domain    TEXT,
-        success_count     INTEGER NOT NULL DEFAULT 0,
-        failure_count     INTEGER NOT NULL DEFAULT 0,
-        version           TEXT NOT NULL DEFAULT '1.0.0',
-        origin            TEXT,
-        applicability     TEXT NOT NULL,
-        guidance          TEXT NOT NULL,
-        verification      TEXT NOT NULL DEFAULT '{}',
-        evolution         TEXT NOT NULL DEFAULT '{}',
-        provenance        TEXT,
-        embedding         BLOB,
-        created_at        TEXT NOT NULL,
-        updated_at        TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_playbooks_name ON playbooks(name);
-      CREATE INDEX IF NOT EXISTS idx_playbooks_confidence ON playbooks(confidence);
-      CREATE INDEX IF NOT EXISTS idx_playbooks_primary_domain ON playbooks(primary_domain);
-      CREATE INDEX IF NOT EXISTS idx_playbooks_origin ON playbooks(origin);
-
-      CREATE TABLE IF NOT EXISTS playbook_versions (
-        playbook_id   TEXT NOT NULL,
-        version       TEXT NOT NULL,
-        playbook_snapshot TEXT NOT NULL,
-        changelog     TEXT NOT NULL DEFAULT '',
-        created_at    TEXT NOT NULL,
-        PRIMARY KEY (playbook_id, version)
-      );
-
-      CREATE TABLE IF NOT EXISTS reflexion_episodes (
-        id                         TEXT PRIMARY KEY,
-        trajectory_id              TEXT NOT NULL,
-        task_summary               TEXT NOT NULL,
-        outcome                    TEXT NOT NULL,
-        self_critique              TEXT NOT NULL,
-        key_insights               TEXT NOT NULL DEFAULT '[]',
-        strategy_assessment        TEXT NOT NULL,
-        suggested_playbook_updates TEXT NOT NULL DEFAULT '[]',
-        domain                     TEXT NOT NULL,
-        created_at                 TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_reflexion_trajectory ON reflexion_episodes(trajectory_id);
-      CREATE INDEX IF NOT EXISTS idx_reflexion_domain ON reflexion_episodes(domain);
-      CREATE INDEX IF NOT EXISTS idx_reflexion_outcome ON reflexion_episodes(outcome);
-      CREATE INDEX IF NOT EXISTS idx_reflexion_created_at ON reflexion_episodes(created_at);
-
-      CREATE TABLE IF NOT EXISTS causal_edges (
-        id                     TEXT PRIMARY KEY,
-        cause                  TEXT NOT NULL,
-        effect                 TEXT NOT NULL,
-        confidence             REAL NOT NULL,
-        domain                 TEXT NOT NULL,
-        source_trajectory_ids  TEXT NOT NULL DEFAULT '[]',
-        observed_count         INTEGER NOT NULL DEFAULT 1,
-        created_at             TEXT NOT NULL,
-        updated_at             TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_causal_domain ON causal_edges(domain);
-      CREATE INDEX IF NOT EXISTS idx_causal_confidence ON causal_edges(confidence);
-
-      CREATE TABLE IF NOT EXISTS meta_observations (
-        id              TEXT PRIMARY KEY,
-        trajectory_id   TEXT NOT NULL,
-        routing         TEXT NOT NULL,
-        memory_usage    TEXT NOT NULL,
-        execution       TEXT NOT NULL,
-        outcome         TEXT NOT NULL,
-        lessons         TEXT NOT NULL,
-        routing_decision TEXT NOT NULL,
-        outcome_success  INTEGER NOT NULL,
-        timestamp       TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_meta_obs_trajectory ON meta_observations(trajectory_id);
-      CREATE INDEX IF NOT EXISTS idx_meta_obs_routing ON meta_observations(routing_decision);
-      CREATE INDEX IF NOT EXISTS idx_meta_obs_outcome ON meta_observations(outcome_success);
-      CREATE INDEX IF NOT EXISTS idx_meta_obs_timestamp ON meta_observations(timestamp);
-
-      CREATE TABLE IF NOT EXISTS meta_strategies (
-        id                TEXT PRIMARY KEY,
-        name              TEXT NOT NULL UNIQUE,
-        condition         TEXT NOT NULL,
-        adjustment        TEXT NOT NULL,
-        application_count INTEGER NOT NULL DEFAULT 0,
-        success_rate      REAL NOT NULL DEFAULT 0,
-        created_at        TEXT NOT NULL,
-        updated_at        TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_meta_strategies_name ON meta_strategies(name);
-
-      CREATE TABLE IF NOT EXISTS system_state (
-        key        TEXT PRIMARY KEY,
-        value      TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS schema_version (
-        version    INTEGER NOT NULL,
-        applied_at TEXT NOT NULL
-      );
-    `);
-  }
-
-  // ==========================================================================
-  // Prepared statement helpers
-  // ==========================================================================
-
-  private stmt(name: string, sql: string): Database.Statement {
-    if (!this.stmts[name]) {
-      this.stmts[name] = this.db.prepare(sql);
-    }
-    return this.stmts[name];
-  }
-
-  // ==========================================================================
-  // Schema version
-  // ==========================================================================
-
-  getSchemaVersion(): number {
-    const row = this.db.prepare(
-      'SELECT MAX(version) as version FROM schema_version'
-    ).get() as { version: number | null } | undefined;
-    return row?.version ?? 0;
-  }
-
-  setSchemaVersion(version: number): void {
-    this.stmt('set_schema_version',
-      'INSERT INTO schema_version (version, applied_at) VALUES (?, ?)'
-    ).run(version, new Date().toISOString());
-  }
-
-  // ==========================================================================
-  // Experiences CRUD
-  // ==========================================================================
-
-  insertExperience(exp: Experience): void {
-    this.stmt('insert_experience', `
-      INSERT OR REPLACE INTO experiences
-        (id, task_input, solution_output, feedback, success, domain, embedding,
-         trajectory_id, usage_count, access_score, retrieval_count, tier,
-         compressed, metadata, created_at, last_accessed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      exp.id, exp.taskInput, exp.solutionOutput, exp.feedback,
-      toInt(exp.success), exp.domain, embeddingToBlob(exp.embedding),
-      exp.trajectoryId, exp.usageCount, exp.accessScore, exp.retrievalCount,
-      exp.tier ?? 'hot', toJSON(exp.compressed), toJSON(exp.metadata),
-      toISO(exp.createdAt), toISO(exp.lastAccessedAt),
-    );
-  }
-
-  getExperience(id: string): ExperienceRow | undefined {
-    return this.stmt('get_experience',
-      'SELECT * FROM experiences WHERE id = ?'
-    ).get(id) as ExperienceRow | undefined;
-  }
-
-  getAllExperiences(): ExperienceRow[] {
-    return this.stmt('get_all_experiences',
-      'SELECT * FROM experiences'
-    ).all() as ExperienceRow[];
-  }
-
-  getExperiencesByDomain(domain: string): ExperienceRow[] {
-    return this.stmt('get_experiences_by_domain',
-      'SELECT * FROM experiences WHERE domain = ?'
-    ).all(domain) as ExperienceRow[];
-  }
-
-  getExperiencesByTrajectory(trajectoryId: string): ExperienceRow[] {
-    return this.stmt('get_experiences_by_trajectory',
-      'SELECT * FROM experiences WHERE trajectory_id = ?'
-    ).all(trajectoryId) as ExperienceRow[];
-  }
-
-  getExperienceIds(): Array<{ id: string; task_input: string }> {
-    return this.stmt('get_experience_ids',
-      'SELECT id, task_input FROM experiences'
-    ).all() as Array<{ id: string; task_input: string }>;
-  }
-
-  updateExperience(id: string, updates: Record<string, unknown>): void {
-    // Build dynamic UPDATE — only set provided fields
-    const setClauses: string[] = [];
-    const values: unknown[] = [];
-
-    for (const [key, value] of Object.entries(updates)) {
-      const col = camelToSnake(key);
-      setClauses.push(`${col} = ?`);
-      if (key === 'embedding') {
-        values.push(embeddingToBlob(value as number[]));
-      } else if (key === 'success') {
-        values.push(toInt(value as boolean));
-      } else if (value instanceof Date) {
-        values.push(toISO(value));
-      } else if (typeof value === 'object' && value !== null) {
-        values.push(toJSON(value));
-      } else {
-        values.push(value);
-      }
-    }
-
-    if (setClauses.length === 0) return;
-    values.push(id);
-
-    this.db.prepare(
-      `UPDATE experiences SET ${setClauses.join(', ')} WHERE id = ?`
-    ).run(...values);
-  }
-
-  deleteExperience(id: string): boolean {
-    const result = this.stmt('delete_experience',
-      'DELETE FROM experiences WHERE id = ?'
-    ).run(id);
-    return result.changes > 0;
-  }
-
-  deleteExperiencesWhere(whereClause: string, params: unknown[] = []): number {
-    const result = this.db.prepare(
-      `DELETE FROM experiences WHERE ${whereClause}`
-    ).run(...params);
-    return result.changes;
-  }
-
-  getExperienceCount(): number {
-    const row = this.stmt('count_experiences',
-      'SELECT COUNT(*) as count FROM experiences'
-    ).get() as { count: number };
-    return row.count;
-  }
-
-  // ==========================================================================
-  // Playbooks CRUD
-  // ==========================================================================
-
-  insertPlaybook(pb: Playbook): void {
-    this.stmt('insert_playbook', `
-      INSERT OR REPLACE INTO playbooks
-        (id, name, confidence, complexity, estimated_effort, primary_domain,
-         success_count, failure_count, version, origin,
-         applicability, guidance, verification, evolution, provenance,
-         embedding, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      pb.id, pb.name, pb.confidence, pb.complexity, pb.estimatedEffort,
-      pb.applicability.domains?.[0] ?? null,
-      pb.evolution.successCount, pb.evolution.failureCount,
-      pb.evolution.version, pb.provenance?.origin ?? null,
-      toJSON(pb.applicability), toJSON(pb.guidance),
-      toJSON(pb.verification), toJSON(pb.evolution),
-      pb.provenance ? toJSON(pb.provenance) : null, embeddingToBlob(pb.embedding),
-      toISO(pb.createdAt), toISO(pb.updatedAt),
-    );
-  }
-
-  getPlaybook(id: string): PlaybookRow | undefined {
-    return this.stmt('get_playbook',
-      'SELECT * FROM playbooks WHERE id = ?'
-    ).get(id) as PlaybookRow | undefined;
-  }
-
-  getAllPlaybooks(): PlaybookRow[] {
-    return this.stmt('get_all_playbooks',
-      'SELECT * FROM playbooks'
-    ).all() as PlaybookRow[];
-  }
-
-  getPlaybooksByDomain(domain: string): PlaybookRow[] {
-    return this.stmt('get_playbooks_by_domain',
-      'SELECT * FROM playbooks WHERE primary_domain = ?'
-    ).all(domain) as PlaybookRow[];
-  }
-
-  getPlaybookIds(): Array<{ id: string; applicability: string }> {
-    return this.stmt('get_playbook_ids',
-      'SELECT id, applicability FROM playbooks'
-    ).all() as Array<{ id: string; applicability: string }>;
-  }
-
-  updatePlaybook(id: string, updates: Record<string, unknown>): void {
-    const setClauses: string[] = [];
-    const values: unknown[] = [];
-
-    for (const [key, value] of Object.entries(updates)) {
-      const col = camelToSnake(key);
-      setClauses.push(`${col} = ?`);
-      if (key === 'embedding') {
-        values.push(embeddingToBlob(value as number[]));
-      } else if (value instanceof Date) {
-        values.push(toISO(value));
-      } else if (typeof value === 'object' && value !== null) {
-        values.push(toJSON(value));
-      } else {
-        values.push(value);
-      }
-    }
-
-    if (setClauses.length === 0) return;
-    values.push(id);
-
-    this.db.prepare(
-      `UPDATE playbooks SET ${setClauses.join(', ')} WHERE id = ?`
-    ).run(...values);
-  }
-
-  deletePlaybook(id: string): boolean {
-    const result = this.stmt('delete_playbook',
-      'DELETE FROM playbooks WHERE id = ?'
-    ).run(id);
-    return result.changes > 0;
-  }
-
-  getPlaybookCount(): number {
-    const row = this.stmt('count_playbooks',
-      'SELECT COUNT(*) as count FROM playbooks'
-    ).get() as { count: number };
-    return row.count;
-  }
-
-  /** Snapshot current playbook state for version history. */
-  snapshotPlaybookVersion(playbookId: string, version: string, changelog = ''): void {
-    const pb = this.getPlaybook(playbookId);
-    if (!pb) return;
-    this.stmt('snapshot_playbook_version', `
-      INSERT OR IGNORE INTO playbook_versions
-        (playbook_id, version, playbook_snapshot, changelog, created_at)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(playbookId, version, JSON.stringify(pb), changelog, new Date().toISOString());
-  }
-
-  getPlaybookVersions(playbookId: string): Array<{
-    playbook_id: string;
-    version: string;
-    playbook_snapshot: string;
-    changelog: string;
-    created_at: string;
-  }> {
-    return this.stmt('get_playbook_versions',
-      'SELECT * FROM playbook_versions WHERE playbook_id = ? ORDER BY created_at ASC'
-    ).all(playbookId) as Array<{
-      playbook_id: string;
-      version: string;
-      playbook_snapshot: string;
-      changelog: string;
-      created_at: string;
-    }>;
-  }
-
-  // ==========================================================================
-  // Reflexion Episodes CRUD
-  // ==========================================================================
-
-  insertReflexionEpisode(ep: ReflexionEpisode): void {
-    this.stmt('insert_reflexion', `
-      INSERT OR REPLACE INTO reflexion_episodes
-        (id, trajectory_id, task_summary, outcome, self_critique,
-         key_insights, strategy_assessment, suggested_playbook_updates,
-         domain, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      ep.id, ep.trajectoryId, ep.taskSummary, ep.outcome,
-      ep.selfCritique, toJSON(ep.keyInsights, '[]'),
-      ep.strategyAssessment, toJSON(ep.suggestedPlaybookUpdates, '[]'),
-      ep.domain, toISO(ep.createdAt),
-    );
-  }
-
-  getReflexionEpisode(id: string): ReflexionRow | undefined {
-    return this.stmt('get_reflexion',
-      'SELECT * FROM reflexion_episodes WHERE id = ?'
-    ).get(id) as ReflexionRow | undefined;
-  }
-
-  getReflexionEpisodes(options?: {
-    domain?: string;
-    outcome?: string;
-    limit?: number;
-  }): ReflexionRow[] {
-    let query = 'SELECT * FROM reflexion_episodes WHERE 1=1';
-    const params: unknown[] = [];
-
-    if (options?.domain) {
-      query += ' AND domain = ?';
-      params.push(options.domain);
-    }
-    if (options?.outcome) {
-      query += ' AND outcome = ?';
-      params.push(options.outcome);
-    }
-    query += ' ORDER BY created_at DESC';
-    if (options?.limit) {
-      query += ' LIMIT ?';
-      params.push(options.limit);
-    }
-
-    return this.db.prepare(query).all(...params) as ReflexionRow[];
-  }
-
-  getReflexionByTrajectory(trajectoryId: string): ReflexionRow[] {
-    return this.stmt('get_reflexion_by_trajectory',
-      'SELECT * FROM reflexion_episodes WHERE trajectory_id = ?'
-    ).all(trajectoryId) as ReflexionRow[];
-  }
-
-  // ==========================================================================
-  // Causal Edges CRUD
-  // ==========================================================================
-
-  insertCausalEdge(edge: {
-    id: string;
-    cause: string;
-    effect: string;
-    confidence: number;
-    domain: string;
-    sourceTrajectoryIds: string[];
-    observedCount: number;
-    createdAt: Date;
-    updatedAt: Date;
-  }): void {
-    this.stmt('insert_causal', `
-      INSERT OR REPLACE INTO causal_edges
-        (id, cause, effect, confidence, domain, source_trajectory_ids,
-         observed_count, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      edge.id, edge.cause, edge.effect, edge.confidence, edge.domain,
-      toJSON(edge.sourceTrajectoryIds, '[]'), edge.observedCount,
-      toISO(edge.createdAt), toISO(edge.updatedAt),
-    );
-  }
-
-  getCausalEdge(id: string): CausalEdgeRow | undefined {
-    return this.stmt('get_causal',
-      'SELECT * FROM causal_edges WHERE id = ?'
-    ).get(id) as CausalEdgeRow | undefined;
-  }
-
-  getAllCausalEdges(): CausalEdgeRow[] {
-    return this.stmt('get_all_causal',
-      'SELECT * FROM causal_edges'
-    ).all() as CausalEdgeRow[];
-  }
-
-  getCausalEdgesByDomain(domain: string): CausalEdgeRow[] {
-    return this.stmt('get_causal_by_domain',
-      'SELECT * FROM causal_edges WHERE domain = ?'
-    ).all(domain) as CausalEdgeRow[];
-  }
-
-  getCausalEdgeIds(): Array<{ id: string; cause: string; effect: string }> {
-    return this.stmt('get_causal_ids',
-      'SELECT id, cause, effect FROM causal_edges'
-    ).all() as Array<{ id: string; cause: string; effect: string }>;
-  }
-
-  updateCausalEdge(id: string, updates: Record<string, unknown>): void {
-    const setClauses: string[] = [];
-    const values: unknown[] = [];
-
-    for (const [key, value] of Object.entries(updates)) {
-      const col = camelToSnake(key);
-      setClauses.push(`${col} = ?`);
-      if (value instanceof Date) {
-        values.push(toISO(value));
-      } else if (typeof value === 'object' && value !== null) {
-        values.push(toJSON(value));
-      } else {
-        values.push(value);
-      }
-    }
-
-    if (setClauses.length === 0) return;
-    values.push(id);
-
-    this.db.prepare(
-      `UPDATE causal_edges SET ${setClauses.join(', ')} WHERE id = ?`
-    ).run(...values);
-  }
-
-  deleteCausalEdge(id: string): boolean {
-    const result = this.stmt('delete_causal',
-      'DELETE FROM causal_edges WHERE id = ?'
-    ).run(id);
-    return result.changes > 0;
-  }
-
-  // ==========================================================================
-  // Meta Observations CRUD
-  // ==========================================================================
-
-  insertMetaObservation(obs: MetaObservation): void {
-    this.stmt('insert_meta_obs', `
-      INSERT OR REPLACE INTO meta_observations
-        (id, trajectory_id, routing, memory_usage, execution, outcome,
-         lessons, routing_decision, outcome_success, timestamp)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      obs.id, obs.trajectoryId,
-      toJSON(obs.routing), toJSON(obs.memoryUsage),
-      toJSON(obs.execution), toJSON(obs.outcome),
-      toJSON(obs.lessons),
-      obs.routing.decision, toInt(obs.outcome.success),
-      toISO(obs.timestamp),
-    );
-  }
-
-  getMetaObservation(id: string): MetaObservationRow | undefined {
-    return this.stmt('get_meta_obs',
-      'SELECT * FROM meta_observations WHERE id = ?'
-    ).get(id) as MetaObservationRow | undefined;
-  }
-
-  getAllMetaObservations(): MetaObservationRow[] {
-    return this.stmt('get_all_meta_obs',
-      'SELECT * FROM meta_observations ORDER BY timestamp DESC'
-    ).all() as MetaObservationRow[];
-  }
-
-  getMetaObservationsByRouting(decision: string): MetaObservationRow[] {
-    return this.stmt('get_meta_obs_by_routing',
-      'SELECT * FROM meta_observations WHERE routing_decision = ? ORDER BY timestamp DESC'
-    ).all(decision) as MetaObservationRow[];
-  }
-
-  deleteMetaObservationsBefore(cutoffDate: Date): number {
-    const result = this.stmt('delete_meta_obs_before',
-      'DELETE FROM meta_observations WHERE timestamp < ?'
-    ).run(toISO(cutoffDate));
-    return result.changes;
-  }
-
-  getMetaObservationCount(): number {
-    const row = this.stmt('count_meta_obs',
-      'SELECT COUNT(*) as count FROM meta_observations'
-    ).get() as { count: number };
-    return row.count;
-  }
-
-  /** Aggregate routing effectiveness: { decision: { total, successful } } */
-  aggregateRoutingEffectiveness(): Record<string, { total: number; successful: number }> {
-    const rows = this.db.prepare(`
-      SELECT routing_decision, COUNT(*) as total, SUM(outcome_success) as successful
-      FROM meta_observations
-      GROUP BY routing_decision
-    `).all() as Array<{ routing_decision: string; total: number; successful: number }>;
-
-    const result: Record<string, { total: number; successful: number }> = {};
-    for (const row of rows) {
-      result[row.routing_decision] = { total: row.total, successful: row.successful };
-    }
-    return result;
-  }
-
-  // ==========================================================================
-  // Meta Strategies CRUD
-  // ==========================================================================
-
-  insertMetaStrategy(strategy: MetaStrategy): void {
-    this.stmt('insert_meta_strategy', `
-      INSERT OR REPLACE INTO meta_strategies
-        (id, name, condition, adjustment, application_count, success_rate,
-         created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      strategy.id, strategy.name,
-      toJSON(strategy.condition), toJSON(strategy.adjustment),
-      strategy.applicationCount, strategy.successRate,
-      toISO(strategy.createdAt), toISO(strategy.updatedAt),
-    );
-  }
-
-  getMetaStrategy(id: string): MetaStrategyRow | undefined {
-    return this.stmt('get_meta_strategy',
-      'SELECT * FROM meta_strategies WHERE id = ?'
-    ).get(id) as MetaStrategyRow | undefined;
-  }
-
-  getMetaStrategyByName(name: string): MetaStrategyRow | undefined {
-    return this.stmt('get_meta_strategy_by_name',
-      'SELECT * FROM meta_strategies WHERE name = ?'
-    ).get(name) as MetaStrategyRow | undefined;
-  }
-
-  getAllMetaStrategies(): MetaStrategyRow[] {
-    return this.stmt('get_all_meta_strategies',
-      'SELECT * FROM meta_strategies'
-    ).all() as MetaStrategyRow[];
-  }
-
-  updateMetaStrategy(id: string, updates: Record<string, unknown>): void {
-    const setClauses: string[] = [];
-    const values: unknown[] = [];
-
-    for (const [key, value] of Object.entries(updates)) {
-      const col = camelToSnake(key);
-      setClauses.push(`${col} = ?`);
-      if (value instanceof Date) {
-        values.push(toISO(value));
-      } else if (typeof value === 'object' && value !== null) {
-        values.push(toJSON(value));
-      } else {
-        values.push(value);
-      }
-    }
-
-    if (setClauses.length === 0) return;
-    values.push(id);
-
-    this.db.prepare(
-      `UPDATE meta_strategies SET ${setClauses.join(', ')} WHERE id = ?`
-    ).run(...values);
-  }
-
-  deleteMetaStrategy(id: string): boolean {
-    const result = this.stmt('delete_meta_strategy',
-      'DELETE FROM meta_strategies WHERE id = ?'
-    ).run(id);
-    return result.changes > 0;
-  }
-
-  // ==========================================================================
-  // System State (key-value store for singleton blobs)
-  // ==========================================================================
-
-  getSystemState<T>(key: string): T | undefined {
-    const row = this.stmt('get_system_state',
-      'SELECT value FROM system_state WHERE key = ?'
-    ).get(key) as SystemStateRow | undefined;
-    if (!row) return undefined;
-    return fromJSON<T>(row.value);
-  }
-
-  setSystemState<T>(key: string, value: T): void {
-    this.stmt('set_system_state', `
-      INSERT OR REPLACE INTO system_state (key, value, updated_at)
-      VALUES (?, ?, ?)
-    `).run(key, toJSON(value), new Date().toISOString());
-  }
-
-  deleteSystemState(key: string): boolean {
-    const result = this.stmt('delete_system_state',
-      'DELETE FROM system_state WHERE key = ?'
-    ).run(key);
-    return result.changes > 0;
-  }
-
-  // ==========================================================================
-  // Lifecycle
-  // ==========================================================================
-
-  close(): void {
-    if (this.db) {
-      this.db.close();
-    }
-    this.initialized = false;
-    this.stmts = {};
-  }
-
-  get isInitialized(): boolean {
-    return this.initialized;
-  }
-
-  get dbPath(): string {
-    return join(this.config.baseDir, this.config.dbName);
-  }
-}
-
-// ============================================================================
-// Factory function
-// ============================================================================
-
-export function createSqlitePersistence(
-  config?: Partial<SqlitePersistenceConfig>
-): SqlitePersistence {
-  return new SqlitePersistence(config);
-}
-
-// ============================================================================
-// Utility: camelCase to snake_case
-// ============================================================================
-
-function camelToSnake(str: string): string {
-  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}