teleton 0.1.0

package/dist/chunk-WDUHRPGA.js

@@ -0,0 +1,1930 @@
+// src/memory/database.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import * as sqliteVec from "sqlite-vec";
+
+// src/memory/schema.ts
+function compareSemver(a, b) {
+  const parseVersion = (v) => {
+    const parts = v.split("-")[0].split(".").map(Number);
+    return {
+      major: parts[0] || 0,
+      minor: parts[1] || 0,
+      patch: parts[2] || 0
+    };
+  };
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  return 0;
+}
+function versionLessThan(a, b) {
+  return compareSemver(a, b) < 0;
+}
+function ensureSchema(db) {
+  db.exec(`
+    -- ============================================
+    -- METADATA
+    -- ============================================
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+
+    -- ============================================
+    -- AGENT MEMORY (Knowledge Base)
+    -- ============================================
+
+    -- Knowledge chunks from MEMORY.md, memory/*.md, learned facts
+    CREATE TABLE IF NOT EXISTS knowledge (
+      id TEXT PRIMARY KEY,
+      source TEXT NOT NULL CHECK(source IN ('memory', 'session', 'learned')),
+      path TEXT,
+      text TEXT NOT NULL,
+      embedding TEXT,
+      start_line INTEGER,
+      end_line INTEGER,
+      hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_knowledge_source ON knowledge(source);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_hash ON knowledge(hash);
+    CREATE INDEX IF NOT EXISTS idx_knowledge_updated ON knowledge(updated_at DESC);
+
+    -- Full-text search for knowledge
+    CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts USING fts5(
+      text,
+      id UNINDEXED,
+      path UNINDEXED,
+      source UNINDEXED,
+      content='knowledge',
+      content_rowid='rowid'
+    );
+
+    -- FTS triggers
+    CREATE TRIGGER IF NOT EXISTS knowledge_fts_insert AFTER INSERT ON knowledge BEGIN
+      INSERT INTO knowledge_fts(rowid, text, id, path, source)
+      VALUES (new.rowid, new.text, new.id, new.path, new.source);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS knowledge_fts_delete AFTER DELETE ON knowledge BEGIN
+      DELETE FROM knowledge_fts WHERE rowid = old.rowid;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS knowledge_fts_update AFTER UPDATE ON knowledge BEGIN
+      DELETE FROM knowledge_fts WHERE rowid = old.rowid;
+      INSERT INTO knowledge_fts(rowid, text, id, path, source)
+      VALUES (new.rowid, new.text, new.id, new.path, new.source);
+    END;
+
+    -- Sessions/Conversations
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,               -- session_id (UUID)
+      chat_id TEXT UNIQUE NOT NULL,      -- telegram:chat_id
+      started_at INTEGER NOT NULL,       -- createdAt (Unix timestamp ms)
+      updated_at INTEGER NOT NULL,       -- updatedAt (Unix timestamp ms)
+      ended_at INTEGER,                  -- Optional end time
+      summary TEXT,                      -- Session summary
+      message_count INTEGER DEFAULT 0,   -- Number of messages
+      tokens_used INTEGER DEFAULT 0,     -- Deprecated (use context_tokens)
+      last_message_id INTEGER,           -- Last Telegram message ID
+      last_channel TEXT,                 -- Last channel (telegram/discord/etc)
+      last_to TEXT,                      -- Last recipient
+      context_tokens INTEGER,            -- Current context size
+      model TEXT,                        -- Model used (claude-opus-4-5-20251101)
+      provider TEXT,                     -- Provider (anthropic)
+      last_reset_date TEXT               -- YYYY-MM-DD of last daily reset
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_chat ON sessions(chat_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
+
+    -- Tasks
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      description TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'done', 'failed', 'cancelled')),
+      priority INTEGER DEFAULT 0,
+      created_by TEXT,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      started_at INTEGER,
+      completed_at INTEGER,
+      result TEXT,
+      error TEXT,
+      scheduled_for INTEGER,
+      payload TEXT,
+      reason TEXT,
+      scheduled_message_id INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority DESC, created_at ASC);
+    CREATE INDEX IF NOT EXISTS idx_tasks_scheduled ON tasks(scheduled_for) WHERE scheduled_for IS NOT NULL;
+
+    -- Task Dependencies (for chained tasks)
+    CREATE TABLE IF NOT EXISTS task_dependencies (
+      task_id TEXT NOT NULL,
+      depends_on_task_id TEXT NOT NULL,
+      PRIMARY KEY (task_id, depends_on_task_id),
+      FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+      FOREIGN KEY (depends_on_task_id) REFERENCES tasks(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_task_deps_task ON task_dependencies(task_id);
+    CREATE INDEX IF NOT EXISTS idx_task_deps_parent ON task_dependencies(depends_on_task_id);
+
+    -- ============================================
+    -- TELEGRAM FEED
+    -- ============================================
+
+    -- Chats (groups, channels, DMs)
+    CREATE TABLE IF NOT EXISTS tg_chats (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL CHECK(type IN ('dm', 'group', 'channel')),
+      title TEXT,
+      username TEXT,
+      member_count INTEGER,
+      is_monitored INTEGER DEFAULT 1,
+      is_archived INTEGER DEFAULT 0,
+      last_message_id TEXT,
+      last_message_at INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tg_chats_type ON tg_chats(type);
+    CREATE INDEX IF NOT EXISTS idx_tg_chats_monitored ON tg_chats(is_monitored, last_message_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_tg_chats_username ON tg_chats(username) WHERE username IS NOT NULL;
+
+    -- Users
+    CREATE TABLE IF NOT EXISTS tg_users (
+      id TEXT PRIMARY KEY,
+      username TEXT,
+      first_name TEXT,
+      last_name TEXT,
+      is_bot INTEGER DEFAULT 0,
+      is_admin INTEGER DEFAULT 0,
+      is_allowed INTEGER DEFAULT 0,
+      first_seen_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      last_seen_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      message_count INTEGER DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tg_users_username ON tg_users(username) WHERE username IS NOT NULL;
+    CREATE INDEX IF NOT EXISTS idx_tg_users_admin ON tg_users(is_admin) WHERE is_admin = 1;
+    CREATE INDEX IF NOT EXISTS idx_tg_users_last_seen ON tg_users(last_seen_at DESC);
+
+    -- Messages
+    CREATE TABLE IF NOT EXISTS tg_messages (
+      id TEXT PRIMARY KEY,
+      chat_id TEXT NOT NULL,
+      sender_id TEXT,
+      text TEXT,
+      embedding TEXT,
+      reply_to_id TEXT,
+      forward_from_id TEXT,
+      is_from_agent INTEGER DEFAULT 0,
+      is_edited INTEGER DEFAULT 0,
+      has_media INTEGER DEFAULT 0,
+      media_type TEXT,
+      timestamp INTEGER NOT NULL,
+      indexed_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      FOREIGN KEY (chat_id) REFERENCES tg_chats(id) ON DELETE CASCADE,
+      FOREIGN KEY (sender_id) REFERENCES tg_users(id) ON DELETE SET NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tg_messages_chat ON tg_messages(chat_id, timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_tg_messages_sender ON tg_messages(sender_id, timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_tg_messages_timestamp ON tg_messages(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_tg_messages_reply ON tg_messages(reply_to_id) WHERE reply_to_id IS NOT NULL;
+    CREATE INDEX IF NOT EXISTS idx_tg_messages_from_agent ON tg_messages(is_from_agent, timestamp DESC) WHERE is_from_agent = 1;
+
+    -- Full-text search for messages
+    CREATE VIRTUAL TABLE IF NOT EXISTS tg_messages_fts USING fts5(
+      text,
+      id UNINDEXED,
+      chat_id UNINDEXED,
+      sender_id UNINDEXED,
+      timestamp UNINDEXED,
+      content='tg_messages',
+      content_rowid='rowid'
+    );
+
+    -- FTS triggers for messages
+    CREATE TRIGGER IF NOT EXISTS tg_messages_fts_insert AFTER INSERT ON tg_messages BEGIN
+      INSERT INTO tg_messages_fts(rowid, text, id, chat_id, sender_id, timestamp)
+      VALUES (new.rowid, new.text, new.id, new.chat_id, new.sender_id, new.timestamp);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS tg_messages_fts_delete AFTER DELETE ON tg_messages BEGIN
+      DELETE FROM tg_messages_fts WHERE rowid = old.rowid;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS tg_messages_fts_update AFTER UPDATE ON tg_messages BEGIN
+      DELETE FROM tg_messages_fts WHERE rowid = old.rowid;
+      INSERT INTO tg_messages_fts(rowid, text, id, chat_id, sender_id, timestamp)
+      VALUES (new.rowid, new.text, new.id, new.chat_id, new.sender_id, new.timestamp);
+    END;
+
+    -- ============================================
+    -- EMBEDDING CACHE
+    -- ============================================
+
+    CREATE TABLE IF NOT EXISTS embedding_cache (
+      hash TEXT PRIMARY KEY,
+      embedding TEXT NOT NULL,
+      model TEXT NOT NULL,
+      provider TEXT NOT NULL,
+      dims INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      accessed_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_embedding_cache_model ON embedding_cache(provider, model);
+    CREATE INDEX IF NOT EXISTS idx_embedding_cache_accessed ON embedding_cache(accessed_at);
+
+    -- =====================================================
+    -- JOURNAL (Trading & Business Operations)
+    -- =====================================================
+
+    CREATE TABLE IF NOT EXISTS journal (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch()),
+      type TEXT NOT NULL CHECK(type IN ('trade', 'gift', 'middleman', 'kol')),
+      action TEXT NOT NULL,
+      asset_from TEXT,
+      asset_to TEXT,
+      amount_from REAL,
+      amount_to REAL,
+      price_ton REAL,
+      counterparty TEXT,
+      platform TEXT,
+      reasoning TEXT,
+      outcome TEXT CHECK(outcome IN ('pending', 'profit', 'loss', 'neutral', 'cancelled')),
+      pnl_ton REAL,
+      pnl_pct REAL,
+      tx_hash TEXT,
+      tool_used TEXT,
+      chat_id TEXT,
+      user_id INTEGER,
+      closed_at INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_journal_type ON journal(type);
+    CREATE INDEX IF NOT EXISTS idx_journal_timestamp ON journal(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_journal_asset_from ON journal(asset_from);
+    CREATE INDEX IF NOT EXISTS idx_journal_outcome ON journal(outcome);
+    CREATE INDEX IF NOT EXISTS idx_journal_type_timestamp ON journal(type, timestamp DESC);
+  `);
+}
+function ensureVectorTables(db, dimensions) {
+  const existingDims = db.prepare(
+    `
+    SELECT sql FROM sqlite_master
+    WHERE type='table' AND name='knowledge_vec'
+  `
+  ).get();
+  if (existingDims?.sql && !existingDims.sql.includes(`[${dimensions}]`)) {
+    db.exec(`DROP TABLE IF EXISTS knowledge_vec`);
+    db.exec(`DROP TABLE IF EXISTS tg_messages_vec`);
+  }
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_vec USING vec0(
+      id TEXT PRIMARY KEY,
+      embedding FLOAT[${dimensions}] distance_metric=cosine
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS tg_messages_vec USING vec0(
+      id TEXT PRIMARY KEY,
+      embedding FLOAT[${dimensions}] distance_metric=cosine
+    );
+  `);
+}
+function getSchemaVersion(db) {
+  const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
+  return row?.value ?? null;
+}
+function setSchemaVersion(db, version) {
+  db.prepare(
+    `
+    INSERT INTO meta (key, value, updated_at)
+    VALUES ('schema_version', ?, unixepoch())
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+  `
+  ).run(version);
+}
+var CURRENT_SCHEMA_VERSION = "1.6.0";
+function runMigrations(db) {
+  const currentVersion = getSchemaVersion(db);
+  if (!currentVersion || versionLessThan(currentVersion, "1.1.0")) {
+    console.log("\u{1F4E6} Running migration: Adding scheduled task columns...");
+    try {
+      const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='tasks'").get();
+      if (!tableExists) {
+        console.log("  Tasks table doesn't exist yet, skipping column migration");
+        setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
+        return;
+      }
+      const tableInfo = db.prepare("PRAGMA table_info(tasks)").all();
+      const existingColumns = tableInfo.map((col) => col.name);
+      if (!existingColumns.includes("scheduled_for")) {
+        db.exec(`ALTER TABLE tasks ADD COLUMN scheduled_for INTEGER`);
+      }
+      if (!existingColumns.includes("payload")) {
+        db.exec(`ALTER TABLE tasks ADD COLUMN payload TEXT`);
+      }
+      if (!existingColumns.includes("reason")) {
+        db.exec(`ALTER TABLE tasks ADD COLUMN reason TEXT`);
+      }
+      if (!existingColumns.includes("scheduled_message_id")) {
+        db.exec(`ALTER TABLE tasks ADD COLUMN scheduled_message_id INTEGER`);
+      }
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_tasks_scheduled ON tasks(scheduled_for) WHERE scheduled_for IS NOT NULL`
+      );
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS task_dependencies (
+          task_id TEXT NOT NULL,
+          depends_on_task_id TEXT NOT NULL,
+          PRIMARY KEY (task_id, depends_on_task_id),
+          FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE,
+          FOREIGN KEY (depends_on_task_id) REFERENCES tasks(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_task_deps_task ON task_dependencies(task_id);
+        CREATE INDEX IF NOT EXISTS idx_task_deps_parent ON task_dependencies(depends_on_task_id);
+      `);
+      console.log("\u2705 Migration 1.1.0 complete: Scheduled tasks support added");
+    } catch (error) {
+      console.error("\u274C Migration 1.1.0 failed:", error);
+      throw error;
+    }
+  }
+  if (!currentVersion || versionLessThan(currentVersion, "1.2.0")) {
+    try {
+      console.log("\u{1F504} Running migration 1.2.0: Extend sessions table for SQLite backend");
+      const addColumnIfNotExists = (table, column, type) => {
+        try {
+          db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+        } catch (e) {
+          if (!e.message.includes("duplicate column name")) {
+            throw e;
+          }
+        }
+      };
+      addColumnIfNotExists(
+        "sessions",
+        "updated_at",
+        "INTEGER NOT NULL DEFAULT (unixepoch() * 1000)"
+      );
+      addColumnIfNotExists("sessions", "last_message_id", "INTEGER");
+      addColumnIfNotExists("sessions", "last_channel", "TEXT");
+      addColumnIfNotExists("sessions", "last_to", "TEXT");
+      addColumnIfNotExists("sessions", "context_tokens", "INTEGER");
+      addColumnIfNotExists("sessions", "model", "TEXT");
+      addColumnIfNotExists("sessions", "provider", "TEXT");
+      addColumnIfNotExists("sessions", "last_reset_date", "TEXT");
+      const sessions = db.prepare("SELECT started_at FROM sessions LIMIT 1").all();
+      if (sessions.length > 0 && sessions[0].started_at < 1e12) {
+        db.exec(
+          "UPDATE sessions SET started_at = started_at * 1000 WHERE started_at < 1000000000000"
+        );
+      }
+      db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC)");
+      console.log("\u2705 Migration 1.2.0 complete: Sessions table extended");
+    } catch (error) {
+      console.error("\u274C Migration 1.2.0 failed:", error);
+      throw error;
+    }
+  }
+  if (!currentVersion || versionLessThan(currentVersion, "1.5.0")) {
+    try {
+      console.log("\u{1F504} Running migration 1.5.0: Add deals system for secure trading");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS deals (
+          id TEXT PRIMARY KEY,
+          status TEXT NOT NULL CHECK(status IN (
+            'proposed', 'accepted', 'payment_claimed', 'verified', 'completed',
+            'declined', 'expired', 'cancelled', 'failed'
+          )),
+
+          -- Parties
+          user_telegram_id INTEGER NOT NULL,
+          user_username TEXT,
+          chat_id TEXT NOT NULL,
+          proposal_message_id INTEGER,
+
+          -- What USER gives
+          user_gives_type TEXT NOT NULL CHECK(user_gives_type IN ('ton', 'gift')),
+          user_gives_ton_amount REAL,
+          user_gives_gift_id TEXT,
+          user_gives_gift_slug TEXT,
+          user_gives_value_ton REAL NOT NULL,
+
+          -- What AGENT gives
+          agent_gives_type TEXT NOT NULL CHECK(agent_gives_type IN ('ton', 'gift')),
+          agent_gives_ton_amount REAL,
+          agent_gives_gift_id TEXT,
+          agent_gives_gift_slug TEXT,
+          agent_gives_value_ton REAL NOT NULL,
+
+          -- Payment/Gift verification
+          user_payment_verified_at INTEGER,
+          user_payment_tx_hash TEXT,
+          user_payment_gift_msgid TEXT,
+          user_payment_wallet TEXT,
+
+          -- Agent send tracking
+          agent_sent_at INTEGER,
+          agent_sent_tx_hash TEXT,
+          agent_sent_gift_msgid TEXT,
+
+          -- Business logic
+          strategy_check TEXT,
+          profit_ton REAL,
+
+          -- Timestamps
+          created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+          expires_at INTEGER NOT NULL,
+          completed_at INTEGER,
+
+          notes TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_deals_status ON deals(status);
+        CREATE INDEX IF NOT EXISTS idx_deals_user ON deals(user_telegram_id);
+        CREATE INDEX IF NOT EXISTS idx_deals_chat ON deals(chat_id);
+        CREATE INDEX IF NOT EXISTS idx_deals_expires ON deals(expires_at)
+          WHERE status IN ('proposed', 'accepted');
+      `);
+      console.log("\u2705 Migration 1.5.0 complete: Deals system added");
+    } catch (error) {
+      console.error("\u274C Migration 1.5.0 failed:", error);
+      throw error;
+    }
+  }
+  if (!currentVersion || versionLessThan(currentVersion, "1.6.0")) {
+    try {
+      console.log("\u{1F504} Running migration 1.6.0: Add bot inline tracking + payment_claimed status");
+      const dealsExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='deals'").get();
+      if (dealsExists) {
+        const tableSql = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='deals'").get()?.sql || "";
+        if (!tableSql.includes("payment_claimed")) {
+          db.exec(`
+            ALTER TABLE deals RENAME TO deals_old;
+
+            CREATE TABLE deals (
+              id TEXT PRIMARY KEY,
+              status TEXT NOT NULL CHECK(status IN (
+                'proposed', 'accepted', 'payment_claimed', 'verified', 'completed',
+                'declined', 'expired', 'cancelled', 'failed'
+              )),
+              user_telegram_id INTEGER NOT NULL,
+              user_username TEXT,
+              chat_id TEXT NOT NULL,
+              proposal_message_id INTEGER,
+              user_gives_type TEXT NOT NULL CHECK(user_gives_type IN ('ton', 'gift')),
+              user_gives_ton_amount REAL,
+              user_gives_gift_id TEXT,
+              user_gives_gift_slug TEXT,
+              user_gives_value_ton REAL NOT NULL,
+              agent_gives_type TEXT NOT NULL CHECK(agent_gives_type IN ('ton', 'gift')),
+              agent_gives_ton_amount REAL,
+              agent_gives_gift_id TEXT,
+              agent_gives_gift_slug TEXT,
+              agent_gives_value_ton REAL NOT NULL,
+              user_payment_verified_at INTEGER,
+              user_payment_tx_hash TEXT,
+              user_payment_gift_msgid TEXT,
+              user_payment_wallet TEXT,
+              agent_sent_at INTEGER,
+              agent_sent_tx_hash TEXT,
+              agent_sent_gift_msgid TEXT,
+              strategy_check TEXT,
+              profit_ton REAL,
+              created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+              expires_at INTEGER NOT NULL,
+              completed_at INTEGER,
+              notes TEXT,
+              inline_message_id TEXT,
+              payment_claimed_at INTEGER
+            );
+
+            INSERT INTO deals (
+              id, status, user_telegram_id, user_username, chat_id, proposal_message_id,
+              user_gives_type, user_gives_ton_amount, user_gives_gift_id, user_gives_gift_slug, user_gives_value_ton,
+              agent_gives_type, agent_gives_ton_amount, agent_gives_gift_id, agent_gives_gift_slug, agent_gives_value_ton,
+              user_payment_verified_at, user_payment_tx_hash, user_payment_gift_msgid, user_payment_wallet,
+              agent_sent_at, agent_sent_tx_hash, agent_sent_gift_msgid,
+              strategy_check, profit_ton, created_at, expires_at, completed_at, notes
+            )
+            SELECT
+              id, status, user_telegram_id, user_username, chat_id, proposal_message_id,
+              user_gives_type, user_gives_ton_amount, user_gives_gift_id, user_gives_gift_slug, user_gives_value_ton,
+              agent_gives_type, agent_gives_ton_amount, agent_gives_gift_id, agent_gives_gift_slug, agent_gives_value_ton,
+              user_payment_verified_at, user_payment_tx_hash, user_payment_gift_msgid, user_payment_wallet,
+              agent_sent_at, agent_sent_tx_hash, agent_sent_gift_msgid,
+              strategy_check, profit_ton, created_at, expires_at, completed_at, notes
+            FROM deals_old;
+
+            DROP TABLE deals_old;
+
+            CREATE INDEX IF NOT EXISTS idx_deals_status ON deals(status);
+            CREATE INDEX IF NOT EXISTS idx_deals_user ON deals(user_telegram_id);
+            CREATE INDEX IF NOT EXISTS idx_deals_chat ON deals(chat_id);
+            CREATE INDEX IF NOT EXISTS idx_deals_inline_msg ON deals(inline_message_id)
+              WHERE inline_message_id IS NOT NULL;
+            CREATE INDEX IF NOT EXISTS idx_deals_payment_claimed ON deals(payment_claimed_at)
+              WHERE payment_claimed_at IS NOT NULL;
+          `);
+        } else {
+          const columns = db.prepare(`PRAGMA table_info(deals)`).all();
+          const columnNames = columns.map((c) => c.name);
+          if (!columnNames.includes("inline_message_id")) {
+            db.exec(`ALTER TABLE deals ADD COLUMN inline_message_id TEXT`);
+          }
+          if (!columnNames.includes("payment_claimed_at")) {
+            db.exec(`ALTER TABLE deals ADD COLUMN payment_claimed_at INTEGER`);
+          }
+        }
+      }
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS user_trade_stats (
+          telegram_id INTEGER PRIMARY KEY,
+          username TEXT,
+          first_trade_at INTEGER DEFAULT (unixepoch()),
+          total_deals INTEGER DEFAULT 0,
+          completed_deals INTEGER DEFAULT 0,
+          declined_deals INTEGER DEFAULT 0,
+          total_ton_sent REAL DEFAULT 0,
+          total_ton_received REAL DEFAULT 0,
+          total_gifts_sent INTEGER DEFAULT 0,
+          total_gifts_received INTEGER DEFAULT 0,
+          last_deal_at INTEGER
+        );
+      `);
+      console.log("\u2705 Migration 1.6.0 complete: Bot inline tracking + payment_claimed added");
+    } catch (error) {
+      console.error("\u274C Migration 1.6.0 failed:", error);
+      throw error;
+    }
+  }
+  setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
+}
+
+// src/memory/database.ts
+var MemoryDatabase = class {
+  db;
+  config;
+  vectorReady = false;
+  constructor(config) {
+    this.config = config;
+    const dir = dirname(config.path);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(config.path, {
+      verbose: process.env.DEBUG_SQL ? console.log : void 0
+    });
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("cache_size = -64000");
+    this.db.pragma("temp_store = MEMORY");
+    this.db.pragma("mmap_size = 30000000000");
+    this.db.pragma("foreign_keys = ON");
+    this.initialize();
+  }
+  initialize() {
+    let currentVersion = null;
+    try {
+      currentVersion = getSchemaVersion(this.db);
+    } catch {
+      currentVersion = null;
+    }
+    if (!currentVersion) {
+      ensureSchema(this.db);
+      runMigrations(this.db);
+    } else if (currentVersion !== CURRENT_SCHEMA_VERSION) {
+      this.migrate(currentVersion, CURRENT_SCHEMA_VERSION);
+    }
+    if (this.config.enableVectorSearch) {
+      this.loadVectorExtension();
+    }
+  }
+  loadVectorExtension() {
+    try {
+      sqliteVec.load(this.db);
+      console.log("\u2705 sqlite-vec loaded successfully");
+      const { vec_version } = this.db.prepare("SELECT vec_version() as vec_version").get();
+      console.log(`   Version: ${vec_version}`);
+      const dims = this.config.vectorDimensions ?? 512;
+      ensureVectorTables(this.db, dims);
+      this.vectorReady = true;
+    } catch (error) {
+      console.warn(
+        `\u26A0\uFE0F  sqlite-vec not available, vector search disabled: ${error.message}`
+      );
+      console.warn("   Falling back to keyword-only search");
+      this.config.enableVectorSearch = false;
+    }
+  }
+  migrate(from, to) {
+    console.log(`Migrating database from ${from} to ${to}...`);
+    runMigrations(this.db);
+    ensureSchema(this.db);
+    console.log("Migration complete");
+  }
+  /**
+   * Get the underlying better-sqlite3 database
+   */
+  getDb() {
+    return this.db;
+  }
+  /**
+   * Check if vector search is available
+   */
+  isVectorSearchReady() {
+    return this.vectorReady;
+  }
+  /**
+   * Get vector dimensions
+   */
+  getVectorDimensions() {
+    return this.config.vectorDimensions;
+  }
+  /**
+   * Execute a function in a transaction
+   */
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  /**
+   * Execute an async function in a transaction
+   */
+  async asyncTransaction(fn) {
+    const beginTrans = this.db.prepare("BEGIN");
+    const commitTrans = this.db.prepare("COMMIT");
+    const rollbackTrans = this.db.prepare("ROLLBACK");
+    beginTrans.run();
+    try {
+      const result = await fn();
+      commitTrans.run();
+      return result;
+    } catch (error) {
+      rollbackTrans.run();
+      throw error;
+    }
+  }
+  /**
+   * Get database stats
+   */
+  getStats() {
+    const knowledge = this.db.prepare(`SELECT COUNT(*) as c FROM knowledge`).get();
+    const sessions = this.db.prepare(`SELECT COUNT(*) as c FROM sessions`).get();
+    const tasks = this.db.prepare(`SELECT COUNT(*) as c FROM tasks`).get();
+    const tgChats = this.db.prepare(`SELECT COUNT(*) as c FROM tg_chats`).get();
+    const tgUsers = this.db.prepare(`SELECT COUNT(*) as c FROM tg_users`).get();
+    const tgMessages = this.db.prepare(`SELECT COUNT(*) as c FROM tg_messages`).get();
+    const embeddingCache = this.db.prepare(`SELECT COUNT(*) as c FROM embedding_cache`).get();
+    return {
+      knowledge: knowledge.c,
+      sessions: sessions.c,
+      tasks: tasks.c,
+      tgChats: tgChats.c,
+      tgUsers: tgUsers.c,
+      tgMessages: tgMessages.c,
+      embeddingCache: embeddingCache.c,
+      vectorSearchEnabled: this.vectorReady
+    };
+  }
+  /**
+   * Vacuum the database to reclaim space
+   */
+  vacuum() {
+    this.db.exec("VACUUM");
+  }
+  /**
+   * Optimize the database (ANALYZE)
+   */
+  optimize() {
+    this.db.exec("ANALYZE");
+  }
+  /**
+   * Rebuild FTS indexes from existing data
+   * Call this if FTS triggers didn't fire correctly
+   */
+  rebuildFtsIndexes() {
+    this.db.exec(`DELETE FROM knowledge_fts`);
+    const knowledgeRows = this.db.prepare(`SELECT rowid, text, id, path, source FROM knowledge`).all();
+    const insertKnowledge = this.db.prepare(
+      `INSERT INTO knowledge_fts(rowid, text, id, path, source) VALUES (?, ?, ?, ?, ?)`
+    );
+    for (const row of knowledgeRows) {
+      insertKnowledge.run(row.rowid, row.text, row.id, row.path, row.source);
+    }
+    this.db.exec(`DELETE FROM tg_messages_fts`);
+    const messageRows = this.db.prepare(
+      `SELECT rowid, text, id, chat_id, sender_id, timestamp FROM tg_messages WHERE text IS NOT NULL`
+    ).all();
+    const insertMessage = this.db.prepare(
+      `INSERT INTO tg_messages_fts(rowid, text, id, chat_id, sender_id, timestamp) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (const row of messageRows) {
+      insertMessage.run(row.rowid, row.text, row.id, row.chat_id, row.sender_id, row.timestamp);
+    }
+    return { knowledge: knowledgeRows.length, messages: messageRows.length };
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db.open) {
+      this.db.close();
+    }
+  }
+};
+var instance = null;
+function getDatabase(config) {
+  if (!instance && !config) {
+    throw new Error("Database not initialized. Provide config on first call.");
+  }
+  if (!instance && config) {
+    instance = new MemoryDatabase(config);
+  }
+  return instance;
+}
+function closeDatabase() {
+  if (instance) {
+    instance.close();
+    instance = null;
+  }
+}
+
+// src/memory/embeddings/provider.ts
+var NoopEmbeddingProvider = class {
+  id = "noop";
+  model = "none";
+  dimensions = 0;
+  async embedQuery(_text) {
+    return [];
+  }
+  async embedBatch(_texts) {
+    return [];
+  }
+};
+
+// src/memory/embeddings/anthropic.ts
+var AnthropicEmbeddingProvider = class {
+  id = "anthropic";
+  model;
+  dimensions;
+  apiKey;
+  baseUrl = "https://api.voyageai.com/v1";
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? "voyage-3-lite";
+    const dims = {
+      "voyage-3": 1024,
+      "voyage-3-lite": 512,
+      "voyage-code-3": 1024,
+      "voyage-finance-2": 1024,
+      "voyage-multilingual-2": 1024,
+      "voyage-law-2": 1024
+    };
+    this.dimensions = dims[this.model] ?? 512;
+  }
+  async embedQuery(text) {
+    const result = await this.embed([text]);
+    return result[0] ?? [];
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
+    const batchSize = 128;
+    const results = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const embeddings = await this.embed(batch);
+      results.push(...embeddings);
+    }
+    return results;
+  }
+  async embed(texts) {
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        input: texts,
+        model: this.model,
+        input_type: "document"
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Voyage API error: ${response.status} ${error}`);
+    }
+    const data = await response.json();
+    return data.data.map((item) => item.embedding);
+  }
+};
+
+// src/memory/embeddings/local.ts
+var LocalEmbeddingProvider = class {
+  id = "local";
+  model;
+  dimensions;
+  hasWarned = false;
+  constructor(config) {
+    this.model = config.model ?? "all-MiniLM-L6-v2";
+    this.dimensions = 384;
+  }
+  async embedQuery(text) {
+    if (!this.hasWarned) {
+      console.warn(
+        "\u26A0\uFE0F  Local embeddings not yet implemented. Returning zero vectors. This will not work for semantic search. Consider using 'anthropic' embedding provider."
+      );
+      this.hasWarned = true;
+    }
+    return new Array(this.dimensions).fill(0);
+  }
+  async embedBatch(texts) {
+    if (!this.hasWarned) {
+      console.warn(
+        "\u26A0\uFE0F  Local embeddings not yet implemented. Returning zero vectors. This will not work for semantic search. Consider using 'anthropic' embedding provider."
+      );
+      this.hasWarned = true;
+    }
+    return texts.map(() => new Array(this.dimensions).fill(0));
+  }
+};
+
+// src/memory/embeddings/index.ts
+function createEmbeddingProvider(config) {
+  switch (config.provider) {
+    case "anthropic":
+      if (!config.apiKey) {
+        throw new Error("API key required for Anthropic embedding provider");
+      }
+      return new AnthropicEmbeddingProvider({
+        apiKey: config.apiKey,
+        model: config.model
+      });
+    case "local":
+      return new LocalEmbeddingProvider({
+        model: config.model
+      });
+    case "none":
+      return new NoopEmbeddingProvider();
+    default:
+      throw new Error(`Unknown embedding provider: ${config.provider}`);
+  }
+}
+function hashText(text) {
+  let hash = 0;
+  for (let i = 0; i < text.length; i++) {
+    const char = text.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function serializeEmbedding(embedding) {
+  return JSON.stringify(embedding);
+}
+function deserializeEmbedding(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function embeddingToBlob(embedding) {
+  return Buffer.from(new Float32Array(embedding).buffer);
+}
+
+// src/memory/agent/knowledge.ts
+import { readFileSync, existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join } from "path";
+var KnowledgeIndexer = class {
+  constructor(db, workspaceDir, embedder, vectorEnabled) {
+    this.db = db;
+    this.workspaceDir = workspaceDir;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+  }
+  /**
+   * Index all memory files
+   */
+  async indexAll() {
+    const files = this.listMemoryFiles();
+    let indexed = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const wasIndexed = await this.indexFile(file);
+      if (wasIndexed) {
+        indexed++;
+      } else {
+        skipped++;
+      }
+    }
+    return { indexed, skipped };
+  }
+  /**
+   * Index a single file
+   */
+  async indexFile(absPath) {
+    if (!existsSync2(absPath) || !absPath.endsWith(".md")) {
+      return false;
+    }
+    const content = readFileSync(absPath, "utf-8");
+    const relPath = absPath.replace(this.workspaceDir + "/", "");
+    const fileHash = hashText(content);
+    const existing = this.db.prepare(`SELECT hash FROM knowledge WHERE path = ? AND source = 'memory' LIMIT 1`).get(relPath);
+    if (existing?.hash === fileHash) {
+      return false;
+    }
+    this.db.prepare(`DELETE FROM knowledge WHERE path = ? AND source = 'memory'`).run(relPath);
+    const chunks = this.chunkMarkdown(content, relPath);
+    const texts = chunks.map((c) => c.text);
+    const embeddings = await this.embedder.embedBatch(texts);
+    const insert = this.db.prepare(`
+      INSERT INTO knowledge (id, source, path, text, embedding, start_line, end_line, hash)
+      VALUES (?, 'memory', ?, ?, ?, ?, ?, ?)
+    `);
+    const insertVec = this.vectorEnabled ? this.db.prepare(`INSERT INTO knowledge_vec (id, embedding) VALUES (?, ?)`) : null;
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const embedding = embeddings[i] ?? [];
+      insert.run(
+        chunk.id,
+        chunk.path,
+        chunk.text,
+        serializeEmbedding(embedding),
+        chunk.startLine,
+        chunk.endLine,
+        chunk.hash
+      );
+      if (insertVec && embedding.length > 0) {
+        insertVec.run(chunk.id, embeddingToBlob(embedding));
+      }
+    }
+    return true;
+  }
+  /**
+   * List all memory files
+   */
+  listMemoryFiles() {
+    const files = [];
+    const memoryMd = join(this.workspaceDir, "MEMORY.md");
+    if (existsSync2(memoryMd)) {
+      files.push(memoryMd);
+    }
+    const memoryDir = join(this.workspaceDir, "memory");
+    if (existsSync2(memoryDir)) {
+      const entries = readdirSync(memoryDir);
+      for (const entry of entries) {
+        const absPath = join(memoryDir, entry);
+        if (statSync(absPath).isFile() && entry.endsWith(".md")) {
+          files.push(absPath);
+        }
+      }
+    }
+    return files;
+  }
+  /**
+   * Chunk markdown content
+   */
+  chunkMarkdown(content, path) {
+    const lines = content.split("\n");
+    const chunks = [];
+    const chunkSize = 500;
+    const overlap = 50;
+    let currentChunk = "";
+    let startLine = 1;
+    let currentLine = 1;
+    for (const line of lines) {
+      currentChunk += line + "\n";
+      if (currentChunk.length >= chunkSize) {
+        const text2 = currentChunk.trim();
+        if (text2.length > 0) {
+          chunks.push({
+            id: hashText(`${path}:${startLine}:${currentLine}`),
+            source: "memory",
+            path,
+            text: text2,
+            startLine,
+            endLine: currentLine,
+            hash: hashText(text2)
+          });
+        }
+        const overlapText = currentChunk.slice(-overlap);
+        currentChunk = overlapText;
+        startLine = currentLine + 1;
+      }
+      currentLine++;
+    }
+    const text = currentChunk.trim();
+    if (text.length > 0) {
+      chunks.push({
+        id: hashText(`${path}:${startLine}:${currentLine}`),
+        source: "memory",
+        path,
+        text,
+        startLine,
+        endLine: currentLine,
+        hash: hashText(text)
+      });
+    }
+    return chunks;
+  }
+};
+
+// src/memory/agent/sessions.ts
+import { randomUUID } from "crypto";
+var SessionStore = class {
+  constructor(db, embedder, vectorEnabled) {
+    this.db = db;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+  }
+  /**
+   * Create a new session
+   */
+  createSession(chatId) {
+    const id = randomUUID();
+    const now = Math.floor(Date.now() / 1e3);
+    this.db.prepare(
+      `
+      INSERT INTO sessions (id, chat_id, started_at, message_count, tokens_used)
+      VALUES (?, ?, ?, 0, 0)
+    `
+    ).run(id, chatId ?? null, now);
+    return {
+      id,
+      chatId,
+      startedAt: new Date(now * 1e3),
+      messageCount: 0,
+      tokensUsed: 0
+    };
+  }
+  /**
+   * End a session with summary
+   */
+  endSession(sessionId, summary, tokensUsed = 0) {
+    const now = Math.floor(Date.now() / 1e3);
+    this.db.prepare(
+      `
+      UPDATE sessions
+      SET ended_at = ?, summary = ?, tokens_used = ?
+      WHERE id = ?
+    `
+    ).run(now, summary, tokensUsed, sessionId);
+  }
+  /**
+   * Update message count for a session
+   */
+  incrementMessageCount(sessionId, count = 1) {
+    this.db.prepare(
+      `
+      UPDATE sessions
+      SET message_count = message_count + ?
+      WHERE id = ?
+    `
+    ).run(count, sessionId);
+  }
+  /**
+   * Get a session by ID
+   */
+  getSession(id) {
+    const row = this.db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      chatId: row.chat_id,
+      startedAt: new Date(row.started_at * 1e3),
+      endedAt: row.ended_at ? new Date(row.ended_at * 1e3) : void 0,
+      summary: row.summary,
+      messageCount: row.message_count,
+      tokensUsed: row.tokens_used
+    };
+  }
+  /**
+   * Get active (not ended) sessions
+   */
+  getActiveSessions() {
+    const rows = this.db.prepare(
+      `
+      SELECT * FROM sessions
+      WHERE ended_at IS NULL
+      ORDER BY started_at DESC
+    `
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      chatId: row.chat_id,
+      startedAt: new Date(row.started_at * 1e3),
+      endedAt: void 0,
+      summary: row.summary,
+      messageCount: row.message_count,
+      tokensUsed: row.tokens_used
+    }));
+  }
+  /**
+   * Get sessions for a specific chat
+   */
+  getSessionsByChat(chatId, limit = 50) {
+    const rows = this.db.prepare(
+      `
+      SELECT * FROM sessions
+      WHERE chat_id = ?
+      ORDER BY started_at DESC
+      LIMIT ?
+    `
+    ).all(chatId, limit);
+    return rows.map((row) => ({
+      id: row.id,
+      chatId: row.chat_id,
+      startedAt: new Date(row.started_at * 1e3),
+      endedAt: row.ended_at ? new Date(row.ended_at * 1e3) : void 0,
+      summary: row.summary,
+      messageCount: row.message_count,
+      tokensUsed: row.tokens_used
+    }));
+  }
+  /**
+   * Index a session for search (after ending)
+   * This creates a knowledge entry from the session summary
+   */
+  async indexSession(sessionId) {
+    const session = this.getSession(sessionId);
+    if (!session || !session.summary) return;
+    try {
+      const knowledgeId = `session:${sessionId}`;
+      const text = `Session from ${session.startedAt.toISOString()}:
+${session.summary}`;
+      const hash = this.hashText(text);
+      let embedding = null;
+      if (this.vectorEnabled) {
+        embedding = await this.embedder.embedQuery(text);
+      }
+      this.db.prepare(
+        `
+        INSERT INTO knowledge (id, source, path, text, hash, created_at, updated_at)
+        VALUES (?, 'session', ?, ?, ?, unixepoch(), unixepoch())
+        ON CONFLICT(id) DO UPDATE SET
+          text = excluded.text,
+          hash = excluded.hash,
+          updated_at = excluded.updated_at
+      `
+      ).run(knowledgeId, sessionId, text, hash);
+      if (embedding && this.vectorEnabled) {
+        const embeddingBuffer = this.serializeEmbedding(embedding);
+        const rowid = this.db.prepare(`SELECT rowid FROM knowledge WHERE id = ?`).get(knowledgeId);
+        this.db.prepare(
+          `
+          INSERT INTO knowledge_vec (rowid, embedding)
+          VALUES (?, ?)
+          ON CONFLICT(rowid) DO UPDATE SET embedding = excluded.embedding
+        `
+        ).run(rowid.rowid, embeddingBuffer);
+      }
+      console.log(`Indexed session ${sessionId} to knowledge base`);
+    } catch (error) {
+      console.error("Error indexing session:", error);
+    }
+  }
+  /**
+   * Delete a session
+   */
+  deleteSession(sessionId) {
+    this.db.prepare(`DELETE FROM sessions WHERE id = ?`).run(sessionId);
+    this.db.prepare(`DELETE FROM knowledge WHERE id = ?`).run(`session:${sessionId}`);
+  }
+  hashText(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+      const char = text.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
+  serializeEmbedding(embedding) {
+    const float32 = new Float32Array(embedding);
+    return Buffer.from(float32.buffer);
+  }
+};
+
+// src/memory/feed/messages.ts
+var MessageStore = class {
+  constructor(db, embedder, vectorEnabled) {
+    this.db = db;
+    this.embedder = embedder;
+    this.vectorEnabled = vectorEnabled;
+  }
+  /**
+   * Ensure chat exists in database
+   */
+  ensureChat(chatId, isGroup = false) {
+    const existing = this.db.prepare(`SELECT id FROM tg_chats WHERE id = ?`).get(chatId);
+    if (!existing) {
+      this.db.prepare(
+        `INSERT INTO tg_chats (id, type, is_monitored) VALUES (?, ?, 1)`
+      ).run(chatId, isGroup ? "group" : "dm");
+    }
+  }
+  /**
+   * Ensure user exists in database
+   */
+  ensureUser(userId) {
+    if (!userId) return;
+    const existing = this.db.prepare(`SELECT id FROM tg_users WHERE id = ?`).get(userId);
+    if (!existing) {
+      this.db.prepare(
+        `INSERT INTO tg_users (id) VALUES (?)`
+      ).run(userId);
+    }
+  }
+  /**
+   * Store a message
+   */
+  async storeMessage(message) {
+    this.ensureChat(message.chatId);
+    if (message.senderId) {
+      this.ensureUser(message.senderId);
+    }
+    const embedding = message.text ? await this.embedder.embedQuery(message.text) : [];
+    this.db.prepare(
+      `
+      INSERT OR REPLACE INTO tg_messages (
+        id, chat_id, sender_id, text, embedding, reply_to_id,
+        is_from_agent, has_media, media_type, timestamp
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      message.id,
+      message.chatId,
+      message.senderId,
+      message.text,
+      serializeEmbedding(embedding),
+      message.replyToId,
+      message.isFromAgent ? 1 : 0,
+      message.hasMedia ? 1 : 0,
+      message.mediaType,
+      message.timestamp
+    );
+    if (this.vectorEnabled && embedding.length > 0 && message.text) {
+      this.db.prepare(`INSERT OR REPLACE INTO tg_messages_vec (id, embedding) VALUES (?, ?)`).run(message.id, embeddingToBlob(embedding));
+    }
+    this.db.prepare(`UPDATE tg_chats SET last_message_at = ?, last_message_id = ? WHERE id = ?`).run(message.timestamp, message.id, message.chatId);
+  }
+  /**
+   * Get recent messages from a chat
+   */
+  getRecentMessages(chatId, limit = 20) {
+    const rows = this.db.prepare(
+      `
+      SELECT id, chat_id, sender_id, text, reply_to_id, is_from_agent, has_media, media_type, timestamp
+      FROM tg_messages
+      WHERE chat_id = ?
+      ORDER BY timestamp DESC
+      LIMIT ?
+    `
+    ).all(chatId, limit);
+    return rows.reverse().map((row) => ({
+      id: row.id,
+      chatId: row.chat_id,
+      senderId: row.sender_id,
+      text: row.text,
+      replyToId: row.reply_to_id ?? void 0,
+      isFromAgent: Boolean(row.is_from_agent),
+      hasMedia: Boolean(row.has_media),
+      mediaType: row.media_type ?? void 0,
+      timestamp: row.timestamp
+    }));
+  }
+};
+
+// src/memory/feed/chats.ts
+var ChatStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create or update a chat
+   */
+  upsertChat(chat) {
+    const now = Math.floor(Date.now() / 1e3);
+    this.db.prepare(
+      `
+      INSERT INTO tg_chats (
+        id, type, title, username, member_count, is_monitored, is_archived,
+        last_message_id, last_message_at, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        title = COALESCE(excluded.title, title),
+        username = COALESCE(excluded.username, username),
+        member_count = COALESCE(excluded.member_count, member_count),
+        last_message_id = COALESCE(excluded.last_message_id, last_message_id),
+        last_message_at = COALESCE(excluded.last_message_at, last_message_at),
+        updated_at = excluded.updated_at
+    `
+    ).run(
+      chat.id,
+      chat.type,
+      chat.title ?? null,
+      chat.username ?? null,
+      chat.memberCount ?? null,
+      chat.isMonitored ?? 1,
+      chat.isArchived ?? 0,
+      chat.lastMessageId ?? null,
+      chat.lastMessageAt ? Math.floor(chat.lastMessageAt.getTime() / 1e3) : null,
+      now,
+      now
+    );
+  }
+  /**
+   * Get a chat by ID
+   */
+  getChat(id) {
+    const row = this.db.prepare(
+      `
+      SELECT * FROM tg_chats WHERE id = ?
+    `
+    ).get(id);
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      type: row.type,
+      title: row.title,
+      username: row.username,
+      memberCount: row.member_count,
+      isMonitored: Boolean(row.is_monitored),
+      isArchived: Boolean(row.is_archived),
+      lastMessageId: row.last_message_id,
+      lastMessageAt: row.last_message_at ? new Date(row.last_message_at * 1e3) : void 0,
+      createdAt: new Date(row.created_at * 1e3),
+      updatedAt: new Date(row.updated_at * 1e3)
+    };
+  }
+  /**
+   * Get active (monitored, non-archived) chats
+   */
+  getActiveChats(limit = 50) {
+    const rows = this.db.prepare(
+      `
+      SELECT * FROM tg_chats
+      WHERE is_monitored = 1 AND is_archived = 0
+      ORDER BY last_message_at DESC NULLS LAST
+      LIMIT ?
+    `
+    ).all(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      type: row.type,
+      title: row.title,
+      username: row.username,
+      memberCount: row.member_count,
+      isMonitored: Boolean(row.is_monitored),
+      isArchived: Boolean(row.is_archived),
+      lastMessageId: row.last_message_id,
+      lastMessageAt: row.last_message_at ? new Date(row.last_message_at * 1e3) : void 0,
+      createdAt: new Date(row.created_at * 1e3),
+      updatedAt: new Date(row.updated_at * 1e3)
+    }));
+  }
+  /**
+   * Update last message info
+   */
+  updateLastMessage(chatId, messageId, timestamp) {
+    this.db.prepare(
+      `
+      UPDATE tg_chats
+      SET last_message_id = ?, last_message_at = ?, updated_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(messageId, Math.floor(timestamp.getTime() / 1e3), chatId);
+  }
+  /**
+   * Archive a chat
+   */
+  archiveChat(chatId) {
+    this.db.prepare(
+      `
+      UPDATE tg_chats
+      SET is_archived = 1, updated_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(chatId);
+  }
+  /**
+   * Unarchive a chat
+   */
+  unarchiveChat(chatId) {
+    this.db.prepare(
+      `
+      UPDATE tg_chats
+      SET is_archived = 0, updated_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(chatId);
+  }
+  /**
+   * Set monitoring status
+   */
+  setMonitored(chatId, monitored) {
+    this.db.prepare(
+      `
+      UPDATE tg_chats
+      SET is_monitored = ?, updated_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(monitored ? 1 : 0, chatId);
+  }
+};
+
+// src/memory/feed/users.ts
+var UserStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create or update a user
+   */
+  upsertUser(user) {
+    const now = Math.floor(Date.now() / 1e3);
+    const existing = this.db.prepare(`SELECT id FROM tg_users WHERE id = ?`).get(user.id);
+    if (existing) {
+      this.db.prepare(
+        `
+        UPDATE tg_users
+        SET
+          username = COALESCE(?, username),
+          first_name = COALESCE(?, first_name),
+          last_name = COALESCE(?, last_name),
+          last_seen_at = ?
+        WHERE id = ?
+      `
+      ).run(user.username ?? null, user.firstName ?? null, user.lastName ?? null, now, user.id);
+    } else {
+      this.db.prepare(
+        `
+        INSERT INTO tg_users (
+          id, username, first_name, last_name, is_bot, is_admin, is_allowed,
+          first_seen_at, last_seen_at, message_count
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `
+      ).run(
+        user.id,
+        user.username ?? null,
+        user.firstName ?? null,
+        user.lastName ?? null,
+        user.isBot ?? 0,
+        user.isAdmin ?? 0,
+        user.isAllowed ?? 0,
+        now,
+        now,
+        0
+      );
+    }
+  }
+  /**
+   * Get a user by ID
+   */
+  getUser(id) {
+    const row = this.db.prepare(`SELECT * FROM tg_users WHERE id = ?`).get(id);
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      username: row.username,
+      firstName: row.first_name,
+      lastName: row.last_name,
+      isBot: Boolean(row.is_bot),
+      isAdmin: Boolean(row.is_admin),
+      isAllowed: Boolean(row.is_allowed),
+      firstSeenAt: new Date(row.first_seen_at * 1e3),
+      lastSeenAt: new Date(row.last_seen_at * 1e3),
+      messageCount: row.message_count
+    };
+  }
+  /**
+   * Get a user by username
+   */
+  getUserByUsername(username) {
+    const row = this.db.prepare(`SELECT * FROM tg_users WHERE username = ?`).get(username.replace("@", ""));
+    if (!row) return void 0;
+    return {
+      id: row.id,
+      username: row.username,
+      firstName: row.first_name,
+      lastName: row.last_name,
+      isBot: Boolean(row.is_bot),
+      isAdmin: Boolean(row.is_admin),
+      isAllowed: Boolean(row.is_allowed),
+      firstSeenAt: new Date(row.first_seen_at * 1e3),
+      lastSeenAt: new Date(row.last_seen_at * 1e3),
+      messageCount: row.message_count
+    };
+  }
+  /**
+   * Update last seen timestamp
+   */
+  updateLastSeen(userId) {
+    this.db.prepare(
+      `
+      UPDATE tg_users
+      SET last_seen_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(userId);
+  }
+  /**
+   * Increment message count
+   */
+  incrementMessageCount(userId) {
+    this.db.prepare(
+      `
+      UPDATE tg_users
+      SET message_count = message_count + 1, last_seen_at = unixepoch()
+      WHERE id = ?
+    `
+    ).run(userId);
+  }
+  /**
+   * Set admin status
+   */
+  setAdmin(userId, isAdmin) {
+    this.db.prepare(
+      `
+      UPDATE tg_users
+      SET is_admin = ?
+      WHERE id = ?
+    `
+    ).run(isAdmin ? 1 : 0, userId);
+  }
+  /**
+   * Set allowed status
+   */
+  setAllowed(userId, isAllowed) {
+    this.db.prepare(
+      `
+      UPDATE tg_users
+      SET is_allowed = ?
+      WHERE id = ?
+    `
+    ).run(isAllowed ? 1 : 0, userId);
+  }
+  /**
+   * Get all admins
+   */
+  getAdmins() {
+    const rows = this.db.prepare(
+      `
+      SELECT * FROM tg_users
+      WHERE is_admin = 1
+      ORDER BY last_seen_at DESC
+    `
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      username: row.username,
+      firstName: row.first_name,
+      lastName: row.last_name,
+      isBot: Boolean(row.is_bot),
+      isAdmin: Boolean(row.is_admin),
+      isAllowed: Boolean(row.is_allowed),
+      firstSeenAt: new Date(row.first_seen_at * 1e3),
+      lastSeenAt: new Date(row.last_seen_at * 1e3),
+      messageCount: row.message_count
+    }));
+  }
+  /**
+   * Get recently active users
+   */
+  getRecentUsers(limit = 50) {
+    const rows = this.db.prepare(
+      `
+      SELECT * FROM tg_users
+      ORDER BY last_seen_at DESC
+      LIMIT ?
+    `
+    ).all(limit);
+    return rows.map((row) => ({
+      id: row.id,
+      username: row.username,
+      firstName: row.first_name,
+      lastName: row.last_name,
+      isBot: Boolean(row.is_bot),
+      isAdmin: Boolean(row.is_admin),
+      isAllowed: Boolean(row.is_allowed),
+      firstSeenAt: new Date(row.first_seen_at * 1e3),
+      lastSeenAt: new Date(row.last_seen_at * 1e3),
+      messageCount: row.message_count
+    }));
+  }
+};
+
+// src/memory/search/hybrid.ts
+function escapeFts5Query(query) {
+  return query.replace(/["\*\-\+\(\)\:\^\~\?\.\@\#\$\%\&\!\[\]\{\}\|\\\/<>=,;'`]/g, " ").replace(/\s+/g, " ").trim();
+}
+var HybridSearch = class {
+  constructor(db, vectorEnabled) {
+    this.db = db;
+    this.vectorEnabled = vectorEnabled;
+  }
+  /**
+   * Search in knowledge base
+   */
+  async searchKnowledge(query, queryEmbedding, options = {}) {
+    const limit = options.limit ?? 10;
+    const vectorWeight = options.vectorWeight ?? 0.7;
+    const keywordWeight = options.keywordWeight ?? 0.3;
+    const vectorResults = this.vectorEnabled ? this.vectorSearchKnowledge(queryEmbedding, limit * 2) : [];
+    const keywordResults = this.keywordSearchKnowledge(query, limit * 2);
+    return this.mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit);
+  }
+  /**
+   * Search in Telegram messages
+   */
+  async searchMessages(query, queryEmbedding, options = {}) {
+    const limit = options.limit ?? 10;
+    const vectorWeight = options.vectorWeight ?? 0.7;
+    const keywordWeight = options.keywordWeight ?? 0.3;
+    const vectorResults = this.vectorEnabled ? this.vectorSearchMessages(queryEmbedding, limit * 2, options.chatId) : [];
+    const keywordResults = this.keywordSearchMessages(query, limit * 2, options.chatId);
+    return this.mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit);
+  }
+  vectorSearchKnowledge(embedding, limit) {
+    if (!this.vectorEnabled || embedding.length === 0) return [];
+    try {
+      const embeddingBuffer = this.serializeEmbedding(embedding);
+      const rows = this.db.prepare(
+        `
+        SELECT kv.id, k.text, k.source, kv.distance
+        FROM knowledge_vec kv
+        JOIN knowledge k ON k.id = kv.id
+        WHERE kv.embedding MATCH ?
+        ORDER BY kv.distance
+        LIMIT ?
+      `
+      ).all(embeddingBuffer, limit);
+      return rows.map((row) => ({
+        id: row.id,
+        text: row.text,
+        source: row.source,
+        score: 1 - row.distance,
+        // Convert distance to similarity
+        vectorScore: 1 - row.distance
+      }));
+    } catch (error) {
+      console.error("Vector search error (knowledge):", error);
+      return [];
+    }
+  }
+  keywordSearchKnowledge(query, limit) {
+    const safeQuery = escapeFts5Query(query);
+    if (!safeQuery) return [];
+    try {
+      const rows = this.db.prepare(
+        `
+        SELECT k.id, k.text, k.source, rank as score
+        FROM knowledge_fts kf
+        JOIN knowledge k ON k.rowid = kf.rowid
+        WHERE knowledge_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `
+      ).all(safeQuery, limit);
+      return rows.map((row) => ({
+        ...row,
+        keywordScore: this.bm25ToScore(row.score)
+      }));
+    } catch (error) {
+      console.error("FTS5 search error (knowledge):", error);
+      return [];
+    }
+  }
+  vectorSearchMessages(embedding, limit, chatId) {
+    if (!this.vectorEnabled || embedding.length === 0) return [];
+    try {
+      const embeddingBuffer = this.serializeEmbedding(embedding);
+      const sql = chatId ? `
+        SELECT mv.id, m.text, m.chat_id as source, mv.distance
+        FROM tg_messages_vec mv
+        JOIN tg_messages m ON m.id = mv.id
+        WHERE mv.embedding MATCH ? AND m.chat_id = ?
+        ORDER BY mv.distance
+        LIMIT ?
+      ` : `
+        SELECT mv.id, m.text, m.chat_id as source, mv.distance
+        FROM tg_messages_vec mv
+        JOIN tg_messages m ON m.id = mv.id
+        WHERE mv.embedding MATCH ?
+        ORDER BY mv.distance
+        LIMIT ?
+      `;
+      const rows = chatId ? this.db.prepare(sql).all(embeddingBuffer, chatId, limit) : this.db.prepare(sql).all(embeddingBuffer, limit);
+      return rows.map((row) => ({
+        id: row.id,
+        text: row.text ?? "",
+        source: row.source,
+        score: 1 - row.distance,
+        vectorScore: 1 - row.distance
+      }));
+    } catch (error) {
+      console.error("Vector search error (messages):", error);
+      return [];
+    }
+  }
+  keywordSearchMessages(query, limit, chatId) {
+    const safeQuery = escapeFts5Query(query);
+    if (!safeQuery) return [];
+    try {
+      const sql = chatId ? `
+        SELECT m.id, m.text, m.chat_id as source, rank as score
+        FROM tg_messages_fts mf
+        JOIN tg_messages m ON m.rowid = mf.rowid
+        WHERE tg_messages_fts MATCH ? AND m.chat_id = ?
+        ORDER BY rank
+        LIMIT ?
+      ` : `
+        SELECT m.id, m.text, m.chat_id as source, rank as score
+        FROM tg_messages_fts mf
+        JOIN tg_messages m ON m.rowid = mf.rowid
+        WHERE tg_messages_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `;
+      const rows = chatId ? this.db.prepare(sql).all(safeQuery, chatId, limit) : this.db.prepare(sql).all(safeQuery, limit);
+      return rows.map((row) => ({
+        ...row,
+        text: row.text ?? "",
+        keywordScore: this.bm25ToScore(row.score)
+      }));
+    } catch (error) {
+      console.error("FTS5 search error (messages):", error);
+      return [];
+    }
+  }
+  mergeResults(vectorResults, keywordResults, vectorWeight, keywordWeight, limit) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const r of vectorResults) {
+      byId.set(r.id, { ...r, vectorScore: r.score });
+    }
+    for (const r of keywordResults) {
+      const existing = byId.get(r.id);
+      if (existing) {
+        existing.keywordScore = r.keywordScore;
+        existing.score = vectorWeight * (existing.vectorScore ?? 0) + keywordWeight * (r.keywordScore ?? 0);
+      } else {
+        byId.set(r.id, { ...r, score: keywordWeight * (r.keywordScore ?? 0) });
+      }
+    }
+    return Array.from(byId.values()).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  bm25ToScore(rank) {
+    return 1 / (1 + Math.abs(rank));
+  }
+  /**
+   * Serialize embedding (number[]) to Buffer for sqlite-vec
+   */
+  serializeEmbedding(embedding) {
+    const float32 = new Float32Array(embedding);
+    return Buffer.from(float32.buffer);
+  }
+};
+
+// src/memory/search/context.ts
+var ContextBuilder = class {
+  constructor(db, embedder, vectorEnabled) {
+    this.db = db;
+    this.embedder = embedder;
+    this.hybridSearch = new HybridSearch(db, vectorEnabled);
+    this.messageStore = new MessageStore(db, embedder, vectorEnabled);
+  }
+  hybridSearch;
+  messageStore;
+  async buildContext(options) {
+    const {
+      query,
+      chatId,
+      includeAgentMemory = true,
+      includeFeedHistory = true,
+      searchAllChats = false,
+      maxRecentMessages = 20,
+      maxRelevantChunks = 5
+    } = options;
+    const queryEmbedding = await this.embedder.embedQuery(query);
+    const recentTgMessages = this.messageStore.getRecentMessages(chatId, maxRecentMessages);
+    const recentMessages = recentTgMessages.map((m) => ({
+      role: m.isFromAgent ? "assistant" : "user",
+      content: m.text ?? ""
+    }));
+    const relevantKnowledge = [];
+    if (includeAgentMemory) {
+      try {
+        const knowledgeResults = await this.hybridSearch.searchKnowledge(query, queryEmbedding, {
+          limit: maxRelevantChunks
+        });
+        relevantKnowledge.push(...knowledgeResults.map((r) => r.text));
+      } catch (error) {
+        console.warn("Knowledge search failed:", error);
+      }
+    }
+    const relevantFeed = [];
+    if (includeFeedHistory) {
+      try {
+        const feedResults = await this.hybridSearch.searchMessages(query, queryEmbedding, {
+          chatId,
+          limit: maxRelevantChunks
+        });
+        relevantFeed.push(...feedResults.map((r) => r.text));
+        if (searchAllChats) {
+          const globalResults = await this.hybridSearch.searchMessages(query, queryEmbedding, {
+            // No chatId = search all chats
+            limit: maxRelevantChunks
+          });
+          const existingTexts = new Set(relevantFeed);
+          for (const r of globalResults) {
+            if (!existingTexts.has(r.text)) {
+              relevantFeed.push(`[From chat ${r.source}]: ${r.text}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.warn("Feed search failed:", error);
+      }
+      if (relevantFeed.length === 0 && recentTgMessages.length > 0) {
+        const recentTexts = recentTgMessages.filter((m) => m.text && m.text.length > 0).slice(-maxRelevantChunks).map((m) => {
+          const sender = m.isFromAgent ? "Agent" : "User";
+          return `[${sender}]: ${m.text}`;
+        });
+        relevantFeed.push(...recentTexts);
+      }
+    }
+    const allText = recentMessages.map((m) => m.content).join(" ") + relevantKnowledge.join(" ") + relevantFeed.join(" ");
+    const estimatedTokens = Math.ceil(allText.length / 4);
+    return {
+      recentMessages,
+      relevantKnowledge,
+      relevantFeed,
+      estimatedTokens
+    };
+  }
+};
+
+// src/memory/index.ts
+function initializeMemory(config) {
+  const db = getDatabase(config.database);
+  const embedder = createEmbeddingProvider(config.embeddings);
+  const vectorEnabled = db.isVectorSearchReady();
+  const database = db.getDb();
+  return {
+    db: database,
+    embedder,
+    knowledge: new KnowledgeIndexer(database, config.workspaceDir, embedder, vectorEnabled),
+    messages: new MessageStore(database, embedder, vectorEnabled),
+    context: new ContextBuilder(database, embedder, vectorEnabled)
+  };
+}
+
+export {
+  ensureSchema,
+  ensureVectorTables,
+  getSchemaVersion,
+  setSchemaVersion,
+  CURRENT_SCHEMA_VERSION,
+  runMigrations,
+  MemoryDatabase,
+  getDatabase,
+  closeDatabase,
+  NoopEmbeddingProvider,
+  AnthropicEmbeddingProvider,
+  LocalEmbeddingProvider,
+  createEmbeddingProvider,
+  hashText,
+  serializeEmbedding,
+  deserializeEmbedding,
+  embeddingToBlob,
+  KnowledgeIndexer,
+  SessionStore,
+  MessageStore,
+  ChatStore,
+  UserStore,
+  HybridSearch,
+  ContextBuilder,
+  initializeMemory
+};