@cortexa/core 0.7.0

package/dist/index.js

@@ -0,0 +1,4805 @@
+import {
+  createLogger
+} from "./chunk-T4NUBJ7T.js";
+
+// src/index.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/connectors/postgres.ts
+import pg from "pg";
+var { Pool } = pg;
+var PostgresConnector = class {
+  pool = null;
+  async connect(config) {
+    if (config.url) {
+      this.pool = new Pool({ connectionString: config.url });
+    } else {
+      this.pool = new Pool({
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.user,
+        password: config.password
+      });
+    }
+    const client = await this.pool.connect();
+    client.release();
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getTableCount() {
+    this.ensureConnected();
+    const result = await this.pool.query(
+      `SELECT COUNT(*) as count FROM information_schema.tables
+       WHERE table_schema = 'public' AND table_type = 'BASE TABLE'`
+    );
+    return parseInt(result.rows[0].count, 10);
+  }
+  async getDatabaseName() {
+    this.ensureConnected();
+    const result = await this.pool.query("SELECT current_database() as db");
+    return result.rows[0].db;
+  }
+  async isReadOnly() {
+    this.ensureConnected();
+    try {
+      await this.pool.query(
+        "CREATE TEMP TABLE _cortexa_ro_check (id int)"
+      );
+      return false;
+    } catch {
+      return true;
+    } finally {
+      try {
+        await this.pool.query(
+          "DROP TABLE IF EXISTS _cortexa_ro_check"
+        );
+      } catch {
+      }
+    }
+  }
+  async query(sql, params) {
+    this.ensureConnected();
+    const result = await this.pool.query(sql, params);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount ?? result.rows.length
+    };
+  }
+  isConnected() {
+    return this.pool !== null;
+  }
+  ensureConnected() {
+    if (!this.pool) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+  }
+};
+
+// src/connectors/mysql.ts
+import mysql from "mysql2/promise";
+var MySQLConnector = class {
+  pool = null;
+  async connect(config) {
+    if (config.url) {
+      this.pool = mysql.createPool(config.url);
+    } else {
+      this.pool = mysql.createPool({
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.user,
+        password: config.password
+      });
+    }
+    const conn = await this.pool.getConnection();
+    conn.release();
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  async getTableCount() {
+    this.ensureConnected();
+    const [rows] = await this.pool.query(
+      `SELECT COUNT(*) as count FROM information_schema.tables
+       WHERE table_schema = DATABASE() AND table_type = 'BASE TABLE'`
+    );
+    return rows[0].count;
+  }
+  async getDatabaseName() {
+    this.ensureConnected();
+    const [rows] = await this.pool.query("SELECT DATABASE() as db");
+    return rows[0].db;
+  }
+  async isReadOnly() {
+    this.ensureConnected();
+    try {
+      await this.pool.query(
+        "CREATE TEMPORARY TABLE _cortexa_ro_check (id INT)"
+      );
+      return false;
+    } catch {
+      return true;
+    } finally {
+      try {
+        await this.pool.query(
+          "DROP TEMPORARY TABLE IF EXISTS _cortexa_ro_check"
+        );
+      } catch {
+      }
+    }
+  }
+  async query(sql, params) {
+    this.ensureConnected();
+    const mysqlSql = sql.replace(/\$\d+/g, "?");
+    const [rows] = await this.pool.query(mysqlSql, params);
+    const rowArray = rows;
+    return {
+      rows: rowArray,
+      rowCount: rowArray.length
+    };
+  }
+  isConnected() {
+    return this.pool !== null;
+  }
+  ensureConnected() {
+    if (!this.pool) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+  }
+};
+
+// src/connectors/sqlite.ts
+import path from "path";
+import Database from "better-sqlite3";
+var SQLiteConnector = class {
+  db = null;
+  dbPath = "";
+  async connect(config) {
+    this.dbPath = config.path ?? config.database ?? ":memory:";
+    this.db = new Database(this.dbPath, { readonly: true });
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  async getTableCount() {
+    this.ensureConnected();
+    const row = this.db.prepare(
+      `SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`
+    ).get();
+    return row.count;
+  }
+  async getDatabaseName() {
+    return path.basename(this.dbPath, path.extname(this.dbPath));
+  }
+  async isReadOnly() {
+    return true;
+  }
+  async query(sql, params) {
+    this.ensureConnected();
+    const convertedSql = sql.replace(/\$(\d+)/g, "?");
+    const stmt = this.db.prepare(convertedSql);
+    if (convertedSql.trim().toUpperCase().startsWith("SELECT") || convertedSql.trim().toUpperCase().startsWith("PRAGMA")) {
+      const rows = params && params.length > 0 ? stmt.all(...params) : stmt.all();
+      return { rows, rowCount: rows.length };
+    }
+    const result = params && params.length > 0 ? stmt.run(...params) : stmt.run();
+    return { rows: [], rowCount: result.changes };
+  }
+  isConnected() {
+    return this.db !== null;
+  }
+  ensureConnected() {
+    if (!this.db) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+  }
+};
+
+// src/core/connection.ts
+async function createConnector(type) {
+  switch (type) {
+    case "postgres":
+    case "cockroachdb":
+      return new PostgresConnector();
+    case "mysql":
+    case "mariadb":
+      return new MySQLConnector();
+    case "sqlite":
+      return new SQLiteConnector();
+    case "mongodb": {
+      const { MongoDBConnector } = await import("./mongodb-M5UGJZTC.js");
+      return new MongoDBConnector();
+    }
+    case "mssql": {
+      const { MSSQLConnector } = await import("./mssql-I27XEHQ2.js");
+      return new MSSQLConnector();
+    }
+    default:
+      throw new Error(`Unsupported database type: ${type}`);
+  }
+}
+
+// src/core/storage.ts
+import Database2 from "better-sqlite3";
+import fs from "fs";
+import path2 from "path";
+var CortexaStorage = class {
+  db = null;
+  cortexaDir;
+  dbPath;
+  constructor(projectRoot) {
+    this.cortexaDir = path2.join(projectRoot, ".cortexa");
+    this.dbPath = path2.join(this.cortexaDir, "cortexa.db");
+  }
+  initialize() {
+    fs.mkdirSync(this.cortexaDir, { recursive: true });
+    this.db = new Database2(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.createSchema();
+  }
+  setMeta(key, value) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)"
+    ).run(key, value);
+  }
+  getMeta(key) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT value FROM meta WHERE key = ?"
+    ).get(key);
+    return row?.value;
+  }
+  getDiscoveredTableCount() {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT COUNT(*) as count FROM discovered_tables"
+    ).get();
+    return row.count;
+  }
+  saveEntity(entity) {
+    this.ensureInitialized();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO entities
+       (table_name, entity_label, entity_type, description, confidence, columns_classified)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(entity.tableName, entity.entityLabel, entity.entityType, entity.description, entity.confidence, JSON.stringify(entity.columns));
+  }
+  getEntities() {
+    this.ensureInitialized();
+    const rows = this.db.prepare("SELECT * FROM entities").all();
+    return rows.map((row) => ({
+      tableName: row.table_name,
+      entityLabel: row.entity_label,
+      entityType: row.entity_type,
+      description: row.description,
+      confidence: row.confidence,
+      columns: JSON.parse(row.columns_classified || "[]")
+    }));
+  }
+  getEntity(tableName) {
+    this.ensureInitialized();
+    const row = this.db.prepare("SELECT * FROM entities WHERE table_name = ?").get(tableName);
+    if (!row) return void 0;
+    return {
+      tableName: row.table_name,
+      entityLabel: row.entity_label,
+      entityType: row.entity_type,
+      description: row.description,
+      confidence: row.confidence,
+      columns: JSON.parse(row.columns_classified || "[]")
+    };
+  }
+  saveRelationship(rel) {
+    this.ensureInitialized();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO relationships
+       (source_entity, target_entity, relationship, source_column, target_column, inferred, confidence)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(rel.sourceEntity, rel.targetEntity, rel.relationship, rel.sourceColumn, rel.targetColumn, rel.inferred ? 1 : 0, rel.confidence);
+  }
+  getRelationships() {
+    this.ensureInitialized();
+    const rows = this.db.prepare("SELECT * FROM relationships").all();
+    return rows.map((row) => ({
+      sourceEntity: row.source_entity,
+      targetEntity: row.target_entity,
+      relationship: row.relationship,
+      sourceColumn: row.source_column,
+      targetColumn: row.target_column,
+      inferred: row.inferred === 1,
+      confidence: row.confidence
+    }));
+  }
+  clearRelationships() {
+    this.ensureInitialized();
+    this.db.prepare("DELETE FROM relationships").run();
+  }
+  saveDiscoveredTable(table) {
+    this.ensureInitialized();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO discovered_tables
+       (table_name, table_schema, row_count, columns_json, fk_json, indexes_json, sample_rows)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(table.tableName, table.tableSchema, table.rowCount, JSON.stringify(table.columns), JSON.stringify(table.foreignKeys), JSON.stringify(table.indexes), JSON.stringify(table.sampleRows));
+  }
+  setCache(key, response, model, tokensUsed) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO llm_cache (cache_key, response, model, tokens_used) VALUES (?, ?, ?, ?)"
+    ).run(key, response, model, tokensUsed);
+  }
+  getCache(key) {
+    this.ensureInitialized();
+    const row = this.db.prepare("SELECT response FROM llm_cache WHERE cache_key = ?").get(key);
+    return row?.response;
+  }
+  clearCache() {
+    this.ensureInitialized();
+    this.db.prepare("DELETE FROM llm_cache").run();
+  }
+  saveEvent(event) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT INTO events (event_type, entity, table_name, operation, row_id, row_data) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(event.eventType, event.entity, event.tableName, event.operation, event.rowId ?? null, event.rowData ?? null);
+  }
+  getEvents(filter) {
+    this.ensureInitialized();
+    let sql = "SELECT id, event_type, entity, table_name, operation, row_id, row_data, timestamp FROM events";
+    const conditions = [];
+    const params = [];
+    if (filter?.entity) {
+      conditions.push("entity = ?");
+      params.push(filter.entity);
+    }
+    if (filter?.last) {
+      conditions.push(`timestamp >= datetime('now', '-${filter.last} minutes')`);
+    }
+    if (filter?.operation) {
+      conditions.push("operation = ?");
+      params.push(filter.operation);
+    }
+    if (filter?.eventType) {
+      conditions.push("event_type = ?");
+      params.push(filter.eventType);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      eventType: r.event_type,
+      entity: r.entity,
+      tableName: r.table_name,
+      operation: r.operation,
+      rowId: r.row_id,
+      rowData: r.row_data,
+      timestamp: r.timestamp
+    }));
+  }
+  countEvents(entity, operation, lastMinutes) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as count FROM events WHERE entity = ? AND operation = ? AND timestamp >= datetime('now', '-' || ? || ' minutes')`
+    ).get(entity, operation, lastMinutes);
+    return row.count;
+  }
+  saveBaseline(baseline) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO baselines (entity, metric, mean, stddev, sample_size) VALUES (?, ?, ?, ?, ?)"
+    ).run(baseline.entity, baseline.metric, baseline.mean, baseline.stddev, baseline.sampleSize);
+  }
+  getBaselines() {
+    this.ensureInitialized();
+    const rows = this.db.prepare("SELECT entity, metric, mean, stddev, sample_size FROM baselines").all();
+    return rows.map((r) => ({
+      entity: r.entity,
+      metric: r.metric,
+      mean: r.mean,
+      stddev: r.stddev,
+      sampleSize: r.sample_size
+    }));
+  }
+  saveAnomaly(anomaly) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT INTO anomalies (entity, anomaly_type, severity, expected, actual, message) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(anomaly.entity, anomaly.anomalyType, anomaly.severity, anomaly.expected, anomaly.actual, anomaly.message);
+  }
+  getAnomalies(filter) {
+    this.ensureInitialized();
+    let sql = "SELECT id, entity, anomaly_type, severity, expected, actual, message, timestamp FROM anomalies";
+    const conditions = [];
+    const params = [];
+    if (filter?.last) {
+      conditions.push(`timestamp >= datetime('now', '-${filter.last} minutes')`);
+    }
+    if (filter?.entity) {
+      conditions.push("entity = ?");
+      params.push(filter.entity);
+    }
+    if (filter?.severity) {
+      conditions.push("severity = ?");
+      params.push(filter.severity);
+    }
+    if (filter?.anomalyType) {
+      conditions.push("anomaly_type = ?");
+      params.push(filter.anomalyType);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      entity: r.entity,
+      anomalyType: r.anomaly_type,
+      severity: r.severity,
+      expected: r.expected,
+      actual: r.actual,
+      message: r.message,
+      timestamp: r.timestamp
+    }));
+  }
+  saveWatermark(wm) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO watch_watermarks (table_name, table_schema, strategy, timestamp_column, pk_column, last_seen_value) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(wm.tableName, wm.tableSchema, wm.strategy, wm.timestampColumn ?? null, wm.pkColumn ?? null, wm.lastSeenValue ?? null);
+  }
+  getWatermark(tableName, tableSchema) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT strategy, timestamp_column, pk_column, last_seen_value FROM watch_watermarks WHERE table_name = ? AND table_schema = ?"
+    ).get(tableName, tableSchema);
+    if (!row) return void 0;
+    return {
+      strategy: row.strategy,
+      timestampColumn: row.timestamp_column,
+      pkColumn: row.pk_column,
+      lastSeenValue: row.last_seen_value
+    };
+  }
+  saveTransition(t) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT INTO state_transitions (entity, table_name, primary_key, from_state, to_state, duration_ms, expected) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    ).run(t.entity, t.tableName, t.primaryKey, t.fromState, t.toState, t.durationMs, t.expected ? 1 : 0);
+  }
+  getTransitions(filter) {
+    this.ensureInitialized();
+    let sql = "SELECT entity, table_name, primary_key, from_state, to_state, duration_ms, expected, timestamp FROM state_transitions";
+    const params = [];
+    if (filter?.entity) {
+      sql += " WHERE entity = ?";
+      params.push(filter.entity);
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      entity: r.entity,
+      tableName: r.table_name,
+      primaryKey: r.primary_key,
+      fromState: r.from_state,
+      toState: r.to_state,
+      durationMs: r.duration_ms,
+      expected: r.expected === 1,
+      timestamp: r.timestamp
+    }));
+  }
+  getTransitionStats(entity) {
+    this.ensureInitialized();
+    let sql = "SELECT entity, from_state, to_state, COUNT(*) as count, AVG(duration_ms) as avg_duration, MIN(duration_ms) as min_duration, MAX(duration_ms) as max_duration FROM state_transitions";
+    const params = [];
+    if (entity) {
+      sql += " WHERE entity = ?";
+      params.push(entity);
+    }
+    sql += " GROUP BY entity, from_state, to_state";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      entity: r.entity,
+      fromState: r.from_state,
+      toState: r.to_state,
+      count: r.count,
+      avgDurationMs: Math.round(r.avg_duration),
+      minDurationMs: r.min_duration,
+      maxDurationMs: r.max_duration
+    }));
+  }
+  saveInsight(i) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT INTO insights (entity, insight_type, severity, message, context_json) VALUES (?, ?, ?, ?, ?)"
+    ).run(i.entity, i.insightType, i.severity, i.message, JSON.stringify(i.context));
+  }
+  getInsights(filter) {
+    this.ensureInitialized();
+    let sql = "SELECT id, entity, insight_type, severity, message, context_json, timestamp FROM insights";
+    const conditions = [];
+    const params = [];
+    if (filter?.entity) {
+      conditions.push("entity = ?");
+      params.push(filter.entity);
+    }
+    if (filter?.last !== void 0) {
+      conditions.push("timestamp >= datetime('now', '-' || ? || ' minutes')");
+      params.push(filter.last);
+    }
+    if (filter?.insightType) {
+      conditions.push("insight_type = ?");
+      params.push(filter.insightType);
+    }
+    if (filter?.severity) {
+      conditions.push("severity = ?");
+      params.push(filter.severity);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      entity: r.entity,
+      insightType: r.insight_type,
+      severity: r.severity,
+      message: r.message,
+      context: JSON.parse(r.context_json || "{}"),
+      timestamp: r.timestamp
+    }));
+  }
+  getEventById(id) {
+    this.ensureInitialized();
+    const r = this.db.prepare("SELECT id, event_type, entity, table_name, operation, row_id, row_data, timestamp FROM events WHERE id = ?").get(id);
+    if (!r) return void 0;
+    return { id: r.id, eventType: r.event_type, entity: r.entity, tableName: r.table_name, operation: r.operation, rowId: r.row_id, rowData: r.row_data, timestamp: r.timestamp };
+  }
+  getAnomalyById(id) {
+    this.ensureInitialized();
+    const r = this.db.prepare("SELECT id, entity, anomaly_type, severity, expected, actual, message, timestamp FROM anomalies WHERE id = ?").get(id);
+    if (!r) return void 0;
+    return { id: r.id, entity: r.entity, anomalyType: r.anomaly_type, severity: r.severity, expected: r.expected, actual: r.actual, message: r.message, timestamp: r.timestamp };
+  }
+  getInsightById(id) {
+    this.ensureInitialized();
+    const r = this.db.prepare("SELECT id, entity, insight_type, severity, message, context_json, timestamp FROM insights WHERE id = ?").get(id);
+    if (!r) return void 0;
+    return { id: r.id, entity: r.entity, insightType: r.insight_type, severity: r.severity, message: r.message, context: JSON.parse(r.context_json || "{}"), timestamp: r.timestamp };
+  }
+  saveEntityState(s) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO entity_states (table_name, primary_key, state, entered_at) VALUES (?, ?, ?, ?)"
+    ).run(s.tableName, s.primaryKey, s.state, s.enteredAt);
+  }
+  getEntityState(tableName, primaryKey) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT state, entered_at FROM entity_states WHERE table_name = ? AND primary_key = ?"
+    ).get(tableName, primaryKey);
+    if (!row) return void 0;
+    return {
+      state: row.state,
+      enteredAt: row.entered_at
+    };
+  }
+  getStuckEntityStates(tableName, thresholdMs) {
+    this.ensureInitialized();
+    const thresholdSeconds = Math.floor(thresholdMs / 1e3);
+    const rows = this.db.prepare(
+      "SELECT primary_key, state, entered_at FROM entity_states WHERE table_name = ? AND entered_at <= datetime('now', '-' || ? || ' seconds')"
+    ).all(tableName, thresholdSeconds);
+    return rows.map((r) => ({
+      primaryKey: r.primary_key,
+      state: r.state,
+      enteredAt: r.entered_at
+    }));
+  }
+  saveCorrelationEvent(event) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT INTO correlation_events (entity, event_type, primary_key) VALUES (?, ?, ?)"
+    ).run(event.entity, event.eventType, event.primaryKey);
+  }
+  getCorrelationEvents(entity, lastMinutes) {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT entity, event_type, primary_key, timestamp FROM correlation_events WHERE entity = ? AND timestamp >= datetime('now', '-' || ? || ' minutes') ORDER BY timestamp DESC"
+    ).all(entity, lastMinutes);
+    return rows.map((r) => ({
+      entity: r.entity,
+      eventType: r.event_type,
+      primaryKey: r.primary_key,
+      timestamp: r.timestamp
+    }));
+  }
+  saveCorrelationRate(rate) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO correlation_rates (entity, bucket, event_count) VALUES (?, ?, ?)"
+    ).run(rate.entity, rate.bucket, rate.eventCount);
+  }
+  getCorrelationRates(entity, lastHours) {
+    this.ensureInitialized();
+    const cutoff = new Date(Date.now() - lastHours * 36e5).toISOString();
+    const rows = this.db.prepare(
+      "SELECT entity, bucket, event_count FROM correlation_rates WHERE entity = ? AND bucket >= ? ORDER BY bucket DESC"
+    ).all(entity, cutoff);
+    return rows.map((r) => ({
+      entity: r.entity,
+      bucket: r.bucket,
+      eventCount: r.event_count
+    }));
+  }
+  saveHistogramBucket(bucket) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO distribution_histograms (entity, column_name, bucket_key, count, period) VALUES (?, ?, ?, ?, ?)"
+    ).run(bucket.entity, bucket.columnName, bucket.bucketKey, bucket.count, bucket.period);
+  }
+  getHistogramBuckets(entity, columnName, period) {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT bucket_key, count FROM distribution_histograms WHERE entity = ? AND column_name = ? AND period = ? ORDER BY bucket_key"
+    ).all(entity, columnName, period);
+    return rows.map((r) => ({
+      bucketKey: r.bucket_key,
+      count: r.count
+    }));
+  }
+  saveTemporalPattern(pattern) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO temporal_patterns (entity, bucket_type, bucket_key, count, period) VALUES (?, ?, ?, ?, ?)"
+    ).run(pattern.entity, pattern.bucketType, pattern.bucketKey, pattern.count, pattern.period);
+  }
+  getTemporalPatterns(entity, bucketType, period) {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT bucket_key, count FROM temporal_patterns WHERE entity = ? AND bucket_type = ? AND period = ? ORDER BY bucket_key"
+    ).all(entity, bucketType, period);
+    return rows.map((r) => ({
+      bucketKey: r.bucket_key,
+      count: r.count
+    }));
+  }
+  saveAnalyticsBaseline(baseline) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "INSERT OR REPLACE INTO analytics_baselines (key, mean, stddev, sample_size) VALUES (?, ?, ?, ?)"
+    ).run(baseline.key, baseline.mean, baseline.stddev, baseline.sampleSize);
+  }
+  getAnalyticsBaseline(key) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT mean, stddev, sample_size FROM analytics_baselines WHERE key = ?"
+    ).get(key);
+    if (!row) return void 0;
+    return {
+      mean: row.mean,
+      stddev: row.stddev,
+      sampleSize: row.sample_size
+    };
+  }
+  // ── Knowledge Graph ──────────────────────────────────────────
+  saveKgNode(node) {
+    this.ensureInitialized();
+    const info = this.db.prepare(
+      `INSERT INTO kg_nodes (node_type, ref_id, label, metadata) VALUES (?, ?, ?, ?)
+       ON CONFLICT(node_type, ref_id) DO UPDATE SET label = excluded.label, metadata = excluded.metadata, timestamp = datetime('now')`
+    ).run(node.nodeType, node.refId, node.label, node.metadata);
+    if (info.changes === 0) {
+      const existing = this.getKgNodeByRef(node.nodeType, node.refId);
+      return existing.id;
+    }
+    return Number(info.lastInsertRowid);
+  }
+  getKgNode(id) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT id, node_type, ref_id, label, metadata, timestamp FROM kg_nodes WHERE id = ?"
+    ).get(id);
+    if (!row) return void 0;
+    return { id: row.id, nodeType: row.node_type, refId: row.ref_id, label: row.label, metadata: row.metadata, timestamp: row.timestamp };
+  }
+  getKgNodeByRef(nodeType, refId) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT id, node_type, ref_id, label, metadata, timestamp FROM kg_nodes WHERE node_type = ? AND ref_id = ?"
+    ).get(nodeType, refId);
+    if (!row) return void 0;
+    return { id: row.id, nodeType: row.node_type, refId: row.ref_id, label: row.label, metadata: row.metadata, timestamp: row.timestamp };
+  }
+  getKgNodesByType(nodeType) {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT id, node_type, ref_id, label, metadata, timestamp FROM kg_nodes WHERE node_type = ? ORDER BY timestamp DESC"
+    ).all(nodeType);
+    return rows.map((r) => ({ id: r.id, nodeType: r.node_type, refId: r.ref_id, label: r.label, metadata: r.metadata, timestamp: r.timestamp }));
+  }
+  getAllKgNodes() {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT id, node_type, ref_id, label, metadata, timestamp FROM kg_nodes ORDER BY timestamp DESC"
+    ).all();
+    return rows.map((r) => ({ id: r.id, nodeType: r.node_type, refId: r.ref_id, label: r.label, metadata: r.metadata, timestamp: r.timestamp }));
+  }
+  deleteKgNode(id) {
+    this.ensureInitialized();
+    this.db.prepare("DELETE FROM kg_edges WHERE source_id = ? OR target_id = ?").run(id, id);
+    this.db.prepare("DELETE FROM kg_nodes WHERE id = ?").run(id);
+  }
+  saveKgEdge(edge) {
+    this.ensureInitialized();
+    const info = this.db.prepare(
+      `INSERT INTO kg_edges (source_id, target_id, edge_type, weight, metadata) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(source_id, target_id, edge_type) DO UPDATE SET weight = excluded.weight, metadata = excluded.metadata, timestamp = datetime('now')`
+    ).run(edge.sourceId, edge.targetId, edge.edgeType, edge.weight, edge.metadata);
+    return Number(info.lastInsertRowid);
+  }
+  getKgEdgesFrom(nodeId, edgeType) {
+    this.ensureInitialized();
+    let sql = "SELECT id, source_id, target_id, edge_type, weight, metadata, timestamp FROM kg_edges WHERE source_id = ?";
+    const params = [nodeId];
+    if (edgeType) {
+      sql += " AND edge_type = ?";
+      params.push(edgeType);
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({ id: r.id, sourceId: r.source_id, targetId: r.target_id, edgeType: r.edge_type, weight: r.weight, metadata: r.metadata, timestamp: r.timestamp }));
+  }
+  getKgEdgesTo(nodeId, edgeType) {
+    this.ensureInitialized();
+    let sql = "SELECT id, source_id, target_id, edge_type, weight, metadata, timestamp FROM kg_edges WHERE target_id = ?";
+    const params = [nodeId];
+    if (edgeType) {
+      sql += " AND edge_type = ?";
+      params.push(edgeType);
+    }
+    sql += " ORDER BY timestamp DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({ id: r.id, sourceId: r.source_id, targetId: r.target_id, edgeType: r.edge_type, weight: r.weight, metadata: r.metadata, timestamp: r.timestamp }));
+  }
+  getAllKgEdges() {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT id, source_id, target_id, edge_type, weight, metadata, timestamp FROM kg_edges ORDER BY timestamp DESC"
+    ).all();
+    return rows.map((r) => ({ id: r.id, sourceId: r.source_id, targetId: r.target_id, edgeType: r.edge_type, weight: r.weight, metadata: r.metadata, timestamp: r.timestamp }));
+  }
+  getKgSummary() {
+    this.ensureInitialized();
+    const nodeCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_nodes").get();
+    const edgeCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_edges").get();
+    const entityCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_nodes WHERE node_type = 'entity'").get();
+    const eventCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_nodes WHERE node_type = 'event'").get();
+    const anomalyCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_nodes WHERE node_type = 'anomaly'").get();
+    const insightCount = this.db.prepare("SELECT COUNT(*) as count FROM kg_nodes WHERE node_type = 'insight'").get();
+    return { totalNodes: nodeCount.count, totalEdges: edgeCount.count, entities: entityCount.count, events: eventCount.count, anomalies: anomalyCount.count, insights: insightCount.count };
+  }
+  // ── Recommendations ──────────────────────────────────────────
+  saveRecommendation(rec) {
+    this.ensureInitialized();
+    const info = this.db.prepare(
+      "INSERT INTO recommendations (action, reason, confidence, status, governance, insight_id, entity, context) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    ).run(rec.action, rec.reason, rec.confidence, rec.status, rec.governance, rec.insightId, rec.entity, rec.context);
+    return Number(info.lastInsertRowid);
+  }
+  getRecommendation(id) {
+    this.ensureInitialized();
+    const row = this.db.prepare(
+      "SELECT id, action, reason, confidence, status, governance, insight_id, entity, context, created_at, resolved_at, resolved_by FROM recommendations WHERE id = ?"
+    ).get(id);
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      action: row.action,
+      reason: row.reason,
+      confidence: row.confidence,
+      status: row.status,
+      governance: row.governance,
+      insightId: row.insight_id,
+      entity: row.entity,
+      context: row.context,
+      createdAt: row.created_at,
+      resolvedAt: row.resolved_at,
+      resolvedBy: row.resolved_by
+    };
+  }
+  getRecommendations(filter) {
+    this.ensureInitialized();
+    let sql = "SELECT id, action, reason, confidence, status, governance, insight_id, entity, context, created_at, resolved_at, resolved_by FROM recommendations";
+    const conditions = [];
+    const params = [];
+    if (filter?.status) {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+    if (filter?.action) {
+      conditions.push("action = ?");
+      params.push(filter.action);
+    }
+    if (conditions.length > 0) {
+      sql += " WHERE " + conditions.join(" AND ");
+    }
+    sql += " ORDER BY created_at DESC";
+    if (filter?.last) {
+      sql += " LIMIT ?";
+      params.push(filter.last);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      action: row.action,
+      reason: row.reason,
+      confidence: row.confidence,
+      status: row.status,
+      governance: row.governance,
+      insightId: row.insight_id,
+      entity: row.entity,
+      context: row.context,
+      createdAt: row.created_at,
+      resolvedAt: row.resolved_at,
+      resolvedBy: row.resolved_by
+    }));
+  }
+  updateRecommendationStatus(id, status, resolvedBy) {
+    this.ensureInitialized();
+    this.db.prepare(
+      "UPDATE recommendations SET status = ?, resolved_at = datetime('now'), resolved_by = ? WHERE id = ?"
+    ).run(status, resolvedBy, id);
+  }
+  getRecommendationSummary() {
+    this.ensureInitialized();
+    const rows = this.db.prepare(
+      "SELECT status, COUNT(*) as count FROM recommendations GROUP BY status"
+    ).all();
+    const counts = {};
+    let total = 0;
+    for (const row of rows) {
+      counts[row.status] = row.count;
+      total += row.count;
+    }
+    return {
+      total,
+      executed: counts["executed"] ?? 0,
+      pending: counts["pending"] ?? 0,
+      approved: counts["approved"] ?? 0,
+      rejected: counts["rejected"] ?? 0,
+      blocked: counts["blocked"] ?? 0,
+      failed: counts["failed"] ?? 0
+    };
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  createSchema() {
+    const createMetaTable = `
+      CREATE TABLE IF NOT EXISTS meta (
+        key   TEXT PRIMARY KEY,
+        value TEXT
+      )
+    `;
+    const createDiscoveredTablesTable = `
+      CREATE TABLE IF NOT EXISTS discovered_tables (
+        id             INTEGER PRIMARY KEY AUTOINCREMENT,
+        table_name     TEXT NOT NULL,
+        table_schema   TEXT DEFAULT 'public',
+        row_count      INTEGER,
+        columns_json   TEXT,
+        fk_json        TEXT,
+        indexes_json   TEXT,
+        sample_rows    TEXT,
+        discovered_at  TEXT DEFAULT (datetime('now')),
+        UNIQUE(table_name, table_schema)
+      )
+    `;
+    const createEntitiesTable = `
+      CREATE TABLE IF NOT EXISTS entities (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        table_name      TEXT NOT NULL UNIQUE,
+        entity_label    TEXT NOT NULL,
+        entity_type     TEXT NOT NULL,
+        description     TEXT,
+        confidence      REAL DEFAULT 0.0,
+        columns_classified TEXT,
+        classified_at   TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createRelationshipsTable = `
+      CREATE TABLE IF NOT EXISTS relationships (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_entity   TEXT NOT NULL,
+        target_entity   TEXT NOT NULL,
+        relationship    TEXT NOT NULL,
+        source_column   TEXT,
+        target_column   TEXT,
+        inferred        INTEGER DEFAULT 0,
+        confidence      REAL DEFAULT 0.0,
+        UNIQUE(source_entity, target_entity, relationship)
+      )
+    `;
+    const createLlmCacheTable = `
+      CREATE TABLE IF NOT EXISTS llm_cache (
+        cache_key   TEXT PRIMARY KEY,
+        response    TEXT NOT NULL,
+        model       TEXT,
+        tokens_used INTEGER,
+        cached_at   TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createEventsTable = `
+      CREATE TABLE IF NOT EXISTS events (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        event_type  TEXT NOT NULL,
+        entity      TEXT NOT NULL,
+        table_name  TEXT NOT NULL,
+        operation   TEXT NOT NULL,
+        row_id      TEXT,
+        row_data    TEXT,
+        timestamp   TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createEventsEntityIndex = `CREATE INDEX IF NOT EXISTS idx_events_entity ON events(entity, timestamp)`;
+    const createEventsTypeIndex = `CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type, timestamp)`;
+    const createBaselinesTable = `
+      CREATE TABLE IF NOT EXISTS baselines (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        metric      TEXT NOT NULL,
+        mean        REAL NOT NULL,
+        stddev      REAL NOT NULL,
+        sample_size INTEGER NOT NULL,
+        updated_at  TEXT DEFAULT (datetime('now')),
+        UNIQUE(entity, metric)
+      )
+    `;
+    const createAnomaliesTable = `
+      CREATE TABLE IF NOT EXISTS anomalies (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity        TEXT NOT NULL,
+        anomaly_type  TEXT NOT NULL,
+        severity      TEXT NOT NULL,
+        expected      REAL,
+        actual        REAL,
+        message       TEXT,
+        timestamp     TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createWatchWatermarksTable = `
+      CREATE TABLE IF NOT EXISTS watch_watermarks (
+        table_name       TEXT NOT NULL,
+        table_schema     TEXT NOT NULL,
+        strategy         TEXT NOT NULL,
+        timestamp_column TEXT,
+        pk_column        TEXT,
+        last_seen_value  TEXT,
+        updated_at       TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY(table_name, table_schema)
+      )
+    `;
+    const createStateTransitionsTable = `
+      CREATE TABLE IF NOT EXISTS state_transitions (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        table_name  TEXT NOT NULL,
+        primary_key TEXT NOT NULL,
+        from_state  TEXT NOT NULL,
+        to_state    TEXT NOT NULL,
+        duration_ms INTEGER,
+        expected    INTEGER NOT NULL,
+        timestamp   TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createTransitionsEntityIndex = `CREATE INDEX IF NOT EXISTS idx_transitions_entity ON state_transitions(entity, timestamp)`;
+    const createTransitionsPkIndex = `CREATE INDEX IF NOT EXISTS idx_transitions_pk ON state_transitions(table_name, primary_key)`;
+    const createInsightsTable = `
+      CREATE TABLE IF NOT EXISTS insights (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity       TEXT NOT NULL,
+        insight_type TEXT NOT NULL,
+        severity     TEXT NOT NULL,
+        message      TEXT NOT NULL,
+        context_json TEXT,
+        timestamp    TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createInsightsEntityIndex = `CREATE INDEX IF NOT EXISTS idx_insights_entity ON insights(entity, timestamp)`;
+    const createEntityStatesTable = `
+      CREATE TABLE IF NOT EXISTS entity_states (
+        table_name  TEXT NOT NULL,
+        primary_key TEXT NOT NULL,
+        state       TEXT NOT NULL,
+        entered_at  TEXT NOT NULL,
+        PRIMARY KEY(table_name, primary_key)
+      )
+    `;
+    const createCorrelationEventsTable = `
+      CREATE TABLE IF NOT EXISTS correlation_events (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        event_type  TEXT NOT NULL,
+        primary_key TEXT,
+        timestamp   TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createCorrelationEventsIndex = `CREATE INDEX IF NOT EXISTS idx_corr_events ON correlation_events(entity, timestamp)`;
+    const createCorrelationRatesTable = `
+      CREATE TABLE IF NOT EXISTS correlation_rates (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        bucket      TEXT NOT NULL,
+        event_count INTEGER NOT NULL,
+        UNIQUE(entity, bucket)
+      )
+    `;
+    const createDistributionHistogramsTable = `
+      CREATE TABLE IF NOT EXISTS distribution_histograms (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        column_name TEXT NOT NULL,
+        bucket_key  TEXT NOT NULL,
+        count       INTEGER NOT NULL,
+        period      TEXT NOT NULL,
+        UNIQUE(entity, column_name, bucket_key, period)
+      )
+    `;
+    const createTemporalPatternsTable = `
+      CREATE TABLE IF NOT EXISTS temporal_patterns (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        entity      TEXT NOT NULL,
+        bucket_type TEXT NOT NULL,
+        bucket_key  INTEGER NOT NULL,
+        count       INTEGER NOT NULL,
+        period      TEXT NOT NULL,
+        UNIQUE(entity, bucket_type, bucket_key, period)
+      )
+    `;
+    const createAnalyticsBaselinesTable = `
+      CREATE TABLE IF NOT EXISTS analytics_baselines (
+        key         TEXT PRIMARY KEY,
+        mean        REAL NOT NULL,
+        stddev      REAL NOT NULL,
+        sample_size INTEGER NOT NULL,
+        updated_at  TEXT DEFAULT (datetime('now'))
+      )
+    `;
+    const createKgNodesTable = `
+      CREATE TABLE IF NOT EXISTS kg_nodes (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        node_type  TEXT NOT NULL,
+        ref_id     TEXT NOT NULL,
+        label      TEXT NOT NULL,
+        metadata   TEXT,
+        timestamp  TEXT DEFAULT (datetime('now')),
+        UNIQUE(node_type, ref_id)
+      )
+    `;
+    const createKgNodesTypeIndex = `CREATE INDEX IF NOT EXISTS idx_kg_nodes_type ON kg_nodes(node_type)`;
+    const createKgNodesRefIndex = `CREATE INDEX IF NOT EXISTS idx_kg_nodes_ref ON kg_nodes(ref_id)`;
+    const createKgEdgesTable = `
+      CREATE TABLE IF NOT EXISTS kg_edges (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_id  INTEGER NOT NULL REFERENCES kg_nodes(id),
+        target_id  INTEGER NOT NULL REFERENCES kg_nodes(id),
+        edge_type  TEXT NOT NULL,
+        weight     REAL DEFAULT 1.0,
+        metadata   TEXT,
+        timestamp  TEXT DEFAULT (datetime('now')),
+        UNIQUE(source_id, target_id, edge_type)
+      )
+    `;
+    const createKgEdgesSourceIndex = `CREATE INDEX IF NOT EXISTS idx_kg_edges_source ON kg_edges(source_id)`;
+    const createKgEdgesTargetIndex = `CREATE INDEX IF NOT EXISTS idx_kg_edges_target ON kg_edges(target_id)`;
+    const createKgEdgesTypeIndex = `CREATE INDEX IF NOT EXISTS idx_kg_edges_type ON kg_edges(edge_type)`;
+    const createRecommendationsTable = `
+      CREATE TABLE IF NOT EXISTS recommendations (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        action      TEXT NOT NULL,
+        reason      TEXT NOT NULL,
+        confidence  REAL NOT NULL,
+        status      TEXT NOT NULL DEFAULT 'pending',
+        governance  TEXT NOT NULL,
+        insight_id  TEXT,
+        entity      TEXT NOT NULL,
+        context     TEXT NOT NULL DEFAULT '{}',
+        created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+        resolved_at TEXT,
+        resolved_by TEXT
+      )
+    `;
+    const createRecommendationsStatusIndex = `CREATE INDEX IF NOT EXISTS idx_recommendations_status ON recommendations(status)`;
+    const createRecommendationsEntityIndex = `CREATE INDEX IF NOT EXISTS idx_recommendations_entity ON recommendations(entity)`;
+    const createRecommendationsActionIndex = `CREATE INDEX IF NOT EXISTS idx_recommendations_action ON recommendations(action)`;
+    this.db.prepare(createMetaTable).run();
+    this.db.prepare(createDiscoveredTablesTable).run();
+    this.db.prepare(createEntitiesTable).run();
+    this.db.prepare(createRelationshipsTable).run();
+    this.db.prepare(createLlmCacheTable).run();
+    this.db.prepare(createEventsTable).run();
+    this.db.prepare(createEventsEntityIndex).run();
+    this.db.prepare(createEventsTypeIndex).run();
+    this.db.prepare(createBaselinesTable).run();
+    this.db.prepare(createAnomaliesTable).run();
+    this.db.prepare(createWatchWatermarksTable).run();
+    this.db.prepare(createStateTransitionsTable).run();
+    this.db.prepare(createTransitionsEntityIndex).run();
+    this.db.prepare(createTransitionsPkIndex).run();
+    this.db.prepare(createInsightsTable).run();
+    this.db.prepare(createInsightsEntityIndex).run();
+    this.db.prepare(createEntityStatesTable).run();
+    this.db.prepare(createCorrelationEventsTable).run();
+    this.db.prepare(createCorrelationEventsIndex).run();
+    this.db.prepare(createCorrelationRatesTable).run();
+    this.db.prepare(createDistributionHistogramsTable).run();
+    this.db.prepare(createTemporalPatternsTable).run();
+    this.db.prepare(createAnalyticsBaselinesTable).run();
+    this.db.prepare(createKgNodesTable).run();
+    this.db.prepare(createKgNodesTypeIndex).run();
+    this.db.prepare(createKgNodesRefIndex).run();
+    this.db.prepare(createKgEdgesTable).run();
+    this.db.prepare(createKgEdgesSourceIndex).run();
+    this.db.prepare(createKgEdgesTargetIndex).run();
+    this.db.prepare(createKgEdgesTypeIndex).run();
+    this.db.prepare(createRecommendationsTable).run();
+    this.db.prepare(createRecommendationsStatusIndex).run();
+    this.db.prepare(createRecommendationsEntityIndex).run();
+    this.db.prepare(createRecommendationsActionIndex).run();
+  }
+  ensureInitialized() {
+    if (!this.db) {
+      throw new Error("Storage not initialized. Call initialize() first.");
+    }
+  }
+};
+
+// src/core/errors.ts
+var CortexaError = class extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.name = "CortexaError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+var ConfigError = class extends CortexaError {
+  constructor(message, hint) {
+    super(message, "CONFIG_ERROR", hint);
+    this.name = "ConfigError";
+  }
+};
+var LLMError = class extends CortexaError {
+  statusCode;
+  provider;
+  constructor(message, options) {
+    super(message, "LLM_ERROR", options?.hint);
+    this.name = "LLMError";
+    this.statusCode = options?.statusCode;
+    this.provider = options?.provider;
+  }
+};
+var LLMResponseError = class extends LLMError {
+  rawContent;
+  constructor(message, rawContent) {
+    super(message, {
+      hint: "The LLM returned an unparseable response. Try reducing batchSize or using a different model."
+    });
+    this.name = "LLMResponseError";
+    this.rawContent = rawContent;
+  }
+};
+
+// src/llm/retry.ts
+var DEFAULT_RETRYABLE_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function isRetryableError(error, retryableCodes) {
+  if (error instanceof LLMError && error.statusCode) {
+    return retryableCodes.has(error.statusCode);
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  return false;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, config, logger10) {
+  const maxRetries = config?.maxRetries ?? 3;
+  const initialDelay = config?.initialDelayMs ?? 1e3;
+  const maxDelay = config?.maxDelayMs ?? 3e4;
+  const multiplier = config?.backoffMultiplier ?? 2;
+  const retryableCodes = config?.retryableStatusCodes ? new Set(config.retryableStatusCodes) : DEFAULT_RETRYABLE_CODES;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries) break;
+      if (!isRetryableError(error, retryableCodes)) {
+        throw error;
+      }
+      const delay = Math.min(initialDelay * Math.pow(multiplier, attempt), maxDelay);
+      const jitteredDelay = delay * (0.75 + Math.random() * 0.5);
+      logger10?.warn(
+        { attempt: attempt + 1, maxRetries, delayMs: Math.round(jitteredDelay) },
+        `LLM call failed, retrying... (${lastError.message})`
+      );
+      await sleep(jitteredDelay);
+    }
+  }
+  throw lastError;
+}
+
+// src/llm/openai-compatible.ts
+var OpenAICompatibleProvider = class {
+  apiKey;
+  model;
+  baseUrl;
+  headers;
+  retry;
+  constructor(options) {
+    this.apiKey = options.apiKey ?? "";
+    this.model = options.model;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.headers = options.headers ?? {};
+    this.retry = options.retry;
+  }
+  async chat(prompt, options) {
+    return withRetry(() => this.doChat(prompt, options), this.retry);
+  }
+  async doChat(prompt, options) {
+    const body = {
+      model: this.model,
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: options?.maxTokens ?? 4096
+    };
+    if (options?.jsonMode) {
+      body.response_format = { type: "json_object" };
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const url = `${this.baseUrl}/chat/completions`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new LLMError(
+        `LLM API error (${response.status}): ${errorText}`,
+        {
+          statusCode: response.status,
+          provider: this.model,
+          hint: response.status === 401 ? "Check your API key in cortexa.config.ts." : response.status === 429 ? "Rate limited. Wait a moment and retry, or use a different model." : response.status >= 500 ? "The LLM provider returned a server error. This is usually temporary." : void 0
+        }
+      );
+    }
+    const data = await response.json();
+    return {
+      content: data.choices[0].message.content,
+      tokensUsed: {
+        prompt: data.usage?.prompt_tokens ?? 0,
+        completion: data.usage?.completion_tokens ?? 0
+      },
+      model: data.model ?? this.model
+    };
+  }
+};
+
+// src/llm/anthropic.ts
+var AnthropicProvider = class {
+  apiKey;
+  model;
+  retry;
+  constructor(apiKey, model = "claude-haiku-4-5-20251001", retry) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.retry = retry;
+  }
+  async chat(prompt, options) {
+    return withRetry(() => this.doChat(prompt, options), this.retry);
+  }
+  async doChat(prompt, options) {
+    const body = {
+      model: this.model,
+      max_tokens: options?.maxTokens ?? 4096,
+      messages: [{ role: "user", content: prompt }]
+    };
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new LLMError(
+        `Anthropic API error (${response.status}): ${errorText}`,
+        {
+          statusCode: response.status,
+          provider: "anthropic",
+          hint: response.status === 401 ? "Check your Anthropic API key in cortexa.config.ts." : response.status === 429 ? "Rate limited. Wait a moment and retry, or use a different model." : response.status >= 500 ? "The Anthropic API returned a server error. This is usually temporary." : void 0
+        }
+      );
+    }
+    const data = await response.json();
+    return {
+      content: data.content[0].text,
+      tokensUsed: {
+        prompt: data.usage.input_tokens,
+        completion: data.usage.output_tokens
+      },
+      model: data.model
+    };
+  }
+};
+
+// src/llm/factory.ts
+var KNOWN_BASE_URLS = {
+  openai: { baseUrl: "https://api.openai.com/v1", defaultModel: "gpt-4o-mini" },
+  deepseek: { baseUrl: "https://api.deepseek.com", defaultModel: "deepseek-chat" }
+};
+function createLLMProvider(config) {
+  if (config.provider === "anthropic") {
+    if (!config.apiKey) {
+      throw new ConfigError("Anthropic provider requires an apiKey.", "Add apiKey to llm config in cortexa.config.ts.");
+    }
+    return new AnthropicProvider(config.apiKey, config.model, config.retry);
+  }
+  const known = KNOWN_BASE_URLS[config.provider];
+  const baseUrl = config.baseUrl ?? known?.baseUrl;
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Unknown provider "${config.provider}".`,
+      `Provide a baseUrl for custom providers: { provider: "${config.provider}", baseUrl: "https://api.example.com/v1" }`
+    );
+  }
+  const model = config.model ?? known?.defaultModel ?? config.provider;
+  return new OpenAICompatibleProvider({
+    apiKey: config.apiKey,
+    model,
+    baseUrl,
+    headers: config.headers,
+    retry: config.retry
+  });
+}
+
+// src/schema/introspector.ts
+var SchemaIntrospector = class {
+  connector;
+  dbType;
+  options;
+  constructor(connector, dbType, options = {}) {
+    this.connector = connector;
+    this.dbType = dbType;
+    this.options = options;
+  }
+  async introspect() {
+    const tableRows = await this.getTables();
+    const tables = [];
+    const excludeTables = new Set(this.options.excludeTables?.map((t) => t.toLowerCase()) ?? []);
+    const excludeColumns = new Set(this.options.excludeColumns?.map((c) => c.toLowerCase()) ?? []);
+    const includeSampleData = this.options.includeSampleData !== false;
+    const sampleLimit = this.options.sampleRowLimit ?? 5;
+    for (const row of tableRows) {
+      const tableName = row.table_name;
+      const tableSchema = row.table_schema;
+      if (excludeTables.has(tableName.toLowerCase())) {
+        continue;
+      }
+      const [allColumns, foreignKeys, indexes, sampleRows, rowCount] = await Promise.all([
+        this.getColumns(tableName, tableSchema),
+        this.getForeignKeys(tableName, tableSchema),
+        this.getIndexes(tableName, tableSchema),
+        includeSampleData ? this.getSampleRows(tableName, tableSchema, sampleLimit) : Promise.resolve([]),
+        this.getRowCount(tableName, tableSchema)
+      ]);
+      const columns = excludeColumns.size > 0 ? allColumns.filter((c) => !excludeColumns.has(c.columnName.toLowerCase())) : allColumns;
+      const filteredSampleRows = excludeColumns.size > 0 && sampleRows.length > 0 ? sampleRows.map((row2) => {
+        const filtered = {};
+        for (const [key, value] of Object.entries(row2)) {
+          if (!excludeColumns.has(key.toLowerCase())) {
+            filtered[key] = value;
+          }
+        }
+        return filtered;
+      }) : sampleRows;
+      tables.push({ tableName, tableSchema, columns, foreignKeys, indexes, sampleRows: filteredSampleRows, rowCount });
+    }
+    return { tables, discoveredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  isPostgresLike() {
+    return this.dbType === "postgres" || this.dbType === "cockroachdb";
+  }
+  isMysqlLike() {
+    return this.dbType === "mysql" || this.dbType === "mariadb";
+  }
+  async getTables() {
+    if (this.dbType === "sqlite") {
+      const result2 = await this.connector.query(
+        `SELECT name AS table_name, 'main' AS table_schema FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name`
+      );
+      return result2.rows;
+    }
+    if (this.dbType === "mongodb") {
+      const result2 = await this.connector.query("COLLECTIONS");
+      return result2.rows;
+    }
+    const schemaFilter = this.isPostgresLike() ? `table_schema NOT IN ('pg_catalog', 'information_schema')` : this.dbType === "mssql" ? `table_schema NOT IN ('sys', 'INFORMATION_SCHEMA')` : `table_schema = DATABASE()`;
+    const result = await this.connector.query(
+      `SELECT table_name AS table_name, table_schema AS table_schema FROM information_schema.tables WHERE table_type = 'BASE TABLE' AND ${schemaFilter} ORDER BY table_name`
+    );
+    return result.rows;
+  }
+  async getColumns(tableName, _tableSchema) {
+    if (this.dbType === "sqlite") {
+      const result2 = await this.connector.query(`PRAGMA table_info("${tableName}")`);
+      return result2.rows.map((row) => ({
+        columnName: row.name,
+        dataType: row.type || "TEXT",
+        isNullable: row.notnull === 0,
+        columnDefault: row.dflt_value ?? null
+      }));
+    }
+    if (this.dbType === "mongodb") {
+      const result2 = await this.connector.query(`FIELDS:${tableName}:20`);
+      return result2.rows.map((row) => ({
+        columnName: row.column_name,
+        dataType: row.data_type,
+        isNullable: true,
+        columnDefault: null
+      }));
+    }
+    const result = await this.connector.query(
+      `SELECT column_name AS column_name, data_type AS data_type, is_nullable AS is_nullable, column_default AS column_default FROM information_schema.columns WHERE table_name = $1 AND table_schema = $2 ORDER BY ordinal_position`,
+      [tableName, _tableSchema]
+    );
+    return result.rows.map((row) => ({
+      columnName: row.column_name,
+      dataType: row.data_type,
+      isNullable: row.is_nullable === "YES",
+      columnDefault: row.column_default ?? null
+    }));
+  }
+  async getForeignKeys(tableName, tableSchema) {
+    if (this.dbType === "mongodb") {
+      const columns = await this.getColumns(tableName, tableSchema);
+      const fks = [];
+      for (const col of columns) {
+        if (col.columnName === "_id") continue;
+        const match = col.columnName.match(/^(.+?)(?:_id|Id)$/);
+        if (match) {
+          fks.push({
+            columnName: col.columnName,
+            referencedTable: match[1] + "s",
+            // naive pluralization
+            referencedColumn: "_id"
+          });
+        }
+      }
+      return fks;
+    }
+    if (this.dbType === "sqlite") {
+      const result2 = await this.connector.query(`PRAGMA foreign_key_list("${tableName}")`);
+      return result2.rows.map((row) => ({
+        columnName: row.from,
+        referencedTable: row.table,
+        referencedColumn: row.to
+      }));
+    }
+    if (this.dbType === "mssql") {
+      const sql2 = `SELECT COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS column_name,
+         OBJECT_NAME(fkc.referenced_object_id) AS referenced_table,
+         COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) AS referenced_column
+         FROM sys.foreign_key_columns fkc
+         JOIN sys.objects o ON o.object_id = fkc.parent_object_id
+         JOIN sys.schemas s ON s.schema_id = o.schema_id
+         WHERE o.name = $1 AND s.name = $2`;
+      const result2 = await this.connector.query(sql2, [tableName, tableSchema]);
+      return result2.rows.map((row) => ({
+        columnName: row.column_name,
+        referencedTable: row.referenced_table,
+        referencedColumn: row.referenced_column
+      }));
+    }
+    const sql = this.isPostgresLike() ? `SELECT a.attname AS column_name, cl2.relname AS referenced_table, a2.attname AS referenced_column
+         FROM pg_constraint con
+         JOIN pg_class cl ON con.conrelid = cl.oid
+         JOIN pg_namespace ns ON cl.relnamespace = ns.oid
+         JOIN pg_class cl2 ON con.confrelid = cl2.oid
+         JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = ANY(con.conkey)
+         JOIN pg_attribute a2 ON a2.attrelid = con.confrelid AND a2.attnum = ANY(con.confkey)
+         WHERE con.contype = 'f' AND cl.relname = $1 AND ns.nspname = $2` : `SELECT column_name AS column_name, referenced_table_name AS referenced_table, referenced_column_name AS referenced_column
+         FROM information_schema.key_column_usage
+         WHERE table_name = $1 AND table_schema = $2 AND referenced_table_name IS NOT NULL`;
+    const result = await this.connector.query(sql, [tableName, tableSchema]);
+    return result.rows.map((row) => ({
+      columnName: row.column_name,
+      referencedTable: row.referenced_table,
+      referencedColumn: row.referenced_column
+    }));
+  }
+  async getIndexes(tableName, tableSchema) {
+    if (this.dbType === "mongodb") {
+      const result2 = await this.connector.query(`INDEXES:${tableName}`);
+      return result2.rows.map((row) => ({
+        indexName: row.index_name,
+        columns: row.columns,
+        isUnique: Boolean(row.is_unique)
+      }));
+    }
+    if (this.dbType === "sqlite") {
+      const indexListResult = await this.connector.query(`PRAGMA index_list("${tableName}")`);
+      const indexes = [];
+      for (const idx of indexListResult.rows) {
+        const idxName = idx.name;
+        const infoResult = await this.connector.query(`PRAGMA index_info("${idxName}")`);
+        indexes.push({
+          indexName: idxName,
+          columns: infoResult.rows.map((r) => r.name),
+          isUnique: idx.unique === 1
+        });
+      }
+      return indexes;
+    }
+    if (this.dbType === "mssql") {
+      const sql2 = `SELECT i.name AS index_name, STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY ic.key_ordinal) AS columns, i.is_unique
+         FROM sys.indexes i
+         JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+         JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+         JOIN sys.objects o ON o.object_id = i.object_id
+         JOIN sys.schemas s ON s.schema_id = o.schema_id
+         WHERE o.name = $1 AND s.name = $2 AND i.type > 0
+         GROUP BY i.name, i.is_unique`;
+      const result2 = await this.connector.query(sql2, [tableName, tableSchema]);
+      return result2.rows.map((row) => ({
+        indexName: row.index_name,
+        columns: row.columns.split(","),
+        isUnique: Boolean(row.is_unique)
+      }));
+    }
+    const sql = this.isPostgresLike() ? `SELECT i.relname AS index_name, array_agg(a.attname ORDER BY k.n) AS columns, ix.indisunique AS is_unique
+         FROM pg_index ix
+         JOIN pg_class t ON t.oid = ix.indrelid
+         JOIN pg_class i ON i.oid = ix.indexrelid
+         JOIN pg_namespace n ON n.oid = t.relnamespace
+         CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)
+         JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+         WHERE t.relname = $1 AND n.nspname = $2
+         GROUP BY i.relname, ix.indisunique` : `SELECT index_name AS index_name, GROUP_CONCAT(column_name ORDER BY seq_in_index) AS columns, NOT non_unique AS is_unique
+         FROM information_schema.statistics
+         WHERE table_name = $1 AND table_schema = $2
+         GROUP BY index_name, non_unique`;
+    const result = await this.connector.query(sql, [tableName, tableSchema]);
+    return result.rows.map((row) => ({
+      indexName: row.index_name,
+      columns: Array.isArray(row.columns) ? row.columns : row.columns.split(","),
+      isUnique: Boolean(row.is_unique)
+    }));
+  }
+  async getSampleRows(tableName, tableSchema, limit = 5) {
+    try {
+      if (this.dbType === "mongodb") {
+        return (await this.connector.query(`SAMPLE:${tableName}:${limit}`)).rows;
+      }
+      if (this.dbType === "mssql") {
+        return (await this.connector.query(`SELECT TOP ${limit} * FROM [${tableSchema}].[${tableName}]`)).rows;
+      }
+      const qualifiedName = this.dbType === "sqlite" ? `"${tableName}"` : this.isPostgresLike() ? `"${tableSchema}"."${tableName}"` : `\`${tableSchema}\`.\`${tableName}\``;
+      const result = await this.connector.query(`SELECT * FROM ${qualifiedName} LIMIT ${limit}`);
+      return result.rows;
+    } catch {
+      return [];
+    }
+  }
+  async getRowCount(tableName, tableSchema) {
+    try {
+      if (this.dbType === "mongodb") {
+        const result2 = await this.connector.query(`COUNT:${tableName}`);
+        return Number(result2.rows[0]?.count ?? 0);
+      }
+      if (this.dbType === "sqlite") {
+        const result2 = await this.connector.query(`SELECT COUNT(*) AS count FROM "${tableName}"`);
+        return Number(result2.rows[0]?.count ?? 0);
+      }
+      if (this.isPostgresLike()) {
+        const result2 = await this.connector.query(
+          `SELECT reltuples::bigint AS count FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.relname = $1 AND n.nspname = $2`,
+          [tableName, tableSchema]
+        );
+        const count = Number(result2.rows[0]?.count ?? 0);
+        return count >= 0 ? count : 0;
+      }
+      if (this.dbType === "mssql") {
+        const result2 = await this.connector.query(
+          `SELECT SUM(rows) AS count FROM sys.partitions WHERE object_id = OBJECT_ID($1) AND index_id IN (0, 1)`,
+          [`${tableSchema}.${tableName}`]
+        );
+        return Number(result2.rows[0]?.count ?? 0);
+      }
+      const result = await this.connector.query(
+        `SELECT table_rows AS count FROM information_schema.tables WHERE table_name = $1 AND table_schema = $2`,
+        [tableName, tableSchema]
+      );
+      return Number(result.rows[0]?.count ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// src/schema/classifier.ts
+var DEFAULT_BATCH_SIZE = 5;
+var SchemaClassifier = class {
+  llm;
+  batchSize;
+  constructor(llm, batchSize) {
+    this.llm = llm;
+    this.batchSize = batchSize ?? DEFAULT_BATCH_SIZE;
+  }
+  async classify(tables) {
+    const batches = this.chunk(tables, this.batchSize);
+    const results = [];
+    for (const batch of batches) {
+      const classified = await this.classifyBatch(batch);
+      results.push(...classified);
+    }
+    return results;
+  }
+  async classifyBatch(tables) {
+    const prompt = this.buildPrompt(tables);
+    const chatOptions = { jsonMode: true, maxTokens: 8192 };
+    let response = await this.llm.chat(prompt, chatOptions);
+    try {
+      return this.parseResponse(response.content);
+    } catch {
+      response = await this.llm.chat(prompt, chatOptions);
+      return this.parseResponse(response.content);
+    }
+  }
+  buildPrompt(tables) {
+    const tablesContext = tables.map((t) => {
+      const columnsStr = t.columns.map((c) => `  - ${c.columnName} (${c.dataType}, ${c.isNullable ? "nullable" : "not null"}${c.columnDefault ? `, default: ${c.columnDefault}` : ""})`).join("\n");
+      const fkStr = t.foreignKeys.length > 0 ? `
+  Foreign Keys:
+${t.foreignKeys.map((fk) => `  - ${fk.columnName} -> ${fk.referencedTable}.${fk.referencedColumn}`).join("\n")}` : "";
+      const sampleStr = t.sampleRows.length > 0 ? `
+  Sample Data (${t.sampleRows.length} rows): ${JSON.stringify(t.sampleRows[0])}` : "";
+      return `Table: ${t.tableName} (schema: ${t.tableSchema}, ~${t.rowCount} rows)
+  Columns:
+${columnsStr}${fkStr}${sampleStr}`;
+    }).join("\n\n");
+    return `You are a database schema analyst. Analyze the following database tables and classify each one.
+
+For each table, return a JSON object with:
+- tableName: exact table name (must match input)
+- entityLabel: human-readable business name (e.g., "User Account", "Sales Order")
+- entityType: one of "master" (core business entities like Users, Products), "transaction" (events/activities like Orders, Payments), "reference" (lookup/config tables like Countries, Statuses), or "junction" (many-to-many link tables)
+- description: one sentence describing the table's business purpose
+- confidence: 0.0 to 1.0 indicating classification confidence
+- columns: array of { columnName, label, meaning } for each column
+
+Return valid JSON in this exact format:
+{
+  "tables": [
+    {
+      "tableName": "...",
+      "entityLabel": "...",
+      "entityType": "master|transaction|reference|junction",
+      "description": "...",
+      "confidence": 0.95,
+      "columns": [
+        { "columnName": "...", "label": "...", "meaning": "..." }
+      ]
+    }
+  ]
+}
+
+DATABASE TABLES:
+
+${tablesContext}`;
+  }
+  parseResponse(content) {
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (err) {
+      throw new LLMResponseError(
+        `Failed to parse LLM response: ${err.message}`,
+        content.slice(0, 500)
+      );
+    }
+    if (!data.tables || !Array.isArray(data.tables)) {
+      throw new LLMResponseError('Invalid LLM response: missing "tables" array', content.slice(0, 500));
+    }
+    return data.tables.map((t) => ({
+      tableName: t.tableName,
+      entityLabel: t.entityLabel,
+      entityType: t.entityType,
+      description: t.description,
+      confidence: t.confidence,
+      columns: (t.columns ?? []).map((c) => ({
+        columnName: c.columnName,
+        label: c.label,
+        meaning: c.meaning
+      }))
+    }));
+  }
+  chunk(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+
+// src/schema/graph-builder.ts
+var GraphBuilder = class {
+  build(rawTables, entities) {
+    const entityMap = new Map(entities.map((e) => [e.tableName, e]));
+    const relationships = [];
+    for (const table of rawTables) {
+      for (const fk of table.foreignKeys) {
+        const sourceEntity = entityMap.get(table.tableName);
+        const targetEntity = entityMap.get(fk.referencedTable);
+        const relationshipLabel = this.generateLabel(
+          sourceEntity?.entityLabel ?? table.tableName,
+          targetEntity?.entityLabel ?? fk.referencedTable,
+          fk.columnName
+        );
+        relationships.push({
+          sourceEntity: table.tableName,
+          targetEntity: fk.referencedTable,
+          relationship: relationshipLabel,
+          sourceColumn: fk.columnName,
+          targetColumn: fk.referencedColumn,
+          inferred: false,
+          confidence: 1
+        });
+      }
+    }
+    return { entities, relationships };
+  }
+  generateLabel(sourceLabel, targetLabel, columnName) {
+    const cleaned = columnName.replace(/_id$/, "").replace(/_/g, " ").toUpperCase();
+    if (cleaned.length > 0) {
+      return `HAS_${cleaned}`;
+    }
+    return `REFERENCES_${targetLabel.replace(/\s+/g, "_").toUpperCase()}`;
+  }
+};
+
+// src/behavioral/change-detector.ts
+var TIMESTAMP_COLUMNS = ["updated_at", "modified_at", "last_modified", "updatedat", "modifiedat"];
+var AUTO_INCREMENT_PATTERNS = ["nextval", "auto_increment", "serial", "identity"];
+var ChangeDetector = class {
+  connector;
+  dbType;
+  constructor(connector, dbType) {
+    this.connector = connector;
+    this.dbType = dbType;
+  }
+  static buildWatchConfigs(tables, excludeTables) {
+    const excludeSet = new Set(excludeTables?.map((t) => t.toLowerCase()) ?? []);
+    const configs = [];
+    for (const table of tables) {
+      if (excludeSet.has(table.tableName.toLowerCase())) continue;
+      const timestampCol = table.columns.find(
+        (c) => TIMESTAMP_COLUMNS.includes(c.columnName.toLowerCase()) && c.dataType.toLowerCase().includes("timestamp")
+      );
+      if (timestampCol) {
+        const pkCol = table.columns.find(
+          (c) => c.columnName.toLowerCase() === "id" && !c.isNullable
+        );
+        configs.push({
+          tableName: table.tableName,
+          tableSchema: table.tableSchema,
+          strategy: "timestamp",
+          timestampColumn: timestampCol.columnName,
+          primaryKeyColumn: pkCol?.columnName ?? table.columns[0].columnName
+        });
+        continue;
+      }
+      const autoIncrementCol = table.columns.find(
+        (c) => c.columnDefault !== null && AUTO_INCREMENT_PATTERNS.some((p) => (c.columnDefault ?? "").toLowerCase().includes(p))
+      );
+      if (autoIncrementCol) {
+        configs.push({
+          tableName: table.tableName,
+          tableSchema: table.tableSchema,
+          strategy: "id_watermark",
+          primaryKeyColumn: autoIncrementCol.columnName
+        });
+        continue;
+      }
+      configs.push({
+        tableName: table.tableName,
+        tableSchema: table.tableSchema,
+        strategy: "table_stats"
+      });
+    }
+    return configs;
+  }
+  async poll(config) {
+    if (config.strategy === "timestamp") {
+      return this.pollTimestamp(config);
+    }
+    if (config.strategy === "id_watermark") {
+      return this.pollIdWatermark(config);
+    }
+    if (config.strategy === "table_stats") {
+      return this.pollTableStats(config);
+    }
+    return [];
+  }
+  async pollTimestamp(config) {
+    const qualified = this.qualifyTable(config.tableName, config.tableSchema);
+    const tsCol = config.timestampColumn;
+    const pkCol = config.primaryKeyColumn ?? "id";
+    const lastSeen = config.lastSeenValue ?? "1970-01-01T00:00:00Z";
+    const result = await this.connector.query(
+      `SELECT * FROM ${qualified} WHERE ${this.quoteIdent(tsCol)} > $1 ORDER BY ${this.quoteIdent(tsCol)} ASC`,
+      [lastSeen]
+    );
+    return result.rows.map((row) => ({
+      tableName: config.tableName,
+      tableSchema: config.tableSchema,
+      operation: "UPDATE",
+      primaryKey: row[pkCol],
+      newData: { ...row },
+      detectedAt: /* @__PURE__ */ new Date()
+    }));
+  }
+  async pollIdWatermark(config) {
+    const qualified = this.qualifyTable(config.tableName, config.tableSchema);
+    const pkCol = config.primaryKeyColumn;
+    const lastSeen = config.lastSeenValue ?? "0";
+    const result = await this.connector.query(
+      `SELECT * FROM ${qualified} WHERE ${this.quoteIdent(pkCol)} > $1 ORDER BY ${this.quoteIdent(pkCol)} ASC`,
+      [lastSeen]
+    );
+    return result.rows.map((row) => ({
+      tableName: config.tableName,
+      tableSchema: config.tableSchema,
+      operation: "INSERT",
+      primaryKey: row[pkCol],
+      newData: { ...row },
+      detectedAt: /* @__PURE__ */ new Date()
+    }));
+  }
+  async pollTableStats(config) {
+    const currentStats = await this.queryTableStats(config.tableName, config.tableSchema);
+    if (!config.lastStats) {
+      config.lastStats = currentStats;
+      return [];
+    }
+    const prev = config.lastStats;
+    const changes = [];
+    const newInserts = currentStats.inserts - prev.inserts;
+    const newUpdates = currentStats.updates - prev.updates;
+    const newDeletes = currentStats.deletes - prev.deletes;
+    config.lastStats = currentStats;
+    if (newInserts === 0 && newUpdates === 0 && newDeletes === 0) return [];
+    if (newInserts > 0) {
+      changes.push({
+        tableName: config.tableName,
+        tableSchema: config.tableSchema,
+        operation: "INSERT",
+        primaryKey: "unknown",
+        detectedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    if (newUpdates > 0) {
+      changes.push({
+        tableName: config.tableName,
+        tableSchema: config.tableSchema,
+        operation: "UPDATE",
+        primaryKey: "unknown",
+        detectedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    if (newDeletes > 0) {
+      changes.push({
+        tableName: config.tableName,
+        tableSchema: config.tableSchema,
+        operation: "DELETE",
+        primaryKey: "unknown",
+        detectedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return changes;
+  }
+  async queryTableStats(tableName, tableSchema) {
+    if (this.dbType === "postgres" || this.dbType === "cockroachdb") {
+      const result2 = await this.connector.query(
+        `SELECT COALESCE(n_tup_ins, 0) AS inserts, COALESCE(n_tup_upd, 0) AS updates, COALESCE(n_tup_del, 0) AS deletes
+         FROM pg_stat_user_tables WHERE relname = $1 AND schemaname = $2`,
+        [tableName, tableSchema]
+      );
+      if (result2.rows.length === 0) return { inserts: 0, updates: 0, deletes: 0 };
+      const row2 = result2.rows[0];
+      return {
+        inserts: parseInt(String(row2.inserts), 10),
+        updates: parseInt(String(row2.updates), 10),
+        deletes: parseInt(String(row2.deletes), 10)
+      };
+    }
+    if (this.dbType === "sqlite") {
+      const result2 = await this.connector.query(
+        `SELECT COUNT(*) AS row_count FROM "${tableName}"`
+      );
+      const rowCount2 = parseInt(String(result2.rows[0]?.row_count ?? 0), 10);
+      return { inserts: rowCount2, updates: 0, deletes: 0 };
+    }
+    if (this.dbType === "mongodb") {
+      const result2 = await this.connector.query(`COUNT:${tableName}`);
+      const docCount = parseInt(String(result2.rows[0]?.count ?? 0), 10);
+      return { inserts: docCount, updates: 0, deletes: 0 };
+    }
+    if (this.dbType === "mssql") {
+      const result2 = await this.connector.query(
+        `SELECT SUM(rows) AS row_count FROM sys.partitions WHERE object_id = OBJECT_ID($1) AND index_id IN (0, 1)`,
+        [`${tableSchema}.${tableName}`]
+      );
+      const rowCount2 = parseInt(String(result2.rows[0]?.row_count ?? 0), 10);
+      return { inserts: rowCount2, updates: 0, deletes: 0 };
+    }
+    const result = await this.connector.query(
+      `SELECT TABLE_ROWS, UPDATE_TIME FROM information_schema.TABLES WHERE TABLE_NAME = $1 AND TABLE_SCHEMA = $2`,
+      [tableName, tableSchema]
+    );
+    if (result.rows.length === 0) return { inserts: 0, updates: 0, deletes: 0 };
+    const row = result.rows[0];
+    const rowCount = parseInt(String(row.TABLE_ROWS ?? 0), 10);
+    const updateTime = row.UPDATE_TIME ? new Date(String(row.UPDATE_TIME)).getTime() : 0;
+    return { inserts: rowCount, updates: updateTime, deletes: 0 };
+  }
+  qualifyTable(tableName, tableSchema) {
+    if (this.dbType === "postgres" || this.dbType === "cockroachdb") {
+      return `"${tableSchema}"."${tableName}"`;
+    }
+    if (this.dbType === "sqlite") {
+      return `"${tableName}"`;
+    }
+    if (this.dbType === "mssql") {
+      return `[${tableSchema}].[${tableName}]`;
+    }
+    if (this.dbType === "mongodb") {
+      return tableName;
+    }
+    return `\`${tableSchema}\`.\`${tableName}\``;
+  }
+  quoteIdent(name) {
+    if (this.dbType === "postgres" || this.dbType === "cockroachdb" || this.dbType === "sqlite") {
+      return `"${name}"`;
+    }
+    if (this.dbType === "mssql") {
+      return `[${name}]`;
+    }
+    return `\`${name}\``;
+  }
+};
+
+// src/behavioral/event-classifier.ts
+var OPERATION_MAP = {
+  INSERT: "created",
+  UPDATE: "updated",
+  DELETE: "deleted"
+};
+var EventClassifier = class {
+  entityLookup;
+  constructor(entityLookup) {
+    this.entityLookup = entityLookup;
+  }
+  classify(change, options) {
+    const entity = this.entityLookup.getEntity(change.tableName);
+    const excludeSet = new Set(options?.excludeColumns?.map((c) => c.toLowerCase()) ?? []);
+    const metadata = this.filterMetadata(change.newData ?? change.oldData ?? {}, excludeSet);
+    return {
+      entity: entity?.entityLabel ?? change.tableName,
+      entityType: entity?.entityType ?? "reference",
+      type: OPERATION_MAP[change.operation],
+      table: change.tableName,
+      primaryKey: change.primaryKey,
+      timestamp: change.detectedAt,
+      changedColumns: change.changedColumns,
+      metadata
+    };
+  }
+  filterMetadata(data, excludeSet) {
+    if (excludeSet.size === 0) return { ...data };
+    const filtered = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (!excludeSet.has(key.toLowerCase())) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  }
+};
+
+// src/behavioral/pattern-engine.ts
+var MIN_SAMPLE_SIZE = 12;
+var DEFAULT_ANOMALY_THRESHOLD = 2;
+var PatternEngine = class _PatternEngine {
+  storage;
+  anomalyThreshold;
+  constructor(storage, options) {
+    this.storage = storage;
+    this.anomalyThreshold = options?.anomalyThreshold ?? DEFAULT_ANOMALY_THRESHOLD;
+  }
+  updateBaselines(entities, operation) {
+    const baselines = this.storage.getBaselines();
+    const baselineMap = new Map(baselines.map((b) => [`${b.entity}:${b.metric}`, b]));
+    for (const entity of entities) {
+      const metric = `${operation}_per_hour`;
+      const currentCount = this.storage.countEvents(entity, operation, 60);
+      const key = `${entity}:${metric}`;
+      const existing = baselineMap.get(key);
+      if (!existing) {
+        this.storage.saveBaseline({
+          entity,
+          metric,
+          mean: currentCount,
+          stddev: 0,
+          sampleSize: 1
+        });
+      } else {
+        const n = existing.sampleSize;
+        const newN = n + 1;
+        const newMean = existing.mean + (currentCount - existing.mean) / newN;
+        const newStddev = Math.sqrt(
+          ((n - 1) * existing.stddev * existing.stddev + (currentCount - existing.mean) * (currentCount - newMean)) / Math.max(n, 1)
+        );
+        this.storage.saveBaseline({
+          entity,
+          metric,
+          mean: newMean,
+          stddev: newStddev,
+          sampleSize: newN
+        });
+      }
+    }
+  }
+  checkRateAnomalies(entities, operation) {
+    const baselines = this.storage.getBaselines();
+    const baselineMap = new Map(baselines.map((b) => [`${b.entity}:${b.metric}`, b]));
+    const anomalies = [];
+    for (const entity of entities) {
+      const metric = `${operation}_per_hour`;
+      const baseline = baselineMap.get(`${entity}:${metric}`);
+      if (!baseline || baseline.sampleSize < MIN_SAMPLE_SIZE || baseline.stddev === 0) continue;
+      const currentCount = this.storage.countEvents(entity, operation, 60);
+      const deviation = Math.abs(currentCount - baseline.mean) / baseline.stddev;
+      if (deviation >= this.anomalyThreshold) {
+        const anomalyType = currentCount > baseline.mean ? "rate_spike" : "rate_drop";
+        const severity = _PatternEngine.getSeverity(deviation);
+        const anomaly = {
+          entity,
+          anomalyType,
+          severity,
+          expected: baseline.mean,
+          actual: currentCount,
+          message: `${entity} ${operation} rate ${anomalyType === "rate_spike" ? "spiked" : "dropped"} to ${currentCount}/hr (expected ${baseline.mean.toFixed(0)}\xB1${baseline.stddev.toFixed(0)})`,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.storage.saveAnomaly({
+          entity: anomaly.entity,
+          anomalyType: anomaly.anomalyType,
+          severity: anomaly.severity,
+          expected: anomaly.expected,
+          actual: anomaly.actual,
+          message: anomaly.message
+        });
+        anomalies.push(anomaly);
+      }
+    }
+    return anomalies;
+  }
+  static getSeverity(sigma) {
+    if (sigma >= 5) return "critical";
+    if (sigma >= 4) return "high";
+    if (sigma >= 3) return "medium";
+    return "low";
+  }
+};
+
+// src/behavioral/capability-detector.ts
+var CapabilityDetector = class {
+  connector;
+  dbType;
+  constructor(connector, dbType) {
+    this.connector = connector;
+    this.dbType = dbType;
+  }
+  async detect() {
+    switch (this.dbType) {
+      case "postgres":
+        return this.detectPostgres();
+      case "cockroachdb":
+        return { canStream: false, reason: "CockroachDB changefeed not yet supported. Polling mode will be used." };
+      case "mysql":
+      case "mariadb":
+        return this.detectMysql();
+      case "sqlite":
+        return { canStream: false, reason: "SQLite does not support CDC streaming. Polling mode will be used." };
+      case "mongodb":
+        return this.detectMongodb();
+      case "mssql":
+        return { canStream: false, reason: "SQL Server CDC not yet supported. Polling mode will be used." };
+      default:
+        return { canStream: false, reason: `Unsupported database type: ${this.dbType}` };
+    }
+  }
+  async detectMongodb() {
+    try {
+      const result = await this.connector.query('COMMAND:{"replSetGetStatus":1}');
+      if (result.rows.length > 0) {
+        return { canStream: true, reason: "MongoDB Change Streams supported (replica set detected)" };
+      }
+      return { canStream: false, reason: "MongoDB Change Streams require a replica set. Polling mode will be used." };
+    } catch {
+      return { canStream: false, reason: "MongoDB Change Streams require a replica set. Polling mode will be used." };
+    }
+  }
+  async detectPostgres() {
+    try {
+      const walResult = await this.connector.query(
+        "SELECT current_setting('wal_level') AS wal_level"
+      );
+      const walLevel = String(walResult.rows[0]?.wal_level ?? "").toLowerCase();
+      if (walLevel !== "logical") {
+        return {
+          canStream: false,
+          reason: "wal_level is not set to 'logical'. Set wal_level = logical in postgresql.conf and restart."
+        };
+      }
+      const roleResult = await this.connector.query(
+        "SELECT rolreplication FROM pg_roles WHERE rolname = current_user"
+      );
+      const rolreplication = roleResult.rows[0]?.rolreplication;
+      if (rolreplication !== true) {
+        return {
+          canStream: false,
+          reason: "Current user lacks REPLICATION privilege required for WAL streaming"
+        };
+      }
+      return { canStream: true, reason: "WAL streaming supported" };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { canStream: false, reason: `Capability detection failed: ${message}` };
+    }
+  }
+  async detectMysql() {
+    try {
+      const logBinResult = await this.connector.query("SHOW VARIABLES LIKE 'log_bin'");
+      const logBinValue = String(logBinResult.rows[0]?.Value ?? "").toUpperCase();
+      if (logBinValue !== "ON") {
+        return {
+          canStream: false,
+          reason: "log_bin is not ON; binlog streaming requires log_bin = ON"
+        };
+      }
+      const binlogFormatResult = await this.connector.query("SHOW VARIABLES LIKE 'binlog_format'");
+      const binlogFormatValue = String(binlogFormatResult.rows[0]?.Value ?? "").toUpperCase();
+      if (binlogFormatValue !== "ROW") {
+        return {
+          canStream: false,
+          reason: `binlog_format is '${binlogFormatValue}', must be 'ROW' for binlog streaming`
+        };
+      }
+      return { canStream: true, reason: "Binlog streaming supported" };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { canStream: false, reason: `Capability detection failed: ${message}` };
+    }
+  }
+};
+
+// src/reasoning/types.ts
+var DURATION_REGEX = /^(\d+)(ms|s|m|h|d)$/;
+var UNIT_TO_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseTransitionDuration(input) {
+  const match = DURATION_REGEX.exec(input);
+  if (!match) {
+    throw new Error(`Invalid duration string: "${input}". Expected format: <number><unit> (ms|s|m|h|d)`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  return value * UNIT_TO_MS[unit];
+}
+
+// src/reasoning/transition-tracker.ts
+var logger = createLogger({ name: "transition-tracker" });
+var TransitionTracker = class {
+  workflows;
+  storage;
+  onInsight;
+  graphs;
+  constructor(workflows, storage, onInsight) {
+    this.workflows = workflows;
+    this.storage = storage;
+    this.onInsight = onInsight;
+    this.graphs = /* @__PURE__ */ new Map();
+    for (const [tableName, config] of Object.entries(workflows)) {
+      this.graphs.set(tableName, this.parseGraph(config.expectedTransitions));
+    }
+  }
+  handleChange(change) {
+    if (change.operation !== "UPDATE") {
+      return;
+    }
+    const tableName = change.tableName;
+    const workflow = this.workflows[tableName];
+    if (!workflow) {
+      return;
+    }
+    if (change.changedColumns && !change.changedColumns.includes(workflow.stateColumn)) {
+      return;
+    }
+    const newState = change.newData?.[workflow.stateColumn];
+    if (newState === null || newState === void 0) {
+      return;
+    }
+    const toState = String(newState);
+    const primaryKey = String(change.primaryKey);
+    const currentState = this.storage.getEntityState(tableName, primaryKey);
+    if (!currentState) {
+      this.storage.saveEntityState({
+        tableName,
+        primaryKey,
+        state: toState,
+        enteredAt: change.detectedAt.toISOString()
+      });
+      return;
+    }
+    const fromState = currentState.state;
+    if (fromState === toState) {
+      return;
+    }
+    const enteredAt = new Date(currentState.enteredAt);
+    const durationMs = change.detectedAt.getTime() - enteredAt.getTime();
+    const entityName = this.storage.getEntity(tableName)?.entityLabel ?? tableName;
+    const graph = this.graphs.get(tableName);
+    const validation = graph ? this.validateTransition(fromState, toState, graph) : { expected: false, insightType: "transition_unexpected", severity: "medium" };
+    this.storage.saveTransition({
+      entity: entityName,
+      tableName,
+      primaryKey,
+      fromState,
+      toState,
+      durationMs,
+      expected: validation.expected
+    });
+    this.storage.saveEntityState({
+      tableName,
+      primaryKey,
+      state: toState,
+      enteredAt: change.detectedAt.toISOString()
+    });
+    if (!validation.expected && validation.insightType && validation.severity) {
+      const message = this.buildMessage(
+        entityName,
+        primaryKey,
+        fromState,
+        toState,
+        validation.insightType,
+        validation.expectedPath,
+        durationMs
+      );
+      const insight = {
+        entity: entityName,
+        insightType: validation.insightType,
+        severity: validation.severity,
+        message,
+        context: {
+          primaryKey,
+          fromState,
+          toState,
+          ...validation.expectedPath ? { expectedPath: validation.expectedPath } : {},
+          durationMs
+        },
+        timestamp: change.detectedAt
+      };
+      this.storage.saveInsight({
+        entity: insight.entity,
+        insightType: insight.insightType,
+        severity: insight.severity,
+        message: insight.message,
+        context: insight.context
+      });
+      this.onInsight(insight);
+      logger.warn(
+        { entity: entityName, primaryKey, fromState, toState, insightType: validation.insightType },
+        message
+      );
+    }
+  }
+  checkStuck() {
+    for (const [tableName, workflow] of Object.entries(this.workflows)) {
+      if (!workflow.stuckThreshold) {
+        continue;
+      }
+      const thresholdMs = parseTransitionDuration(workflow.stuckThreshold);
+      const stuckRecords = this.storage.getStuckEntityStates(
+        tableName,
+        thresholdMs
+      );
+      if (stuckRecords.length === 0) {
+        continue;
+      }
+      const entityName = this.storage.getEntity(tableName)?.entityLabel ?? tableName;
+      const recentInsights = this.storage.getInsights({
+        entity: entityName,
+        last: 60
+      });
+      const recentlyAlertedKeys = new Set(
+        recentInsights.filter((i) => i.insightType === "transition_stuck").map((i) => String(i.context.primaryKey))
+      );
+      for (const record of stuckRecords) {
+        if (recentlyAlertedKeys.has(record.primaryKey)) {
+          continue;
+        }
+        const enteredAt = new Date(record.enteredAt);
+        const now = /* @__PURE__ */ new Date();
+        const actualDurationMs = now.getTime() - enteredAt.getTime();
+        const severity = this.computeStuckSeverity(actualDurationMs, thresholdMs);
+        const message = this.buildMessage(
+          entityName,
+          record.primaryKey,
+          record.state,
+          void 0,
+          "transition_stuck",
+          void 0,
+          actualDurationMs
+        );
+        const insight = {
+          entity: entityName,
+          insightType: "transition_stuck",
+          severity,
+          message,
+          context: {
+            primaryKey: record.primaryKey,
+            fromState: record.state,
+            durationMs: actualDurationMs
+          },
+          timestamp: now
+        };
+        this.storage.saveInsight({
+          entity: insight.entity,
+          insightType: insight.insightType,
+          severity: insight.severity,
+          message: insight.message,
+          context: insight.context
+        });
+        this.onInsight(insight);
+        logger.warn(
+          { entity: entityName, primaryKey: record.primaryKey, state: record.state, severity },
+          message
+        );
+      }
+    }
+  }
+  parseGraph(transitions) {
+    const adjacency = /* @__PURE__ */ new Map();
+    for (const transition of transitions) {
+      const parts = transition.split("->").map((s) => s.trim());
+      if (parts.length !== 2) {
+        logger.warn({ transition }, "Invalid transition format, skipping");
+        continue;
+      }
+      const [from, to] = parts;
+      const neighbors = adjacency.get(from) ?? [];
+      neighbors.push(to);
+      adjacency.set(from, neighbors);
+    }
+    return { adjacency };
+  }
+  validateTransition(from, to, graph) {
+    const directNeighbors = graph.adjacency.get(from) ?? [];
+    if (directNeighbors.includes(to)) {
+      return { expected: true };
+    }
+    const path3 = this.findPath(from, to, graph.adjacency);
+    if (path3 && path3.length > 2) {
+      return {
+        expected: false,
+        insightType: "transition_skip",
+        severity: "high",
+        expectedPath: path3
+      };
+    }
+    return {
+      expected: false,
+      insightType: "transition_unexpected",
+      severity: "medium"
+    };
+  }
+  findPath(from, to, adjacency) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [[from]];
+    visited.add(from);
+    while (queue.length > 0) {
+      const currentPath = queue.shift();
+      const current = currentPath[currentPath.length - 1];
+      const neighbors = adjacency.get(current) ?? [];
+      for (const neighbor of neighbors) {
+        if (neighbor === to) {
+          return [...currentPath, neighbor];
+        }
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push([...currentPath, neighbor]);
+        }
+      }
+    }
+    return null;
+  }
+  computeStuckSeverity(durationMs, thresholdMs) {
+    const multiplier = durationMs / thresholdMs;
+    if (multiplier >= 8) {
+      return "critical";
+    }
+    if (multiplier >= 4) {
+      return "high";
+    }
+    if (multiplier >= 2) {
+      return "medium";
+    }
+    return "low";
+  }
+  buildMessage(entity, primaryKey, fromState, toState, insightType, expectedPath, durationMs) {
+    const formatted = this.formatDuration(durationMs);
+    switch (insightType) {
+      case "transition_skip":
+        return `${entity} ${primaryKey} skipped states: ${fromState} -> ${toState} (expected path: ${expectedPath?.join(" -> ")}) after ${formatted}`;
+      case "transition_unexpected":
+        return `${entity} ${primaryKey} made unexpected transition: ${fromState} -> ${toState} after ${formatted}`;
+      case "transition_stuck":
+        return `${entity} ${primaryKey} stuck in "${fromState}" for ${formatted}`;
+      default:
+        return `${entity} ${primaryKey}: ${insightType} (${fromState}${toState ? " -> " + toState : ""}) after ${formatted}`;
+    }
+  }
+  formatDuration(ms) {
+    const totalMinutes = Math.floor(ms / 6e4);
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    if (hours > 0 && minutes > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    if (hours > 0) {
+      return `${hours}h`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m`;
+    }
+    const seconds = Math.floor(ms / 1e3);
+    if (seconds > 0) {
+      return `${seconds}s`;
+    }
+    return `${ms}ms`;
+  }
+};
+
+// src/analytics/types.ts
+var TIME_WINDOW_REGEX = /^(\d+)(s|m|h|d)$/;
+var UNIT_TO_MS2 = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function parseTimeWindow(input) {
+  const match = TIME_WINDOW_REGEX.exec(input);
+  if (!match) {
+    throw new Error(`Invalid time window string: "${input}". Expected format: <number><unit> (s|m|h|d)`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2];
+  return value * UNIT_TO_MS2[unit];
+}
+
+// src/analytics/correlator.ts
+var logger2 = createLogger({ name: "correlator" });
+var MIN_SAMPLE_SIZE2 = 12;
+var ANOMALY_THRESHOLD = 2;
+var Correlator = class _Correlator {
+  storage;
+  onInsight;
+  trackedEntities;
+  parsedConfigs;
+  constructor(configs, storage, onInsight) {
+    this.storage = storage;
+    this.onInsight = onInsight;
+    this.trackedEntities = /* @__PURE__ */ new Set();
+    this.parsedConfigs = [];
+    for (const [name, config] of Object.entries(configs)) {
+      this.trackedEntities.add(config.entities[0]);
+      this.trackedEntities.add(config.entities[1]);
+      this.parsedConfigs.push({
+        name,
+        entities: config.entities,
+        timeWindowMs: parseTimeWindow(config.timeWindow)
+      });
+    }
+    logger2.debug({ configCount: this.parsedConfigs.length }, "Correlator initialized");
+  }
+  recordEvent(entity, eventType, primaryKey) {
+    if (!this.trackedEntities.has(entity)) {
+      return;
+    }
+    this.storage.saveCorrelationEvent({ entity, eventType, primaryKey });
+  }
+  checkRateCorrelation() {
+    for (const config of this.parsedConfigs) {
+      const [entityA, entityB] = config.entities;
+      const ratesA = this.storage.getCorrelationRates(entityA, 24);
+      const ratesB = this.storage.getCorrelationRates(entityB, 24);
+      const avgA = this.averageEventCount(ratesA);
+      const avgB = this.averageEventCount(ratesB);
+      if (avgA === 0 || avgB === 0) {
+        continue;
+      }
+      const ratio = avgA / avgB;
+      const baselineKey = `correlation:${config.name}:rate_ratio`;
+      const existing = this.storage.getBaseline(baselineKey);
+      if (!existing || existing.sampleSize < MIN_SAMPLE_SIZE2) {
+        this.updateBaseline(baselineKey, ratio, existing);
+        continue;
+      }
+      if (existing.stddev === 0) {
+        this.updateBaseline(baselineKey, ratio, existing);
+        continue;
+      }
+      const zScore = Math.abs(ratio - existing.mean) / existing.stddev;
+      if (zScore >= ANOMALY_THRESHOLD) {
+        const severity = _Correlator.getSeverity(zScore);
+        const insight = {
+          entity: config.name,
+          insightType: "correlation_divergence",
+          severity,
+          message: `Rate ratio between ${entityA} and ${entityB} diverged to ${ratio.toFixed(2)} (expected ${existing.mean.toFixed(2)}\xB1${existing.stddev.toFixed(2)}, z=${zScore.toFixed(1)})`,
+          context: {
+            entityA,
+            entityB,
+            ratio,
+            baselineMean: existing.mean,
+            baselineStddev: existing.stddev,
+            zScore
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.storage.saveInsight({
+          entity: insight.entity,
+          insightType: insight.insightType,
+          severity: insight.severity,
+          message: insight.message,
+          context: insight.context
+        });
+        this.onInsight(insight);
+        logger2.info({ config: config.name, zScore, ratio }, "Rate correlation divergence detected");
+      }
+      this.updateBaseline(baselineKey, ratio, existing);
+    }
+  }
+  checkCoOccurrence() {
+    for (const config of this.parsedConfigs) {
+      const [entityA, entityB] = config.entities;
+      const timeWindowMinutes = Math.ceil(config.timeWindowMs / 6e4);
+      const eventsA = this.storage.getCorrelationEvents(entityA, timeWindowMinutes);
+      const eventsB = this.storage.getCorrelationEvents(entityB, timeWindowMinutes);
+      const countA = eventsA.length;
+      const countB = eventsB.length;
+      if (countA === 0 && countB === 0) {
+        continue;
+      }
+      const maxCount = Math.max(countA, countB);
+      const minCount = Math.min(countA, countB);
+      const coOccurrenceRate = maxCount === 0 ? 0 : minCount / maxCount;
+      const baselineKey = `correlation:${config.name}:co_occurrence`;
+      const existing = this.storage.getBaseline(baselineKey);
+      if (!existing || existing.sampleSize < MIN_SAMPLE_SIZE2) {
+        this.updateBaseline(baselineKey, coOccurrenceRate, existing);
+        continue;
+      }
+      if (existing.stddev === 0) {
+        this.updateBaseline(baselineKey, coOccurrenceRate, existing);
+        continue;
+      }
+      const zScore = (existing.mean - coOccurrenceRate) / existing.stddev;
+      if (zScore >= ANOMALY_THRESHOLD) {
+        const severity = _Correlator.getSeverity(zScore);
+        const insight = {
+          entity: config.name,
+          insightType: "correlation_timing",
+          severity,
+          message: `Co-occurrence between ${entityA} and ${entityB} dropped to ${(coOccurrenceRate * 100).toFixed(1)}% (expected ${(existing.mean * 100).toFixed(1)}%\xB1${(existing.stddev * 100).toFixed(1)}%, z=${zScore.toFixed(1)})`,
+          context: {
+            entityA,
+            entityB,
+            coOccurrenceRate,
+            baselineMean: existing.mean,
+            baselineStddev: existing.stddev,
+            zScore,
+            countA,
+            countB
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.storage.saveInsight({
+          entity: insight.entity,
+          insightType: insight.insightType,
+          severity: insight.severity,
+          message: insight.message,
+          context: insight.context
+        });
+        this.onInsight(insight);
+        logger2.info({ config: config.name, zScore, coOccurrenceRate }, "Co-occurrence timing violation detected");
+      }
+      this.updateBaseline(baselineKey, coOccurrenceRate, existing);
+    }
+  }
+  static getSeverity(sigma) {
+    if (sigma >= 5) return "critical";
+    if (sigma >= 4) return "high";
+    if (sigma >= 3) return "medium";
+    return "low";
+  }
+  updateBaseline(key, currentValue, existing) {
+    if (!existing) {
+      this.storage.saveBaseline({
+        key,
+        mean: currentValue,
+        stddev: 0,
+        sampleSize: 1
+      });
+      return;
+    }
+    const newN = existing.sampleSize + 1;
+    const delta = currentValue - existing.mean;
+    const newMean = existing.mean + delta / newN;
+    const delta2 = currentValue - newMean;
+    const newVariance = newN <= 2 ? (existing.stddev * existing.stddev * Math.max(newN - 2, 0) + delta * delta2) / Math.max(newN - 1, 1) : (existing.stddev * existing.stddev * (newN - 2) + delta * delta2) / (newN - 1);
+    const newStddev = Math.sqrt(Math.max(newVariance, 0));
+    this.storage.saveBaseline({
+      key,
+      mean: newMean,
+      stddev: newStddev,
+      sampleSize: newN
+    });
+  }
+  averageEventCount(rates) {
+    if (rates.length === 0) return 0;
+    const total = rates.reduce((sum, r) => sum + r.eventCount, 0);
+    return total / rates.length;
+  }
+};
+
+// src/analytics/distribution-tracker.ts
+var logger3 = createLogger({ name: "distribution-tracker" });
+var MIN_SAMPLE_SIZE3 = 12;
+var NUM_BINS = 10;
+var DistributionTracker = class _DistributionTracker {
+  storage;
+  onInsight;
+  entityConfigs;
+  constructor(configs, storage, onInsight) {
+    this.storage = storage;
+    this.onInsight = onInsight;
+    this.entityConfigs = /* @__PURE__ */ new Map();
+    for (const [entity, config] of Object.entries(configs)) {
+      this.entityConfigs.set(entity, {
+        entity,
+        columns: config.columns,
+        temporalBuckets: config.temporalBuckets
+      });
+    }
+    logger3.debug(
+      { entityCount: this.entityConfigs.size },
+      "DistributionTracker initialized"
+    );
+  }
+  recordValue(entity, data) {
+    const config = this.entityConfigs.get(entity);
+    if (!config) {
+      return;
+    }
+    for (const column of config.columns) {
+      const value = data[column];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const bucketKey = _DistributionTracker.toBucketKey(value);
+      if (bucketKey === null) {
+        continue;
+      }
+      this.storage.saveHistogramBucket({
+        entity,
+        columnName: column,
+        bucketKey,
+        count: 1,
+        period: "current"
+      });
+    }
+  }
+  recordTemporalEvent(entity, timestamp) {
+    const config = this.entityConfigs.get(entity);
+    if (!config) {
+      return;
+    }
+    if (config.temporalBuckets === "hourly") {
+      this.storage.saveTemporalPattern({
+        entity,
+        bucketType: "hour_of_day",
+        bucketKey: timestamp.getUTCHours(),
+        count: 1,
+        period: "current"
+      });
+    } else {
+      this.storage.saveTemporalPattern({
+        entity,
+        bucketType: "day_of_week",
+        bucketKey: timestamp.getUTCDay(),
+        count: 1,
+        period: "current"
+      });
+    }
+  }
+  checkDistributionShift() {
+    for (const config of this.entityConfigs.values()) {
+      for (const column of config.columns) {
+        const baselineKey = `distribution:${config.entity}:${column}:shift`;
+        const baseline = this.storage.getBaseline(baselineKey);
+        if (!baseline || baseline.sampleSize < MIN_SAMPLE_SIZE3) {
+          continue;
+        }
+        const baselineBuckets = this.storage.getHistogramBuckets(
+          config.entity,
+          column,
+          "baseline"
+        );
+        const currentBuckets = this.storage.getHistogramBuckets(
+          config.entity,
+          column,
+          "current"
+        );
+        if (baselineBuckets.length === 0 || currentBuckets.length === 0) {
+          continue;
+        }
+        const { observed, expected } = _DistributionTracker.alignAndNormalize(currentBuckets, baselineBuckets);
+        if (observed.length === 0) {
+          continue;
+        }
+        const chi2 = _DistributionTracker.chiSquared(observed, expected);
+        const df = Math.max(observed.length - 1, 1);
+        const threshold = _DistributionTracker.chiSquaredThreshold(df);
+        if (chi2 > threshold) {
+          const pValue = _DistributionTracker.chiSquaredPValue(chi2, df);
+          const severity = _DistributionTracker.shiftSeverity(chi2, df);
+          const insightType = "distribution_shift";
+          const insight = {
+            entity: config.entity,
+            insightType,
+            severity,
+            message: `Distribution shift detected for ${config.entity}.${column}: chi2=${chi2.toFixed(2)}, df=${df}, p=${pValue.toFixed(4)}`,
+            context: {
+              column,
+              chi2,
+              df,
+              pValue,
+              threshold
+            },
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.storage.saveInsight({
+            entity: insight.entity,
+            insightType: insight.insightType,
+            severity: insight.severity,
+            message: insight.message,
+            context: insight.context
+          });
+          this.onInsight(insight);
+          logger3.info(
+            { entity: config.entity, column, chi2, df, pValue },
+            "Distribution shift detected"
+          );
+        }
+      }
+    }
+  }
+  checkTemporalShift() {
+    for (const config of this.entityConfigs.values()) {
+      const bucketType = config.temporalBuckets === "hourly" ? "hour_of_day" : "day_of_week";
+      const baselineKey = `temporal:${config.entity}:${bucketType}:shift`;
+      const baseline = this.storage.getBaseline(baselineKey);
+      if (!baseline || baseline.sampleSize < MIN_SAMPLE_SIZE3) {
+        continue;
+      }
+      const baselinePatterns = this.storage.getTemporalPatterns(
+        config.entity,
+        bucketType,
+        "baseline"
+      );
+      const currentPatterns = this.storage.getTemporalPatterns(
+        config.entity,
+        bucketType,
+        "current"
+      );
+      if (baselinePatterns.length === 0 || currentPatterns.length === 0) {
+        continue;
+      }
+      const { observed, expected } = _DistributionTracker.alignAndNormalizeNumericBuckets(
+        currentPatterns,
+        baselinePatterns
+      );
+      if (observed.length === 0) {
+        continue;
+      }
+      const chi2 = _DistributionTracker.chiSquared(observed, expected);
+      const df = Math.max(observed.length - 1, 1);
+      const threshold = _DistributionTracker.chiSquaredThreshold(df);
+      if (chi2 > threshold) {
+        const pValue = _DistributionTracker.chiSquaredPValue(chi2, df);
+        const severity = _DistributionTracker.shiftSeverity(chi2, df);
+        const insightType = "temporal_shift";
+        const insight = {
+          entity: config.entity,
+          insightType,
+          severity,
+          message: `Temporal pattern shift detected for ${config.entity} (${bucketType}): chi2=${chi2.toFixed(2)}, df=${df}, p=${pValue.toFixed(4)}`,
+          context: {
+            bucketType,
+            chi2,
+            df,
+            pValue,
+            threshold
+          },
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.storage.saveInsight({
+          entity: insight.entity,
+          insightType: insight.insightType,
+          severity: insight.severity,
+          message: insight.message,
+          context: insight.context
+        });
+        this.onInsight(insight);
+        logger3.info(
+          { entity: config.entity, bucketType, chi2, df, pValue },
+          "Temporal pattern shift detected"
+        );
+      }
+    }
+  }
+  static chiSquared(observed, expected) {
+    let sum = 0;
+    for (let i = 0; i < observed.length; i++) {
+      const e = expected[i];
+      if (e === 0) {
+        continue;
+      }
+      const diff = observed[i] - e;
+      sum += diff * diff / e;
+    }
+    return sum;
+  }
+  static chiSquaredThreshold(df) {
+    const table = {
+      1: 3.841,
+      2: 5.991,
+      3: 7.815,
+      4: 9.488,
+      5: 11.07
+    };
+    if (df in table) {
+      return table[df];
+    }
+    const term = 1 - 2 / (9 * df);
+    return df * Math.pow(term, 3);
+  }
+  static chiSquaredPValue(chi2, df) {
+    if (df <= 0 || chi2 <= 0) return 1;
+    const a = df / 2;
+    const x = chi2 / 2;
+    return 1 - _DistributionTracker.regularizedGammaP(a, x);
+  }
+  static regularizedGammaP(a, x) {
+    if (x < 0) return 0;
+    if (x === 0) return 0;
+    if (x < a + 1) {
+      return _DistributionTracker.gammaPSeries(a, x);
+    }
+    return 1 - _DistributionTracker.gammaPContinuedFraction(a, x);
+  }
+  static gammaPSeries(a, x) {
+    const lnGammaA = _DistributionTracker.lnGamma(a);
+    let sum = 1 / a;
+    let term = 1 / a;
+    for (let n = 1; n < 200; n++) {
+      term *= x / (a + n);
+      sum += term;
+      if (Math.abs(term) < Math.abs(sum) * 1e-10) break;
+    }
+    return sum * Math.exp(-x + a * Math.log(x) - lnGammaA);
+  }
+  static gammaPContinuedFraction(a, x) {
+    const lnGammaA = _DistributionTracker.lnGamma(a);
+    let f = 1e-30;
+    let c = 1e-30;
+    let d = 1 / (x + 1 - a);
+    let h = d;
+    for (let n = 1; n < 200; n++) {
+      const an = -n * (n - a);
+      const bn = x + 2 * n + 1 - a;
+      d = bn + an * d;
+      if (Math.abs(d) < 1e-30) d = 1e-30;
+      c = bn + an / c;
+      if (Math.abs(c) < 1e-30) c = 1e-30;
+      d = 1 / d;
+      const delta = c * d;
+      h *= delta;
+      if (Math.abs(delta - 1) < 1e-10) break;
+    }
+    return Math.exp(-x + a * Math.log(x) - lnGammaA) * h;
+  }
+  static lnGamma(x) {
+    const g = 7;
+    const coef = [
+      0.9999999999998099,
+      676.5203681218851,
+      -1259.1392167224028,
+      771.3234287776531,
+      -176.6150291621406,
+      12.507343278686905,
+      -0.13857109526572012,
+      9984369578019572e-21,
+      15056327351493116e-23
+    ];
+    if (x < 0.5) {
+      return Math.log(Math.PI / Math.sin(Math.PI * x)) - _DistributionTracker.lnGamma(1 - x);
+    }
+    x -= 1;
+    let a = coef[0];
+    const t = x + g + 0.5;
+    for (let i = 1; i < coef.length; i++) {
+      a += coef[i] / (x + i);
+    }
+    return 0.5 * Math.log(2 * Math.PI) + (x + 0.5) * Math.log(t) - t + Math.log(a);
+  }
+  static shiftSeverity(chi2, df) {
+    const p = _DistributionTracker.chiSquaredPValue(chi2, df);
+    if (p < 1e-3) return "critical";
+    if (p < 0.01) return "high";
+    if (p < 0.05) return "medium";
+    return "low";
+  }
+  static toBucketKey(value) {
+    if (typeof value === "number") {
+      return `n:${value}`;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return null;
+  }
+  static alignAndNormalize(currentBuckets, baselineBuckets) {
+    const allBuckets = [...baselineBuckets, ...currentBuckets];
+    const isNumeric = allBuckets.length > 0 && allBuckets.every((b) => b.bucketKey.startsWith("n:"));
+    if (isNumeric) {
+      return _DistributionTracker.alignNumericBins(currentBuckets, baselineBuckets);
+    }
+    return _DistributionTracker.alignCategoricalBuckets(currentBuckets, baselineBuckets);
+  }
+  static alignCategoricalBuckets(currentBuckets, baselineBuckets) {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const b of baselineBuckets) allKeys.add(b.bucketKey);
+    for (const b of currentBuckets) allKeys.add(b.bucketKey);
+    const baselineMap = new Map(baselineBuckets.map((b) => [b.bucketKey, b.count]));
+    const currentMap = new Map(currentBuckets.map((b) => [b.bucketKey, b.count]));
+    const keys = Array.from(allKeys).sort();
+    const rawObserved = [];
+    const rawExpected = [];
+    for (const key of keys) {
+      rawObserved.push(currentMap.get(key) ?? 0);
+      rawExpected.push(baselineMap.get(key) ?? 0);
+    }
+    const totalObserved = rawObserved.reduce((s, v) => s + v, 0);
+    const totalExpected = rawExpected.reduce((s, v) => s + v, 0);
+    if (totalExpected === 0 || totalObserved === 0) {
+      return { observed: [], expected: [] };
+    }
+    const scale = totalObserved / totalExpected;
+    const expected = rawExpected.map((e) => e * scale);
+    return { observed: rawObserved, expected };
+  }
+  static alignNumericBins(currentBuckets, baselineBuckets) {
+    const parseValue = (key) => parseFloat(key.slice(2));
+    const allValues = [];
+    for (const b of baselineBuckets) allValues.push(parseValue(b.bucketKey));
+    for (const b of currentBuckets) allValues.push(parseValue(b.bucketKey));
+    if (allValues.length === 0) {
+      return { observed: [], expected: [] };
+    }
+    const min = Math.min(...allValues);
+    const max = Math.max(...allValues);
+    const range = max - min;
+    if (range === 0) {
+      const totalObs = currentBuckets.reduce((s, b) => s + b.count, 0);
+      const totalExp = baselineBuckets.reduce((s, b) => s + b.count, 0);
+      if (totalObs === 0 || totalExp === 0) return { observed: [], expected: [] };
+      return { observed: [totalObs], expected: [totalExp] };
+    }
+    const binWidth = range / NUM_BINS;
+    const observed = new Array(NUM_BINS).fill(0);
+    const rawExpected = new Array(NUM_BINS).fill(0);
+    for (const b of currentBuckets) {
+      const val = parseValue(b.bucketKey);
+      const bin = Math.min(Math.floor((val - min) / binWidth), NUM_BINS - 1);
+      observed[bin] += b.count;
+    }
+    for (const b of baselineBuckets) {
+      const val = parseValue(b.bucketKey);
+      const bin = Math.min(Math.floor((val - min) / binWidth), NUM_BINS - 1);
+      rawExpected[bin] += b.count;
+    }
+    const totalObserved = observed.reduce((s, v) => s + v, 0);
+    const totalExpected = rawExpected.reduce((s, v) => s + v, 0);
+    if (totalObserved === 0 || totalExpected === 0) {
+      return { observed: [], expected: [] };
+    }
+    const scale = totalObserved / totalExpected;
+    const expected = rawExpected.map((e) => e * scale);
+    return { observed, expected };
+  }
+  static alignAndNormalizeNumericBuckets(currentBuckets, baselineBuckets) {
+    const allKeys = /* @__PURE__ */ new Set();
+    for (const b of baselineBuckets) allKeys.add(b.bucketKey);
+    for (const b of currentBuckets) allKeys.add(b.bucketKey);
+    const baselineMap = new Map(baselineBuckets.map((b) => [b.bucketKey, b.count]));
+    const currentMap = new Map(currentBuckets.map((b) => [b.bucketKey, b.count]));
+    const keys = Array.from(allKeys).sort((a, b) => a - b);
+    const rawObserved = [];
+    const rawExpected = [];
+    for (const key of keys) {
+      rawObserved.push(currentMap.get(key) ?? 0);
+      rawExpected.push(baselineMap.get(key) ?? 0);
+    }
+    const totalObserved = rawObserved.reduce((s, v) => s + v, 0);
+    const totalExpected = rawExpected.reduce((s, v) => s + v, 0);
+    if (totalExpected === 0 || totalObserved === 0) {
+      return { observed: [], expected: [] };
+    }
+    const scale = totalObserved / totalExpected;
+    const expected = rawExpected.map((e) => e * scale);
+    return { observed: rawObserved, expected };
+  }
+};
+
+// src/analytics/analytics-engine.ts
+var logger4 = createLogger({ name: "analytics-engine" });
+var AnalyticsEngine = class {
+  correlator;
+  distributionTracker;
+  constructor(config, storage, onInsight) {
+    const correlationEntries = config.correlations ? Object.keys(config.correlations) : [];
+    const distributionEntries = config.distributions ? Object.keys(config.distributions) : [];
+    if (correlationEntries.length > 0 && config.correlations) {
+      this.correlator = new Correlator(config.correlations, storage, onInsight);
+    } else {
+      this.correlator = null;
+    }
+    if (distributionEntries.length > 0 && config.distributions) {
+      this.distributionTracker = new DistributionTracker(config.distributions, storage, onInsight);
+    } else {
+      this.distributionTracker = null;
+    }
+    logger4.debug(
+      { hasCorrelator: this.correlator !== null, hasDistributionTracker: this.distributionTracker !== null },
+      "AnalyticsEngine initialized"
+    );
+  }
+  handleEvent(entity, eventType, primaryKey, data, timestamp) {
+    if (this.correlator) {
+      this.correlator.recordEvent(entity, eventType, primaryKey);
+    }
+    if (this.distributionTracker) {
+      this.distributionTracker.recordValue(entity, data);
+      this.distributionTracker.recordTemporalEvent(entity, timestamp);
+    }
+  }
+  runPeriodicChecks() {
+    if (this.correlator) {
+      this.correlator.checkRateCorrelation();
+      this.correlator.checkCoOccurrence();
+    }
+    if (this.distributionTracker) {
+      this.distributionTracker.checkDistributionShift();
+      this.distributionTracker.checkTemporalShift();
+    }
+  }
+};
+
+// src/knowledge/graph-store.ts
+var logger5 = createLogger({ name: "graph-store" });
+function toNode(raw) {
+  return {
+    id: raw.id,
+    nodeType: raw.nodeType,
+    refId: raw.refId,
+    label: raw.label,
+    metadata: JSON.parse(raw.metadata || "{}"),
+    timestamp: raw.timestamp
+  };
+}
+function toEdge(raw) {
+  return {
+    id: raw.id,
+    sourceId: raw.sourceId,
+    targetId: raw.targetId,
+    edgeType: raw.edgeType,
+    weight: raw.weight,
+    metadata: JSON.parse(raw.metadata || "{}"),
+    timestamp: raw.timestamp
+  };
+}
+var GraphStore = class {
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  upsertNode(nodeType, refId, label, metadata = {}) {
+    const id = this.storage.saveKgNode({ nodeType, refId, label, metadata: JSON.stringify(metadata) });
+    logger5.debug({ id, nodeType, refId }, "Upserted node");
+    return id;
+  }
+  getNode(id) {
+    const raw = this.storage.getKgNode(id);
+    return raw ? toNode(raw) : void 0;
+  }
+  getNodeByRef(nodeType, refId) {
+    const raw = this.storage.getKgNodeByRef(nodeType, refId);
+    return raw ? toNode(raw) : void 0;
+  }
+  getNodesByType(nodeType) {
+    return this.storage.getKgNodesByType(nodeType).map(toNode);
+  }
+  getAllNodes() {
+    return this.storage.getAllKgNodes().map(toNode);
+  }
+  deleteNode(id) {
+    this.storage.deleteKgNode(id);
+    logger5.debug({ id }, "Deleted node");
+  }
+  addEdge(sourceId, targetId, edgeType, weight = 1, metadata = {}) {
+    const id = this.storage.saveKgEdge({ sourceId, targetId, edgeType, weight, metadata: JSON.stringify(metadata) });
+    logger5.debug({ id, sourceId, targetId, edgeType }, "Added edge");
+    return id;
+  }
+  getEdgesFrom(nodeId, edgeType) {
+    return this.storage.getKgEdgesFrom(nodeId, edgeType).map(toEdge);
+  }
+  getEdgesTo(nodeId, edgeType) {
+    return this.storage.getKgEdgesTo(nodeId, edgeType).map(toEdge);
+  }
+  getAllEdges() {
+    return this.storage.getAllKgEdges().map(toEdge);
+  }
+  neighbors(nodeId) {
+    const outgoing = this.storage.getKgEdgesFrom(nodeId);
+    const incoming = this.storage.getKgEdgesTo(nodeId);
+    const neighborIds = /* @__PURE__ */ new Set();
+    for (const e of outgoing) neighborIds.add(e.targetId);
+    for (const e of incoming) neighborIds.add(e.sourceId);
+    const nodes = [];
+    for (const nid of neighborIds) {
+      const raw = this.storage.getKgNode(nid);
+      if (raw) nodes.push(toNode(raw));
+    }
+    return nodes;
+  }
+  getSummary() {
+    return this.storage.getKgSummary();
+  }
+};
+
+// src/knowledge/graph-populator.ts
+var logger6 = createLogger({ name: "graph-populator" });
+var HIGH_SEVERITY = /* @__PURE__ */ new Set(["high", "critical"]);
+var eventCounter = 0;
+var insightCounter = 0;
+var GraphPopulator = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  populateFromSchema(tables) {
+    for (const table of tables) {
+      this.store.upsertNode("entity", table.tableName, table.tableName, {
+        tableSchema: table.tableSchema,
+        rowCount: table.rowCount
+      });
+    }
+    for (const table of tables) {
+      for (const fk of table.foreignKeys) {
+        const sourceNode = this.store.getNodeByRef("entity", fk.referencedTable);
+        const targetNode = this.store.getNodeByRef("entity", table.tableName);
+        if (sourceNode && targetNode && sourceNode.id !== targetNode.id) {
+          this.store.addEdge(sourceNode.id, targetNode.id, "contains", 1, {
+            sourceColumn: fk.referencedColumn,
+            targetColumn: fk.columnName
+          });
+        }
+      }
+    }
+    logger6.info({ tables: tables.length }, "Graph populated from schema");
+  }
+  onEvent(entity, eventType, primaryKey, data) {
+    const entityNode = this.store.getNodeByRef("entity", entity);
+    if (!entityNode) return;
+    eventCounter++;
+    const refId = `event:${Date.now()}-${eventCounter}`;
+    const label = `${entity} ${eventType}`;
+    const eventNodeId = this.store.upsertNode("event", refId, label, {
+      eventType,
+      primaryKey,
+      ...data
+    });
+    this.store.addEdge(eventNodeId, entityNode.id, "detected_on");
+  }
+  onInsight(insight) {
+    const entityNode = this.store.getNodeByRef("entity", insight.entity);
+    if (!entityNode) return;
+    insightCounter++;
+    const nodeType = HIGH_SEVERITY.has(insight.severity) ? "anomaly" : "insight";
+    const refId = `${nodeType}:${Date.now()}-${insightCounter}`;
+    const nodeId = this.store.upsertNode(nodeType, refId, insight.message, {
+      insightType: insight.insightType,
+      severity: insight.severity,
+      ...insight.context
+    });
+    this.store.addEdge(nodeId, entityNode.id, "detected_on");
+  }
+  addCorrelation(entityA, entityB, weight = 1) {
+    const nodeA = this.store.getNodeByRef("entity", entityA);
+    const nodeB = this.store.getNodeByRef("entity", entityB);
+    if (!nodeA || !nodeB) return;
+    this.store.addEdge(nodeA.id, nodeB.id, "correlates", weight);
+  }
+};
+
+// src/actions/action-registry.ts
+var ActionRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  governance;
+  constructor(governance) {
+    this.governance = governance ?? {};
+  }
+  register(name, handler, description) {
+    if (this.handlers.has(name)) {
+      throw new Error(`Action handler "${name}" is already registered`);
+    }
+    this.handlers.set(name, { name, handler, description });
+  }
+  getHandler(name) {
+    return this.handlers.get(name);
+  }
+  has(name) {
+    return this.handlers.has(name);
+  }
+  getNames() {
+    return Array.from(this.handlers.keys());
+  }
+  getGovernance(actionName) {
+    const level = this.governance[actionName];
+    if (level === "auto_approve" || level === "require_approval" || level === "never_automate") {
+      return level;
+    }
+    return "require_approval";
+  }
+};
+
+// src/actions/action-matcher.ts
+var DEFAULT_CONFIDENCE = 0.5;
+var ActionMatcher = class {
+  rules;
+  constructor(rules) {
+    this.rules = rules;
+  }
+  match(insight, confidence) {
+    const effectiveConfidence = confidence ?? DEFAULT_CONFIDENCE;
+    const matched = [];
+    for (const rule of this.rules) {
+      const threshold = rule.confidence ?? DEFAULT_CONFIDENCE;
+      if (effectiveConfidence < threshold) {
+        continue;
+      }
+      if (!this.matchesConditions(rule, insight)) {
+        continue;
+      }
+      matched.push(rule);
+    }
+    return matched;
+  }
+  matchesConditions(rule, insight) {
+    const { when } = rule;
+    if (when.severity && when.severity.length > 0) {
+      if (!when.severity.includes(insight.severity)) {
+        return false;
+      }
+    }
+    if (when.insightType && when.insightType.length > 0) {
+      if (!when.insightType.includes(insight.insightType)) {
+        return false;
+      }
+    }
+    if (when.entity && when.entity.length > 0) {
+      if (!when.entity.includes(insight.entity)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/actions/action-executor.ts
+import { EventEmitter } from "events";
+var logger7 = createLogger({ name: "action-executor" });
+var ActionExecutor = class extends EventEmitter {
+  registry;
+  matcher;
+  storage;
+  constructor(registry, matcher, storage) {
+    super();
+    this.registry = registry;
+    this.matcher = matcher;
+    this.storage = storage;
+  }
+  async onInsight(insight) {
+    const confidence = this.computeConfidence(insight);
+    const matchedRules = this.matcher.match(insight, confidence);
+    for (const rule of matchedRules) {
+      await this.processRule(rule, insight, confidence);
+    }
+  }
+  async processRule(rule, insight, confidence) {
+    const governance = this.registry.getGovernance(rule.action);
+    const handler = this.registry.getHandler(rule.action);
+    let status = "pending";
+    if (governance === "never_automate") {
+      status = "blocked";
+    } else if (governance === "auto_approve" && handler) {
+      status = "executed";
+    }
+    const insightId = `insight:${insight.entity}:${insight.insightType}:${Date.now()}`;
+    const recData = {
+      action: rule.action,
+      reason: insight.message,
+      confidence,
+      status: status === "executed" ? "executed" : status,
+      governance,
+      insightId,
+      entity: insight.entity,
+      context: JSON.stringify(insight.context)
+    };
+    const recId = this.storage.saveRecommendation(recData);
+    const emitRec = {
+      id: recId,
+      action: rule.action,
+      reason: insight.message,
+      confidence,
+      status,
+      governance,
+      insightId,
+      entity: insight.entity,
+      context: insight.context
+    };
+    if (status === "executed" && handler) {
+      try {
+        const actionContext = {
+          insight,
+          entity: insight.entity,
+          recommendation: {
+            id: recId,
+            action: rule.action,
+            reason: insight.message,
+            confidence,
+            status: "executed",
+            governance,
+            insightId,
+            entity: insight.entity,
+            context: insight.context,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            resolvedAt: null,
+            resolvedBy: null
+          }
+        };
+        await handler.handler(actionContext);
+        this.emit("action:executed", emitRec);
+        logger7.info({ action: rule.action, entity: insight.entity }, "Action executed");
+      } catch (error) {
+        this.storage.updateRecommendationStatus(recId, "failed", "auto");
+        emitRec.status = "failed";
+        this.emit("action:failed", { ...emitRec, error: error.message });
+        logger7.error({ action: rule.action, error: error.message }, "Action failed");
+      }
+    }
+    this.emit("recommendation", emitRec);
+  }
+  computeConfidence(insight) {
+    const severityWeights = {
+      critical: 0.95,
+      high: 0.8,
+      medium: 0.6,
+      low: 0.4
+    };
+    return severityWeights[insight.severity] ?? 0.5;
+  }
+};
+
+// src/behavioral/watcher.ts
+var Watcher = class {
+  config;
+  detector;
+  classifier;
+  logger = createLogger({ name: "watcher" });
+  patternEngine = null;
+  transitionTracker = null;
+  analyticsEngine = null;
+  graphPopulator = null;
+  actionExecutor = null;
+  stuckInterval = null;
+  analyticsInterval = null;
+  interval = null;
+  stream = null;
+  _streaming = false;
+  watchConfigs = [];
+  constructor(config) {
+    this.config = config;
+    this.detector = new ChangeDetector(config.connector, config.dbType);
+    this.classifier = new EventClassifier(config.storage);
+    if (config.workflows && Object.keys(config.workflows).length > 0) {
+      this.transitionTracker = new TransitionTracker(
+        config.workflows,
+        config.storage,
+        (insight) => {
+          config.onInsight?.(insight);
+          this.graphPopulator?.onInsight(insight);
+          this.actionExecutor?.onInsight(insight);
+        }
+      );
+    }
+    const hasAnalytics = config.analytics && (Object.keys(config.analytics.correlations ?? {}).length > 0 || Object.keys(config.analytics.distributions ?? {}).length > 0);
+    if (hasAnalytics) {
+      const analyticsStorage = {
+        saveCorrelationEvent: config.storage.saveCorrelationEvent.bind(config.storage),
+        getCorrelationEvents: config.storage.getCorrelationEvents.bind(config.storage),
+        saveCorrelationRate: config.storage.saveCorrelationRate.bind(config.storage),
+        getCorrelationRates: config.storage.getCorrelationRates.bind(config.storage),
+        saveHistogramBucket: config.storage.saveHistogramBucket.bind(config.storage),
+        getHistogramBuckets: config.storage.getHistogramBuckets.bind(config.storage),
+        saveTemporalPattern: config.storage.saveTemporalPattern.bind(config.storage),
+        getTemporalPatterns: config.storage.getTemporalPatterns.bind(config.storage),
+        saveInsight: config.storage.saveInsight.bind(config.storage),
+        getBaseline: config.storage.getAnalyticsBaseline.bind(config.storage),
+        saveBaseline: config.storage.saveAnalyticsBaseline.bind(config.storage)
+      };
+      this.analyticsEngine = new AnalyticsEngine(
+        config.analytics,
+        analyticsStorage,
+        (insight) => {
+          config.onInsight?.(insight);
+          this.graphPopulator?.onInsight(insight);
+          this.actionExecutor?.onInsight(insight);
+        }
+      );
+    }
+    if (config.knowledge?.enabled) {
+      const graphStore = new GraphStore({
+        saveKgNode: config.storage.saveKgNode.bind(config.storage),
+        getKgNode: config.storage.getKgNode.bind(config.storage),
+        getKgNodeByRef: config.storage.getKgNodeByRef.bind(config.storage),
+        getKgNodesByType: config.storage.getKgNodesByType.bind(config.storage),
+        getAllKgNodes: config.storage.getAllKgNodes.bind(config.storage),
+        deleteKgNode: config.storage.deleteKgNode.bind(config.storage),
+        saveKgEdge: config.storage.saveKgEdge.bind(config.storage),
+        getKgEdgesFrom: config.storage.getKgEdgesFrom.bind(config.storage),
+        getKgEdgesTo: config.storage.getKgEdgesTo.bind(config.storage),
+        getAllKgEdges: config.storage.getAllKgEdges.bind(config.storage),
+        getKgSummary: config.storage.getKgSummary.bind(config.storage)
+      });
+      this.graphPopulator = new GraphPopulator(graphStore);
+      this.graphPopulator.populateFromSchema(config.tables);
+    }
+    if (config.actions?.enabled && config.actions.rules && config.actions.rules.length > 0) {
+      const actionRegistry = config.actionRegistry ?? new ActionRegistry(config.actions.governance);
+      const actionMatcher = new ActionMatcher(config.actions.rules);
+      const actionStorage = {
+        saveRecommendation: config.storage.saveRecommendation.bind(config.storage),
+        getRecommendation: config.storage.getRecommendation.bind(config.storage),
+        updateRecommendationStatus: config.storage.updateRecommendationStatus.bind(config.storage)
+      };
+      this.actionExecutor = new ActionExecutor(actionRegistry, actionMatcher, actionStorage);
+      this.actionExecutor.on("recommendation", (rec) => {
+        config.onRecommendation?.(rec);
+      });
+      this.actionExecutor.on("action:executed", (rec) => {
+        config.onActionExecuted?.(rec);
+      });
+      this.actionExecutor.on("action:failed", (rec) => {
+        config.onActionFailed?.(rec);
+      });
+    }
+  }
+  async start(options) {
+    if (this.interval || this.stream) throw new Error("Watcher already running");
+    this.patternEngine = new PatternEngine(this.config.storage, {
+      anomalyThreshold: options?.anomalyThreshold
+    });
+    if (options?.once) {
+      this.watchConfigs = ChangeDetector.buildWatchConfigs(
+        this.config.tables,
+        options?.excludeTables
+      );
+      for (const wc of this.watchConfigs) {
+        const saved = this.config.storage.getWatermark(wc.tableName, wc.tableSchema);
+        if (saved?.lastSeenValue) {
+          wc.lastSeenValue = saved.lastSeenValue;
+        }
+      }
+      await this.pollCycle(options?.excludeColumns);
+      return;
+    }
+    if (!options?.preferPolling && this.config.connectionConfig) {
+      const started = await this.tryStartStreaming(options);
+      if (started) {
+        this.startStuckCheckInterval(options);
+        return;
+      }
+    }
+    this.watchConfigs = ChangeDetector.buildWatchConfigs(
+      this.config.tables,
+      options?.excludeTables
+    );
+    for (const config of this.watchConfigs) {
+      const saved = this.config.storage.getWatermark(config.tableName, config.tableSchema);
+      if (saved?.lastSeenValue) {
+        config.lastSeenValue = saved.lastSeenValue;
+      }
+    }
+    const excludeColumns = options?.excludeColumns;
+    const intervalMs = options?.interval ?? 5e3;
+    this.interval = setInterval(async () => {
+      await this.pollCycle(excludeColumns);
+    }, intervalMs);
+    this.startStuckCheckInterval(options);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.stuckInterval) {
+      clearInterval(this.stuckInterval);
+      this.stuckInterval = null;
+    }
+    if (this.analyticsInterval) {
+      clearInterval(this.analyticsInterval);
+      this.analyticsInterval = null;
+    }
+    if (this.stream) {
+      this.stream.stop().catch((err) => {
+        this.logger.error({ error: err.message }, "Error stopping stream");
+      });
+      this.stream = null;
+    }
+    this._streaming = false;
+  }
+  async cleanup() {
+    const stream = this.stream;
+    this.stop();
+    if (stream) {
+      await stream.cleanup();
+    }
+  }
+  isRunning() {
+    return this.interval !== null || this.stream !== null && this.stream.isRunning();
+  }
+  isStreaming() {
+    return this._streaming;
+  }
+  startStuckCheckInterval(options) {
+    if (this.transitionTracker) {
+      this.stuckInterval = setInterval(() => {
+        this.transitionTracker?.checkStuck();
+      }, options?.stuckCheckInterval ?? 6e4);
+    }
+    if (this.analyticsEngine) {
+      this.analyticsInterval = setInterval(() => {
+        this.analyticsEngine?.runPeriodicChecks();
+      }, options?.stuckCheckInterval ?? 6e4);
+    }
+  }
+  async tryStartStreaming(options) {
+    const capDetector = new CapabilityDetector(this.config.connector, this.config.dbType);
+    const capability = await capDetector.detect();
+    if (!capability.canStream) {
+      this.logger.info({ reason: capability.reason }, "Streaming not available, will use polling");
+      return false;
+    }
+    try {
+      const stream = await this.createStream();
+      if (!stream) {
+        this.logger.info("Streaming package not installed. Falling back to polling.");
+        return false;
+      }
+      await stream.start((change) => {
+        this.handleChange(change, options?.excludeColumns);
+      });
+      this.stream = stream;
+      this._streaming = true;
+      this.logger.info("Using streaming mode for change detection");
+      return true;
+    } catch (error) {
+      this.logger.error({ error: error.message }, "Failed to start streaming, falling back to polling");
+      return false;
+    }
+  }
+  async createStream() {
+    if (this.config.dbType === "postgres" || this.config.dbType === "cockroachdb") {
+      try {
+        const { PostgresStream } = await import("./postgres-stream-A7EVYUX2.js");
+        return new PostgresStream(this.config.connectionConfig, this.config.connector);
+      } catch {
+        return null;
+      }
+    }
+    if (this.config.dbType === "mysql" || this.config.dbType === "mariadb") {
+      try {
+        const { MySQLStream } = await import("./mysql-stream-YCNLPPPG.js");
+        return new MySQLStream(this.config.connectionConfig, this.config.connector);
+      } catch {
+        return null;
+      }
+    }
+    if (this.config.dbType === "mongodb") {
+      try {
+        const { MongoDBStream } = await import("./mongodb-stream-Q23UHLTM.js");
+        return new MongoDBStream(this.config.connectionConfig);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  handleChange(change, excludeColumns) {
+    const event = this.classifier.classify(change, { excludeColumns });
+    this.config.storage.saveEvent({
+      eventType: `${event.entity} ${event.type}`,
+      entity: event.entity,
+      tableName: event.table,
+      operation: change.operation,
+      rowId: String(event.primaryKey),
+      rowData: JSON.stringify(event.metadata)
+    });
+    this.config.onEvent?.(event);
+    if (this.patternEngine) {
+      this.patternEngine.updateBaselines([event.entity], change.operation);
+      const anomalies = this.patternEngine.checkRateAnomalies([event.entity], change.operation);
+      for (const anomaly of anomalies) {
+        this.config.onAnomaly?.(anomaly);
+      }
+    }
+    if (this.transitionTracker && change.operation === "UPDATE") {
+      this.transitionTracker.handleChange(change);
+    }
+    if (this.analyticsEngine) {
+      this.analyticsEngine.handleEvent(
+        event.entity,
+        event.type,
+        String(event.primaryKey),
+        event.metadata,
+        change.detectedAt
+      );
+    }
+    if (this.graphPopulator) {
+      this.graphPopulator.onEvent(
+        event.entity,
+        event.type,
+        String(event.primaryKey),
+        event.metadata
+      );
+    }
+    return event.entity;
+  }
+  async pollCycle(excludeColumns) {
+    const allEntities = /* @__PURE__ */ new Set();
+    for (const config of this.watchConfigs) {
+      try {
+        const changes = await this.detector.poll(config);
+        for (const change of changes) {
+          const entity = this.handleChange(change, excludeColumns);
+          allEntities.add(entity);
+        }
+        if (changes.length > 0) {
+          const lastChange = changes[changes.length - 1];
+          const lastValue = config.strategy === "timestamp" ? String(lastChange.newData?.[config.timestampColumn] ?? "") : String(lastChange.primaryKey);
+          config.lastSeenValue = lastValue;
+        }
+        this.config.storage.saveWatermark({
+          tableName: config.tableName,
+          tableSchema: config.tableSchema,
+          strategy: config.strategy,
+          timestampColumn: config.timestampColumn,
+          pkColumn: config.primaryKeyColumn,
+          lastSeenValue: config.lastSeenValue
+        });
+      } catch (error) {
+        this.logger.error({ table: config.tableName, error: error.message }, "Poll error");
+      }
+    }
+  }
+};
+
+// src/knowledge/traversal.ts
+var DEFAULT_MAX_DEPTH = 5;
+var Traversal = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  causesOf(nodeId, maxDepth = DEFAULT_MAX_DEPTH) {
+    return this.bfs(nodeId, "backward", maxDepth);
+  }
+  impactOf(nodeId, maxDepth = DEFAULT_MAX_DEPTH) {
+    return this.bfs(nodeId, "forward", maxDepth);
+  }
+  timeline(nodeId) {
+    const neighbors = this.store.neighbors(nodeId);
+    return neighbors.sort((a, b) => {
+      if (a.timestamp > b.timestamp) return -1;
+      if (a.timestamp < b.timestamp) return 1;
+      return 0;
+    });
+  }
+  bfs(startId, direction, maxDepth) {
+    const visited = /* @__PURE__ */ new Set();
+    visited.add(startId);
+    const result = [];
+    let currentLevel = [startId];
+    for (let depth = 0; depth < maxDepth && currentLevel.length > 0; depth++) {
+      const nextLevel = [];
+      for (const nodeId of currentLevel) {
+        const edges = direction === "forward" ? this.store.getEdgesFrom(nodeId, "causes") : this.store.getEdgesTo(nodeId, "causes");
+        for (const edge of edges) {
+          const neighborId = direction === "forward" ? edge.targetId : edge.sourceId;
+          if (!visited.has(neighborId)) {
+            visited.add(neighborId);
+            const node = this.store.getNode(neighborId);
+            if (node) {
+              result.push(node);
+              nextLevel.push(neighborId);
+            }
+          }
+        }
+      }
+      currentLevel = nextLevel;
+    }
+    return result;
+  }
+};
+
+// src/knowledge/entity-intelligence.ts
+var MAX_RECENT_INSIGHTS = 10;
+var EntityIntelligence = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  forEntity(refId) {
+    const entityNode = this.store.getNodeByRef("entity", refId);
+    if (!entityNode) return void 0;
+    const containsEdges = this.store.getEdgesFrom(entityNode.id, "contains");
+    const tableCount = containsEdges.length;
+    const incomingEdges = this.store.getEdgesTo(entityNode.id, "detected_on");
+    const connectedNodeIds = incomingEdges.map((e) => e.sourceId);
+    let totalEvents = 0;
+    let anomalyCount = 0;
+    const recentInsights = [];
+    for (const nid of connectedNodeIds) {
+      const node = this.store.getNode(nid);
+      if (!node) continue;
+      if (node.nodeType === "event") totalEvents++;
+      if (node.nodeType === "anomaly") anomalyCount++;
+      if (node.nodeType === "insight") {
+        recentInsights.push(node);
+      }
+    }
+    recentInsights.sort((a, b) => a.timestamp > b.timestamp ? -1 : 1);
+    const limitedInsights = recentInsights.slice(0, MAX_RECENT_INSIGHTS);
+    const correlatesEdges = this.store.getEdgesFrom(entityNode.id, "correlates");
+    const topCorrelations = correlatesEdges.map((edge) => {
+      const targetNode = this.store.getNode(edge.targetId);
+      return targetNode ? { entity: targetNode.label, weight: edge.weight } : null;
+    }).filter((c) => c !== null).sort((a, b) => b.weight - a.weight);
+    const riskScore = totalEvents > 0 ? anomalyCount / totalEvents : 0;
+    return {
+      entityName: entityNode.label,
+      tableCount,
+      totalEvents,
+      anomalyCount,
+      topCorrelations,
+      recentInsights: limitedInsights,
+      riskScore
+    };
+  }
+};
+
+// src/knowledge/export.ts
+function exportGraph(store, rootNodeId) {
+  if (rootNodeId === void 0) {
+    return {
+      nodes: store.getAllNodes(),
+      edges: store.getAllEdges()
+    };
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [rootNodeId];
+  visited.add(rootNodeId);
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    const outgoing = store.getEdgesFrom(nodeId);
+    const incoming = store.getEdgesTo(nodeId);
+    for (const edge of [...outgoing, ...incoming]) {
+      const neighborId = edge.sourceId === nodeId ? edge.targetId : edge.sourceId;
+      if (!visited.has(neighborId)) {
+        visited.add(neighborId);
+        queue.push(neighborId);
+      }
+    }
+  }
+  const nodes = [];
+  for (const id of visited) {
+    const node = store.getNode(id);
+    if (node) nodes.push(node);
+  }
+  const allEdges = store.getAllEdges();
+  const edges = allEdges.filter(
+    (e) => visited.has(e.sourceId) && visited.has(e.targetId)
+  );
+  return { nodes, edges };
+}
+
+// src/notifications/formatters.ts
+var SEVERITY_COLORS = {
+  critical: "#dc2626",
+  high: "#ea580c",
+  medium: "#ca8a04",
+  low: "#2563eb"
+};
+function formatForSlack(trigger, payload) {
+  const severity = payload.severity ?? "info";
+  const color = SEVERITY_COLORS[severity] ?? "#6b7280";
+  const entity = payload.entity ?? "unknown";
+  const message = payload.message ?? JSON.stringify(payload);
+  const timestamp = payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    attachments: [
+      {
+        color,
+        blocks: [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `*[${trigger.toUpperCase()}]* ${message}`
+            }
+          },
+          {
+            type: "context",
+            elements: [
+              {
+                type: "mrkdwn",
+                text: `Entity: *${entity}* | Severity: *${severity}* | ${timestamp}`
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+}
+function formatGeneric(trigger, payload) {
+  return {
+    trigger,
+    timestamp: payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    data: payload
+  };
+}
+
+// src/notifications/notifier.ts
+var Notifier = class {
+  rules;
+  logger = createLogger({ name: "notifier" });
+  constructor(rules) {
+    this.rules = rules;
+  }
+  async notify(trigger, payload) {
+    const matchingRules = this.rules.filter((rule) => {
+      if (!rule.triggers.includes(trigger)) return false;
+      if (rule.filter?.severity && payload.severity) {
+        if (!rule.filter.severity.includes(payload.severity)) {
+          return false;
+        }
+      }
+      if (rule.filter?.entity && payload.entity) {
+        if (!rule.filter.entity.includes(payload.entity)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    const sends = [];
+    for (const rule of matchingRules) {
+      for (const target of rule.targets) {
+        const body = target.type === "slack" ? formatForSlack(trigger, payload) : formatGeneric(trigger, payload);
+        sends.push(this.send(target.url, body, target.headers));
+      }
+    }
+    const results = await Promise.allSettled(sends);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        this.logger.error({ error: result.reason.message }, "Webhook delivery failed");
+      }
+    }
+  }
+  async send(url, body, headers) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Webhook returned ${response.status}: ${await response.text()}`);
+    }
+  }
+};
+
+// src/explain/context-builder.ts
+var DEFAULT_MAX_EVENTS = 50;
+var DEFAULT_MAX_GRAPH_DEPTH = 3;
+var ExplainContextBuilder = class {
+  storage;
+  graphStore;
+  traversal;
+  constructor(storage, graphStore, traversal) {
+    this.storage = storage;
+    this.graphStore = graphStore ?? null;
+    this.traversal = traversal ?? null;
+  }
+  buildContext(target, options) {
+    const maxEvents = options?.maxContextEvents ?? DEFAULT_MAX_EVENTS;
+    const maxGraphDepth = options?.maxGraphDepth ?? DEFAULT_MAX_GRAPH_DEPTH;
+    switch (target.type) {
+      case "anomaly":
+        return this.buildAnomalyContext(target.id, maxEvents, maxGraphDepth);
+      case "insight":
+        return this.buildInsightContext(target.id, maxEvents, maxGraphDepth);
+      case "event":
+        return this.buildEventContext(target.id, maxEvents);
+      case "entity":
+        return this.buildEntityContext(target.id, maxEvents, maxGraphDepth);
+      default:
+        throw new Error(`Unknown explain target type: ${target.type}`);
+    }
+  }
+  buildAnomalyContext(id, maxEvents, maxGraphDepth) {
+    const anomaly = this.storage.getAnomalyById(id);
+    if (!anomaly) {
+      throw new Error(`Anomaly with id ${id} not found`);
+    }
+    const entity = anomaly.entity;
+    const targetDescription = `Anomaly: ${anomaly.message} (type: ${anomaly.anomalyType}, severity: ${anomaly.severity}, expected: ${anomaly.expected}, actual: ${anomaly.actual}, at: ${anomaly.timestamp})`;
+    return {
+      targetDescription,
+      entityInfo: this.getEntityInfo(entity),
+      recentEvents: this.getRecentEvents(entity, maxEvents),
+      baselines: this.getBaselines(entity),
+      transitions: this.getTransitions(entity),
+      graphContext: this.getGraphContext(entity, maxGraphDepth),
+      correlations: this.getCorrelations(entity)
+    };
+  }
+  buildInsightContext(id, maxEvents, maxGraphDepth) {
+    const insight = this.storage.getInsightById(id);
+    if (!insight) {
+      throw new Error(`Insight with id ${id} not found`);
+    }
+    const entity = insight.entity;
+    const targetDescription = `Insight: ${insight.message} (type: ${insight.insightType}, severity: ${insight.severity}, at: ${insight.timestamp}, context: ${JSON.stringify(insight.context)})`;
+    return {
+      targetDescription,
+      entityInfo: this.getEntityInfo(entity),
+      recentEvents: this.getRecentEvents(entity, maxEvents),
+      baselines: this.getBaselines(entity),
+      transitions: this.getTransitions(entity),
+      graphContext: this.getGraphContext(entity, maxGraphDepth),
+      correlations: this.getCorrelations(entity)
+    };
+  }
+  buildEventContext(id, maxEvents) {
+    const event = this.storage.getEventById(id);
+    if (!event) {
+      throw new Error(`Event with id ${id} not found`);
+    }
+    const entity = event.entity;
+    const targetDescription = `Event: ${event.eventType} on ${event.tableName} (operation: ${event.operation}, row: ${event.rowId}, at: ${event.timestamp})`;
+    return {
+      targetDescription,
+      entityInfo: this.getEntityInfo(entity),
+      recentEvents: this.getRecentEvents(entity, maxEvents),
+      baselines: this.getBaselines(entity),
+      transitions: this.getTransitions(entity),
+      graphContext: "",
+      correlations: this.getCorrelations(entity)
+    };
+  }
+  buildEntityContext(id, maxEvents, maxGraphDepth) {
+    const entities = this.storage.getEntities();
+    const entityRow = entities[id - 1];
+    if (!entityRow) {
+      throw new Error(`Entity with id ${id} not found`);
+    }
+    const entity = entityRow.tableName;
+    const targetDescription = `Entity: ${entityRow.entityLabel} (${entity}, type: ${entityRow.entityType}, description: ${entityRow.description})`;
+    const anomalies = this.storage.getAnomalies({ entity });
+    const insights = this.storage.getInsights({ entity });
+    const anomalySummary = anomalies.length > 0 ? `Recent anomalies (${anomalies.length}): ${anomalies.slice(0, 5).map((a) => `${a.anomalyType}:${a.severity} - ${a.message}`).join("; ")}` : "No anomalies detected";
+    const insightSummary = insights.length > 0 ? `Recent insights (${insights.length}): ${insights.slice(0, 5).map((i) => `${i.insightType}:${i.severity} - ${i.message}`).join("; ")}` : "No insights generated";
+    return {
+      targetDescription: `${targetDescription}
+${anomalySummary}
+${insightSummary}`,
+      entityInfo: this.getEntityInfo(entity),
+      recentEvents: this.getRecentEvents(entity, maxEvents),
+      baselines: this.getBaselines(entity),
+      transitions: this.getTransitions(entity),
+      graphContext: this.getGraphContext(entity, maxGraphDepth),
+      correlations: this.getCorrelations(entity)
+    };
+  }
+  getEntityInfo(entity) {
+    const entityData = this.storage.getEntity(entity);
+    if (!entityData) return `Entity: ${entity} (no classification data)`;
+    return `Entity: ${entityData.entityLabel} (table: ${entity}, type: ${entityData.entityType}, description: ${entityData.description}, confidence: ${entityData.confidence})`;
+  }
+  getRecentEvents(entity, maxEvents) {
+    const events = this.storage.getEvents({ entity });
+    const limited = events.slice(0, maxEvents);
+    if (limited.length === 0) return "No recent events";
+    return limited.map((e) => `[${e.timestamp}] ${e.eventType} ${e.operation} (row: ${e.rowId})`).join("\n");
+  }
+  getBaselines(entity) {
+    const baselines = this.storage.getBaselines();
+    const entityBaselines = baselines.filter((b) => b.entity === entity);
+    if (entityBaselines.length === 0) return "No baselines established";
+    return entityBaselines.map((b) => `${b.metric}: mean=${b.mean.toFixed(2)}, stddev=${b.stddev.toFixed(2)}, samples=${b.sampleSize}`).join("\n");
+  }
+  getTransitions(entity) {
+    const stats = this.storage.getTransitionStats(entity);
+    if (stats.length === 0) return "No state transitions recorded";
+    return stats.map((t) => `${t.fromState} -> ${t.toState}: count=${t.count}, avg=${t.avgDurationMs}ms, min=${t.minDurationMs}ms, max=${t.maxDurationMs}ms`).join("\n");
+  }
+  getGraphContext(entity, maxDepth) {
+    if (!this.graphStore || !this.traversal) return "Knowledge graph not available";
+    const entityNode = this.graphStore.getNodeByRef("entity", entity);
+    if (!entityNode) return "Entity not found in knowledge graph";
+    const neighbors = this.graphStore.neighbors(entityNode.id);
+    const causes = this.traversal.causesOf(entityNode.id, maxDepth);
+    const impacts = this.traversal.impactOf(entityNode.id, maxDepth);
+    const parts = [];
+    if (neighbors.length > 0) {
+      parts.push(`Connected nodes (${neighbors.length}): ${neighbors.map((n) => `${n.nodeType}:${n.label}`).join(", ")}`);
+    }
+    if (causes.length > 0) {
+      parts.push(`Causes (${causes.length}): ${causes.map((n) => `${n.nodeType}:${n.label}`).join(", ")}`);
+    }
+    if (impacts.length > 0) {
+      parts.push(`Impacts (${impacts.length}): ${impacts.map((n) => `${n.nodeType}:${n.label}`).join(", ")}`);
+    }
+    return parts.length > 0 ? parts.join("\n") : "No graph connections found";
+  }
+  getCorrelations(entity) {
+    const rates = this.storage.getCorrelationRates(entity, 24);
+    if (rates.length === 0) return "No correlation data";
+    return `Correlation rates (last 24h): ${rates.slice(0, 10).map((r) => `${r.bucket}:${r.eventCount}`).join(", ")}`;
+  }
+};
+
+// src/explain/explainer.ts
+var logger8 = createLogger({ name: "explainer" });
+var explainCounter = 0;
+function generateExplanationId(target) {
+  explainCounter++;
+  return `exp_${target.type}_${target.id}_${Date.now()}_${explainCounter}`;
+}
+var Explainer = class {
+  llm;
+  contextBuilder;
+  constructor(llm, storage, graphStore, traversal) {
+    this.llm = llm;
+    this.contextBuilder = new ExplainContextBuilder(storage, graphStore, traversal);
+  }
+  async explain(target, options) {
+    logger8.info({ target }, "Building explanation context");
+    const context = this.contextBuilder.buildContext(target, options);
+    const prompt = this.buildPrompt(target, context, options);
+    const chatOptions = { jsonMode: true, maxTokens: 4096 };
+    let response = await this.llm.chat(prompt, chatOptions);
+    try {
+      return this.parseResponse(response.content, target);
+    } catch {
+      logger8.warn("First LLM parse failed, retrying");
+      response = await this.llm.chat(prompt, chatOptions);
+      return this.parseResponse(response.content, target);
+    }
+  }
+  buildPrompt(target, context, options) {
+    const includeRecommendations = options?.includeRecommendations !== false;
+    return `You are a database intelligence analyst. Given the following context about a detected ${target.type}, explain WHY it happened using root cause analysis.
+
+TARGET:
+${context.targetDescription}
+
+CONTEXT:
+
+Entity Information:
+${context.entityInfo}
+
+Recent Events:
+${context.recentEvents}
+
+Baselines:
+${context.baselines}
+
+State Transitions:
+${context.transitions}
+
+Knowledge Graph:
+${context.graphContext}
+
+Correlations:
+${context.correlations}
+
+Analyze the data above and return a JSON object with your explanation. Be specific and reference actual data points from the context.
+
+Return valid JSON in this exact format:
+{
+  "summary": "1-2 sentence human-readable explanation of the root cause",
+  "confidence": 0.85,
+  "evidence": [
+    {
+      "type": "event|baseline|transition|correlation|graph_node",
+      "description": "What this evidence shows",
+      "data": {},
+      "relevance": 0.9
+    }
+  ],
+  "causalChain": [
+    {
+      "order": 1,
+      "description": "First thing that happened",
+      "confidence": 0.8
+    }
+  ]${includeRecommendations ? `,
+  "recommendedActions": [
+    {
+      "action": "What to do",
+      "reason": "Why this helps",
+      "priority": "low|medium|high"
+    }
+  ]` : ""}
+}`;
+  }
+  parseResponse(content, target) {
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (err) {
+      throw new LLMResponseError(
+        `Failed to parse explain response: ${err.message}`,
+        content.slice(0, 500)
+      );
+    }
+    if (!data.summary || typeof data.summary !== "string") {
+      throw new LLMResponseError('Invalid explain response: missing "summary"', content.slice(0, 500));
+    }
+    return {
+      explanationId: generateExplanationId(target),
+      target,
+      summary: data.summary,
+      confidence: typeof data.confidence === "number" ? data.confidence : 0.5,
+      evidence: Array.isArray(data.evidence) ? data.evidence.map((e) => ({
+        type: e.type ?? "event",
+        description: e.description ?? "",
+        data: e.data ?? {},
+        relevance: typeof e.relevance === "number" ? e.relevance : 0.5
+      })) : [],
+      causalChain: Array.isArray(data.causalChain) ? data.causalChain.map((s, i) => ({
+        order: s.order ?? i + 1,
+        description: s.description ?? "",
+        confidence: typeof s.confidence === "number" ? s.confidence : 0.5
+      })) : [],
+      recommendedActions: Array.isArray(data.recommendedActions) ? data.recommendedActions.map((a) => ({
+        action: a.action ?? "",
+        reason: a.reason ?? "",
+        priority: ["low", "medium", "high"].includes(a.priority) ? a.priority : "medium"
+      })) : [],
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/ask/ask-context-builder.ts
+var DEFAULT_MAX_EVENTS2 = 50;
+var MAX_ANOMALIES = 20;
+var MAX_INSIGHTS = 20;
+var MAX_RECOMMENDATIONS = 10;
+var AskContextBuilder = class {
+  storage;
+  graphStore;
+  constructor(storage, graphStore) {
+    this.storage = storage;
+    this.graphStore = graphStore ?? null;
+  }
+  buildContext(options) {
+    const maxEvents = options?.maxContextEvents ?? DEFAULT_MAX_EVENTS2;
+    const entityHint = options?.entityHint;
+    return {
+      entities: this.getEntities(),
+      recentEvents: this.getRecentEvents(maxEvents, entityHint),
+      baselines: this.getBaselines(),
+      anomalies: this.getAnomalies(),
+      insights: this.getInsights(),
+      transitions: this.getTransitions(),
+      graphSummary: this.getGraphSummary(),
+      recommendations: this.getRecommendations()
+    };
+  }
+  getEntities() {
+    const entities = this.storage.getEntities();
+    if (entities.length === 0) return "No entities discovered yet";
+    return entities.map(
+      (e) => `${e.tableName} (${e.entityLabel}, type: ${e.entityType}, ${e.description})`
+    ).join("\n");
+  }
+  getRecentEvents(maxEvents, entityHint) {
+    const filter = {};
+    if (entityHint) filter.entity = entityHint;
+    const events = this.storage.getEvents(filter);
+    const limited = events.slice(0, maxEvents);
+    if (limited.length === 0) return "No recent events";
+    return `${events.length} total events (showing ${limited.length}):
+` + limited.map(
+      (e) => `[${e.timestamp}] ${e.entity} ${e.eventType} ${e.operation} (row: ${e.rowId})`
+    ).join("\n");
+  }
+  getBaselines() {
+    const baselines = this.storage.getBaselines();
+    if (baselines.length === 0) return "No baselines established";
+    return baselines.map(
+      (b) => `${b.entity}.${b.metric}: mean=${b.mean.toFixed(2)}, stddev=${b.stddev.toFixed(2)}, samples=${b.sampleSize}`
+    ).join("\n");
+  }
+  getAnomalies() {
+    const anomalies = this.storage.getAnomalies();
+    const limited = anomalies.slice(0, MAX_ANOMALIES);
+    if (limited.length === 0) return "No anomalies detected";
+    return `${anomalies.length} total anomalies (showing ${limited.length}):
+` + limited.map(
+      (a) => `[${a.timestamp}] ${a.entity} ${a.anomalyType} (${a.severity}): ${a.message} (expected: ${a.expected}, actual: ${a.actual})`
+    ).join("\n");
+  }
+  getInsights() {
+    const insights = this.storage.getInsights();
+    const limited = insights.slice(0, MAX_INSIGHTS);
+    if (limited.length === 0) return "No insights generated";
+    return `${insights.length} total insights (showing ${limited.length}):
+` + limited.map(
+      (i) => `[${i.timestamp}] ${i.entity} ${i.insightType} (${i.severity}): ${i.message}`
+    ).join("\n");
+  }
+  getTransitions() {
+    const stats = this.storage.getTransitionStats();
+    if (stats.length === 0) return "No state transitions recorded";
+    return stats.map(
+      (t) => `${t.entity}: ${t.fromState} -> ${t.toState} (count=${t.count}, avg=${t.avgDurationMs}ms)`
+    ).join("\n");
+  }
+  getGraphSummary() {
+    if (!this.graphStore) return "Knowledge graph not available";
+    const summary = this.graphStore.getSummary();
+    return `Nodes: ${summary.totalNodes}, Edges: ${summary.totalEdges} (entities: ${summary.entities}, events: ${summary.events}, anomalies: ${summary.anomalies}, insights: ${summary.insights})`;
+  }
+  getRecommendations() {
+    const recs = this.storage.getRecommendations({ last: MAX_RECOMMENDATIONS });
+    if (recs.length === 0) return "No recommendations";
+    return recs.map(
+      (r) => `[${r.status}] ${r.action}: ${r.reason} (confidence: ${r.confidence}, entity: ${r.entity})`
+    ).join("\n");
+  }
+};
+
+// src/ask/asker.ts
+var logger9 = createLogger({ name: "asker" });
+var askCounter = 0;
+function generateAskId() {
+  askCounter++;
+  return `ask_${Date.now()}_${askCounter}`;
+}
+var VALID_SIGNAL_TYPES = /* @__PURE__ */ new Set([
+  "baselineDeviation",
+  "anomaly",
+  "insight",
+  "eventCluster",
+  "transition",
+  "correlation",
+  "graphRelation"
+]);
+var Asker = class {
+  llm;
+  contextBuilder;
+  constructor(llm, storage, graphStore) {
+    this.llm = llm;
+    this.contextBuilder = new AskContextBuilder(storage, graphStore);
+  }
+  async ask(question, options) {
+    logger9.info({ question }, "Processing question");
+    const context = this.contextBuilder.buildContext(options);
+    const prompt = this.buildPrompt(question, context);
+    const chatOptions = { jsonMode: true, maxTokens: 4096 };
+    let response = await this.llm.chat(prompt, chatOptions);
+    try {
+      return this.parseResponse(response.content, question);
+    } catch {
+      logger9.warn("First LLM parse failed, retrying");
+      response = await this.llm.chat(prompt, chatOptions);
+      return this.parseResponse(response.content, question);
+    }
+  }
+  buildPrompt(question, context) {
+    return `You are a database intelligence analyst. You have access to a live monitoring system that tracks a database. Answer the user's question using ONLY the data provided below. Be specific \u2014 reference actual numbers, entity names, and timestamps from the data.
+
+QUESTION: ${question}
+
+SYSTEM STATE:
+
+Entities:
+${context.entities}
+
+Recent Events:
+${context.recentEvents}
+
+Baselines:
+${context.baselines}
+
+Anomalies:
+${context.anomalies}
+
+Insights:
+${context.insights}
+
+State Transitions:
+${context.transitions}
+
+Knowledge Graph:
+${context.graphSummary}
+
+Recommendations:
+${context.recommendations}
+
+Analyze the data and answer the question. If the data doesn't contain enough information, say so honestly and lower your confidence score.
+
+Return valid JSON in this exact format:
+{
+  "answer": "Clear, specific answer referencing actual data points",
+  "confidence": 0.85,
+  "supportingSignals": [
+    {
+      "type": "baselineDeviation|anomaly|insight|eventCluster|transition|correlation|graphRelation",
+      "entity": "entity name",
+      "description": "What this signal shows",
+      "data": {}
+    }
+  ],
+  "relatedEntities": ["entity1", "entity2"],
+  "recommendedActions": ["Action 1", "Action 2"]
+}`;
+  }
+  parseResponse(content, question) {
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (err) {
+      throw new LLMResponseError(
+        `Failed to parse ask response: ${err.message}`,
+        content.slice(0, 500)
+      );
+    }
+    if (!data.answer || typeof data.answer !== "string") {
+      throw new LLMResponseError('Invalid ask response: missing "answer"', content.slice(0, 500));
+    }
+    return {
+      askId: generateAskId(),
+      question,
+      answer: data.answer,
+      confidence: typeof data.confidence === "number" ? data.confidence : 0.5,
+      supportingSignals: Array.isArray(data.supportingSignals) ? data.supportingSignals.map((s) => ({
+        type: VALID_SIGNAL_TYPES.has(s.type) ? s.type : "anomaly",
+        entity: s.entity ?? "",
+        description: s.description ?? "",
+        data: s.data ?? {}
+      })) : [],
+      relatedEntities: Array.isArray(data.relatedEntities) ? data.relatedEntities.filter((e) => typeof e === "string") : [],
+      recommendedActions: Array.isArray(data.recommendedActions) ? data.recommendedActions.filter((a) => typeof a === "string") : [],
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/core/config.ts
+import { cosmiconfig } from "cosmiconfig";
+function defineConfig(config) {
+  return config;
+}
+
+// src/index.ts
+var KnowledgeGraph = class {
+  store;
+  traversal;
+  entityIntelligence;
+  constructor(store) {
+    this.store = store;
+    this.traversal = new Traversal(store);
+    this.entityIntelligence = new EntityIntelligence(store);
+  }
+  causesOf(nodeId, maxDepth) {
+    return this.traversal.causesOf(nodeId, maxDepth);
+  }
+  impactOf(nodeId, maxDepth) {
+    return this.traversal.impactOf(nodeId, maxDepth);
+  }
+  timeline(nodeId) {
+    return this.traversal.timeline(nodeId);
+  }
+  entity(refId) {
+    return {
+      intelligence: () => this.entityIntelligence.forEntity(refId)
+    };
+  }
+  getNode(id) {
+    return this.store.getNode(id);
+  }
+  getNodeByRef(nodeType, refId) {
+    return this.store.getNodeByRef(nodeType, refId);
+  }
+  getEdges(nodeId, edgeType) {
+    return this.store.getEdgesFrom(nodeId, edgeType);
+  }
+  neighbors(nodeId) {
+    return this.store.neighbors(nodeId);
+  }
+  getSummary() {
+    return this.store.getSummary();
+  }
+  export(rootNodeId) {
+    return exportGraph(this.store, rootNodeId);
+  }
+};
+var Cortexa = class extends EventEmitter2 {
+  config;
+  connector = null;
+  storage;
+  logger;
+  llmProvider = null;
+  watcher = null;
+  knowledgeGraph = null;
+  actionRegistry;
+  discoveredTables = [];
+  _status = { connected: false, tables: 0, db: "", watching: false };
+  constructor(config) {
+    super();
+    this.config = config;
+    this.logger = createLogger();
+    this.storage = new CortexaStorage(config.projectRoot ?? process.cwd());
+    this.actionRegistry = new ActionRegistry(config.actions?.governance);
+  }
+  async connect() {
+    this.logger.info("Connecting to database...");
+    this.storage.initialize();
+    this.connector = await createConnector(this.config.connection.type);
+    await this.connector.connect(this.config.connection);
+    const tables = await this.connector.getTableCount();
+    const db = await this.connector.getDatabaseName();
+    const readOnly = await this.connector.isReadOnly();
+    if (!readOnly) {
+      this.logger.warn(
+        "Connection is NOT read-only. Cortexa recommends using a read-only database user."
+      );
+    }
+    if (this.config.llmProvider) {
+      this.llmProvider = this.config.llmProvider;
+    } else if (this.config.llm) {
+      this.llmProvider = createLLMProvider(this.config.llm);
+    }
+    this.storage.setMeta("database_name", db);
+    this.storage.setMeta("table_count", String(tables));
+    this.storage.setMeta("connected_at", (/* @__PURE__ */ new Date()).toISOString());
+    this._status = { connected: true, tables, db, watching: false };
+    this.logger.info({ db, tables }, "Connected successfully");
+  }
+  async disconnect() {
+    this.unwatch();
+    if (this.connector) {
+      await this.connector.disconnect();
+      this.connector = null;
+    }
+    this.llmProvider = null;
+    this.knowledgeGraph = null;
+    this.storage.close();
+    this._status = { connected: false, tables: 0, db: "", watching: false };
+    this.logger.info("Disconnected");
+  }
+  async discover(options) {
+    if (!this.llmProvider) {
+      throw new Error("LLM configuration required for schema discovery. Add llm config to your Cortexa options.");
+    }
+    if (!this.connector) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    this.logger.info("Starting schema discovery...");
+    const introspector = new SchemaIntrospector(this.connector, this.config.connection.type, options);
+    const rawSchema = await introspector.introspect();
+    this.logger.info({ tables: rawSchema.tables.length }, "Schema introspected");
+    const classifier = new SchemaClassifier(this.llmProvider, this.config.batchSize);
+    const entities = await classifier.classify(rawSchema.tables);
+    this.logger.info({ entities: entities.length }, "Entities classified");
+    const graphBuilder = new GraphBuilder();
+    const graph = graphBuilder.build(rawSchema.tables, entities);
+    for (const entity of entities) {
+      this.storage.saveEntity(entity);
+    }
+    this.storage.clearRelationships();
+    for (const rel of graph.relationships) {
+      this.storage.saveRelationship(rel);
+    }
+    for (const table of rawSchema.tables) {
+      this.storage.saveDiscoveredTable(table);
+    }
+    this.discoveredTables = rawSchema.tables;
+    if (this.config.knowledge?.enabled) {
+      const graphStore = new GraphStore(this.storage);
+      const populator = new GraphPopulator(graphStore);
+      populator.populateFromSchema(rawSchema.tables);
+      this.logger.info("Knowledge graph populated from schema");
+    }
+    this.logger.info("Discovery complete");
+    return {
+      entities: graph.entities,
+      relationships: graph.relationships,
+      raw: rawSchema
+    };
+  }
+  entity(tableName) {
+    return this.storage.getEntity(tableName);
+  }
+  exportGraph() {
+    return {
+      entities: this.storage.getEntities(),
+      relationships: this.storage.getRelationships()
+    };
+  }
+  async watch(options) {
+    if (!this.connector) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    this.watcher = new Watcher({
+      connector: this.connector,
+      dbType: this.config.connection.type,
+      storage: this.storage,
+      tables: this.discoveredTables,
+      connectionConfig: this.config.connection,
+      onEvent: (event) => this.emit("event", event),
+      onAnomaly: (anomaly) => this.emit("anomaly", anomaly),
+      onInsight: (insight) => this.emit("insight", insight),
+      onRecommendation: (rec) => this.emit("recommendation", rec),
+      onActionExecuted: (rec) => this.emit("action:executed", rec),
+      onActionFailed: (rec) => this.emit("action:failed", rec),
+      workflows: this.config.reasoning?.workflows,
+      analytics: this.config.analytics,
+      knowledge: this.config.knowledge,
+      actions: this.config.actions,
+      actionRegistry: this.actionRegistry
+    });
+    if (this.config.notifications?.enabled && this.config.notifications.rules?.length) {
+      const notifier = new Notifier(this.config.notifications.rules);
+      this.on("anomaly", (data) => notifier.notify("anomaly", data));
+      this.on("insight", (data) => notifier.notify("insight", data));
+      this.on("recommendation", (data) => notifier.notify("recommendation", data));
+      this.on("action:executed", (data) => notifier.notify("action:executed", data));
+      this.on("action:failed", (data) => notifier.notify("action:failed", data));
+    }
+    await this.watcher.start(options);
+    if (options?.once) {
+      this.watcher = null;
+      this.logger.info("Single poll cycle complete");
+      return;
+    }
+    this._status = { ...this._status, watching: true };
+    this.logger.info("Watcher started");
+  }
+  unwatch() {
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher = null;
+      this._status = { ...this._status, watching: false };
+      this.logger.info("Watcher stopped");
+    }
+  }
+  async cleanupStream() {
+    if (this.watcher) {
+      await this.watcher.cleanup();
+      this.watcher = null;
+      this._status = { ...this._status, watching: false };
+      this.logger.info("Stream cleaned up");
+    }
+  }
+  getEvents(filter) {
+    return this.storage.getEvents(filter);
+  }
+  getBaselines() {
+    return this.storage.getBaselines();
+  }
+  getAnomalies(filter) {
+    return this.storage.getAnomalies(filter);
+  }
+  getInsights(filter) {
+    return this.storage.getInsights(filter);
+  }
+  getTransitions(entity) {
+    return this.storage.getTransitionStats(entity);
+  }
+  getCorrelations() {
+    if (!this.config.analytics?.correlations) {
+      return [];
+    }
+    const results = [];
+    for (const [name, corrConfig] of Object.entries(this.config.analytics.correlations)) {
+      const rateBaseline = this.storage.getAnalyticsBaseline(`correlation:${name}:rate_ratio`);
+      const coOccBaseline = this.storage.getAnalyticsBaseline(`correlation:${name}:co_occurrence`);
+      const rateRatio = rateBaseline ? rateBaseline.mean : 0;
+      const coOccurrenceRate = coOccBaseline ? coOccBaseline.mean : 0;
+      const healthy = !!(rateBaseline && coOccBaseline);
+      results.push({
+        name,
+        entities: corrConfig.entities,
+        rateRatio,
+        baselineRatio: rateBaseline ? rateBaseline.mean : 0,
+        coOccurrenceRate,
+        baselineCoOccurrence: coOccBaseline ? coOccBaseline.mean : 0,
+        healthy
+      });
+    }
+    return results;
+  }
+  getDistributions(entity) {
+    if (!this.config.analytics?.distributions) {
+      return [];
+    }
+    const results = [];
+    for (const [entityName, distConfig] of Object.entries(this.config.analytics.distributions)) {
+      if (entity && entity !== entityName) continue;
+      for (const col of distConfig.columns) {
+        const buckets = this.storage.getHistogramBuckets(entityName, col, "baseline");
+        const shiftBaseline = this.storage.getAnalyticsBaseline(`distribution:${entityName}:${col}:shift`);
+        results.push({
+          entity: entityName,
+          columnName: col,
+          bucketCount: buckets.length,
+          baselineSamples: shiftBaseline ? shiftBaseline.sampleSize : 0,
+          currentShift: shiftBaseline ? shiftBaseline.mean : null,
+          shifted: shiftBaseline ? Math.abs(shiftBaseline.mean) > shiftBaseline.stddev * 2 : false
+        });
+      }
+    }
+    return results;
+  }
+  graph() {
+    if (!this.knowledgeGraph) {
+      const graphStore = new GraphStore(this.storage);
+      this.knowledgeGraph = new KnowledgeGraph(graphStore);
+    }
+    return this.knowledgeGraph;
+  }
+  async explain(target, options) {
+    if (!this.llmProvider) {
+      throw new Error("LLM configuration required for explain(). Add llm config to your Cortexa options.");
+    }
+    const graphStore = new GraphStore(this.storage);
+    const traversal = new Traversal(graphStore);
+    const explainer = new Explainer(this.llmProvider, this.storage, graphStore, traversal);
+    return explainer.explain(target, options);
+  }
+  async ask(question, options) {
+    if (!this.llmProvider) {
+      throw new Error("LLM configuration required for ask(). Add llm config to your Cortexa options.");
+    }
+    const graphStore = new GraphStore(this.storage);
+    const asker = new Asker(this.llmProvider, this.storage, graphStore);
+    return asker.ask(question, options);
+  }
+  registerAction(name, handler, description) {
+    this.actionRegistry.register(name, handler, description);
+  }
+  approveRecommendation(id) {
+    this.storage.updateRecommendationStatus(id, "approved", "user");
+  }
+  rejectRecommendation(id) {
+    this.storage.updateRecommendationStatus(id, "rejected", "user");
+  }
+  getRecommendations(filter) {
+    return this.storage.getRecommendations(filter);
+  }
+  get status() {
+    return { ...this._status };
+  }
+};
+export {
+  Cortexa,
+  KnowledgeGraph,
+  defineConfig
+};
+//# sourceMappingURL=index.js.map