@yugenlab/vaayu 0.1.0

package/chunks/chunk-SMVJRPAH.js

@@ -0,0 +1,2753 @@
+// packages/storage/src/sqlite/connection.ts
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+function createConnection(dbPath) {
+  const dir = path.dirname(dbPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const require3 = createRequire(import.meta.url);
+  const Database = require3("better-sqlite3");
+  const db = new Database(dbPath);
+  db.exec("PRAGMA journal_mode=WAL;");
+  return db;
+}
+
+// packages/storage/src/sqlite/schema-agent.ts
+function initAgentSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_inbox (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      status TEXT,
+      created_at TEXT,
+      started_at TEXT,
+      ended_at TEXT,
+      channel TEXT,
+      chat_id TEXT,
+      user_id TEXT,
+      text TEXT,
+      metadata TEXT,
+      error TEXT
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS session_inbox_session_idx ON session_inbox(session_id, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS session_inbox_status_idx ON session_inbox(status, created_at)`);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_queue (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      agent_id TEXT,
+      parent_agent_id TEXT,
+      parent_run_id TEXT,
+      lane TEXT,
+      status TEXT,
+      created_at TEXT,
+      started_at TEXT,
+      ended_at TEXT,
+      lease_until TEXT,
+      priority INTEGER,
+      channel TEXT,
+      chat_id TEXT,
+      user_id TEXT,
+      provider_id TEXT,
+      model TEXT,
+      system TEXT,
+      text TEXT,
+      timeout_ms INTEGER,
+      tool_policy TEXT,
+      metadata TEXT,
+      error TEXT
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_queue_status_idx ON agent_queue(status, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_queue_lane_idx ON agent_queue(lane, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_queue_session_idx ON agent_queue(session_id, created_at)`);
+  try {
+    db.exec(`ALTER TABLE agent_queue ADD COLUMN lease_until TEXT`);
+  } catch {
+  }
+  try {
+    db.exec(`ALTER TABLE agent_queue ADD COLUMN agent_id TEXT`);
+  } catch {
+  }
+  try {
+    db.exec(`ALTER TABLE agent_queue ADD COLUMN parent_agent_id TEXT`);
+  } catch {
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_runs (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      agent_id TEXT,
+      parent_agent_id TEXT,
+      parent_run_id TEXT,
+      lane TEXT,
+      status TEXT,
+      created_at TEXT,
+      started_at TEXT,
+      ended_at TEXT,
+      timeout_ms INTEGER,
+      channel TEXT,
+      chat_id TEXT,
+      user_id TEXT,
+      provider_id TEXT,
+      model TEXT,
+      system TEXT,
+      text TEXT,
+      metadata TEXT,
+      metrics TEXT,
+      result_summary TEXT,
+      error TEXT
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_runs_status_idx ON agent_runs(status, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_runs_session_idx ON agent_runs(session_id, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_runs_lane_idx ON agent_runs(lane, created_at)`);
+  try {
+    db.exec(`ALTER TABLE agent_runs ADD COLUMN agent_id TEXT`);
+  } catch {
+  }
+  try {
+    db.exec(`ALTER TABLE agent_runs ADD COLUMN parent_agent_id TEXT`);
+  } catch {
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_routes (
+      session_id TEXT PRIMARY KEY,
+      agent_id TEXT,
+      lane_id TEXT,
+      queue_mode TEXT,
+      announce_mode TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS session_routes_updated_idx ON session_routes(updated_at)`);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_run_events (
+      id TEXT PRIMARY KEY,
+      run_id TEXT,
+      time TEXT,
+      type TEXT,
+      payload TEXT
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS agent_run_events_run_idx ON agent_run_events(run_id, time)`);
+}
+
+// packages/storage/src/sqlite/schema/utils.ts
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+function initVectorExtension(db) {
+  try {
+    const sqliteVec = require2("sqlite-vec");
+    sqliteVec.load(db);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasColumn(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => String(row.name) === column);
+}
+function ensureColumn(db, table, column, definition) {
+  if (hasColumn(db, table, column)) return;
+  db.exec(`ALTER TABLE ${table} ADD COLUMN ${definition}`);
+}
+
+// packages/storage/src/sqlite/schema/core.ts
+function initCoreSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      key TEXT UNIQUE,
+      created_at TEXT,
+      updated_at TEXT,
+      user_id TEXT,
+      channel TEXT,
+      chat_type TEXT,
+      chat_id TEXT,
+      peer_id TEXT,
+      account_id TEXT,
+      thread_id TEXT,
+      label TEXT,
+      current_provider TEXT,
+      current_model TEXT,
+      providers_used TEXT,
+      provider_switches INTEGER
+    )
+  `);
+  ensureColumn(db, "sessions", "user_id", "user_id TEXT");
+  ensureColumn(db, "sessions", "current_provider", "current_provider TEXT");
+  ensureColumn(db, "sessions", "current_model", "current_model TEXT");
+  ensureColumn(db, "sessions", "providers_used", "providers_used TEXT");
+  ensureColumn(db, "sessions", "provider_switches", "provider_switches INTEGER");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      role TEXT,
+      content TEXT,
+      metadata TEXT,
+      created_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS session_events_session_idx ON session_events(session_id, created_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_summaries (
+      session_id TEXT PRIMARY KEY,
+      summary TEXT,
+      event_count INTEGER,
+      updated_at TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_prefs (
+      session_id TEXT PRIMARY KEY,
+      provider_id TEXT,
+      model TEXT,
+      system TEXT,
+      auto_routing INTEGER,
+      language TEXT,
+      language_updated_at TEXT,
+      continuity_preferred_device_id TEXT,
+      continuity_mode TEXT,
+      proactive_allowed INTEGER,
+      proactive_observe INTEGER,
+      proactive_deliver INTEGER,
+      proactive_allowed_channels TEXT,
+      proactive_paused_until TEXT,
+      proactive_max_per_day INTEGER,
+      proactive_cooldown_ms INTEGER,
+      proactive_delivered_day TEXT,
+      proactive_delivered_count INTEGER,
+      proactive_last_delivered_at TEXT,
+      updated_at TEXT
+    )
+  `);
+  ensureColumn(db, "session_prefs", "language", "language TEXT");
+  ensureColumn(db, "session_prefs", "language_updated_at", "language_updated_at TEXT");
+  ensureColumn(
+    db,
+    "session_prefs",
+    "continuity_preferred_device_id",
+    "continuity_preferred_device_id TEXT"
+  );
+  ensureColumn(db, "session_prefs", "continuity_mode", "continuity_mode TEXT");
+  ensureColumn(db, "session_prefs", "proactive_allowed", "proactive_allowed INTEGER");
+  ensureColumn(db, "session_prefs", "proactive_observe", "proactive_observe INTEGER");
+  ensureColumn(db, "session_prefs", "proactive_deliver", "proactive_deliver INTEGER");
+  ensureColumn(
+    db,
+    "session_prefs",
+    "proactive_allowed_channels",
+    "proactive_allowed_channels TEXT"
+  );
+  ensureColumn(db, "session_prefs", "proactive_paused_until", "proactive_paused_until TEXT");
+  ensureColumn(db, "session_prefs", "proactive_max_per_day", "proactive_max_per_day INTEGER");
+  ensureColumn(db, "session_prefs", "proactive_cooldown_ms", "proactive_cooldown_ms INTEGER");
+  ensureColumn(db, "session_prefs", "proactive_delivered_day", "proactive_delivered_day TEXT");
+  ensureColumn(
+    db,
+    "session_prefs",
+    "proactive_delivered_count",
+    "proactive_delivered_count INTEGER"
+  );
+  ensureColumn(
+    db,
+    "session_prefs",
+    "proactive_last_delivered_at",
+    "proactive_last_delivered_at TEXT"
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_providers (
+      session_id TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      model TEXT,
+      first_used_at TEXT,
+      last_used_at TEXT,
+      usage_count INTEGER,
+      PRIMARY KEY (session_id, provider_id)
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS session_providers_last_idx ON session_providers(last_used_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS provider_switches (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      from_provider_id TEXT,
+      to_provider_id TEXT,
+      from_model TEXT,
+      to_model TEXT,
+      reason TEXT,
+      created_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS provider_switches_session_idx ON provider_switches(session_id, created_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS devices (
+      id TEXT PRIMARY KEY,
+      name TEXT,
+      type TEXT,
+      role TEXT,
+      caps TEXT,
+      status TEXT,
+      scopes TEXT,
+      auth_type TEXT,
+      token_hash TEXT UNIQUE,
+      token_hint TEXT,
+      public_key TEXT,
+      public_key_alg TEXT,
+      created_at TEXT,
+      updated_at TEXT,
+      last_seen_at TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS channel_allows (
+      id TEXT PRIMARY KEY,
+      channel TEXT,
+      chat_id TEXT,
+      user_id TEXT,
+      status TEXT,
+      note TEXT,
+      created_at TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE UNIQUE INDEX IF NOT EXISTS channel_allows_key ON channel_allows(channel, chat_id, user_id)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS approval_requests (
+      id TEXT PRIMARY KEY,
+      status TEXT,
+      kind TEXT,
+      tool_name TEXT,
+      tool_input TEXT,
+      session_id TEXT,
+      channel TEXT,
+      chat_id TEXT,
+      user_id TEXT,
+      user_text TEXT,
+      risk TEXT,
+      reason TEXT,
+      created_at TEXT,
+      updated_at TEXT,
+      expires_at TEXT,
+      decided_at TEXT,
+      decided_by TEXT,
+      result TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS approval_requests_status_idx ON approval_requests(status, created_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS audit (
+      id TEXT PRIMARY KEY,
+      time TEXT,
+      type TEXT,
+      payload TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_policy (
+      id TEXT PRIMARY KEY,
+      allow TEXT,
+      deny TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS device_sync_state (
+      id TEXT PRIMARY KEY,
+      device_id TEXT NOT NULL UNIQUE,
+      user_id TEXT NOT NULL,
+      last_sync_at INTEGER,
+      pending_changes INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS device_sync_state_user_idx ON device_sync_state(user_id)`);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS token_usage (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      provider_id TEXT,
+      model TEXT,
+      input_tokens INTEGER,
+      output_tokens INTEGER,
+      total_tokens INTEGER,
+      cost_micro INTEGER,
+      source TEXT,
+      created_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS token_usage_session_idx ON token_usage(session_id, created_at)`
+  );
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS token_usage_provider_idx ON token_usage(provider_id, created_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS message_reactions (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_id TEXT NOT NULL,
+      reaction TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS message_reactions_session_idx ON message_reactions(session_id)`
+  );
+  db.exec(
+    `CREATE UNIQUE INDEX IF NOT EXISTS message_reactions_message_idx ON message_reactions(message_id)`
+  );
+}
+
+// packages/storage/src/sqlite/schema/fts.ts
+function initFtsSchema(db) {
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_messages_fts USING fts5(
+        content,
+        content_rowid='id',
+        tokenize='porter unicode61'
+      )
+    `);
+  } catch {
+  }
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_base_fts USING fts5(
+        fact,
+        content_rowid='id',
+        tokenize='porter unicode61'
+      )
+    `);
+  } catch {
+  }
+}
+
+// packages/storage/src/sqlite/schema/memory.ts
+function initMemorySchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_sessions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      topic TEXT,
+      message_count INTEGER DEFAULT 0,
+      summary TEXT,
+      key_entities TEXT,
+      importance_score REAL DEFAULT 0.5,
+      tier INTEGER DEFAULT 1,
+      archived INTEGER DEFAULT 0,
+      created_at TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_sessions_user_tier_idx ON memory_sessions(user_id, tier, started_at)`
+  );
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_sessions_tier_age_idx ON memory_sessions(tier, started_at)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES memory_sessions(id),
+      content TEXT NOT NULL,
+      embedding BLOB,
+      embedding_dim INTEGER,
+      timestamp INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      entities TEXT,
+      importance REAL DEFAULT 0.5,
+      pruned INTEGER DEFAULT 0,
+      created_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_messages_session_idx ON memory_messages(session_id, timestamp)`
+  );
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_messages_pruned_idx ON memory_messages(pruned, importance)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_summaries (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES memory_sessions(id),
+      level INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      embedding BLOB,
+      embedding_dim INTEGER,
+      created_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_summaries_session_idx ON memory_summaries(session_id, level)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS knowledge_base (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      fact TEXT NOT NULL,
+      source_session_id TEXT,
+      confidence REAL DEFAULT 0.8,
+      category TEXT,
+      embedding BLOB,
+      embedding_dim INTEGER,
+      last_verified INTEGER,
+      created_at TEXT,
+      updated_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS knowledge_base_user_idx ON knowledge_base(user_id, category)`
+  );
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS knowledge_base_confidence_idx ON knowledge_base(confidence DESC)`
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memory_search_cache (
+      id TEXT PRIMARY KEY,
+      query_hash TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      results TEXT NOT NULL,
+      created_at TEXT,
+      expires_at TEXT
+    )
+  `);
+  db.exec(
+    `CREATE INDEX IF NOT EXISTS memory_search_cache_hash_idx ON memory_search_cache(query_hash, user_id)`
+  );
+}
+
+// packages/storage/src/sqlite/schema/vector.ts
+function initVectorSchema(db, enabled) {
+  if (!enabled) return;
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS memory_messages_vec USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding FLOAT[1024]
+      )
+    `);
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_base_vec USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding FLOAT[1024]
+      )
+    `);
+  } catch {
+  }
+}
+
+// packages/storage/src/sqlite/schema.ts
+function initSchema(db) {
+  const hasVec = initVectorExtension(db);
+  initCoreSchema(db);
+  initAgentSchema(db);
+  initMemorySchema(db);
+  initFtsSchema(db);
+  initVectorSchema(db, hasVec);
+}
+function resetMemoryTables(db) {
+  db.exec(`DROP TABLE IF EXISTS memory_search_cache`);
+  db.exec(`DROP TABLE IF EXISTS memory_messages_fts`);
+  db.exec(`DROP TABLE IF EXISTS knowledge_base_fts`);
+  db.exec(`DROP TABLE IF EXISTS memory_messages_vec`);
+  db.exec(`DROP TABLE IF EXISTS knowledge_base_vec`);
+  db.exec(`DROP TABLE IF EXISTS memory_summaries`);
+  db.exec(`DROP TABLE IF EXISTS memory_messages`);
+  db.exec(`DROP TABLE IF EXISTS knowledge_base`);
+  db.exec(`DROP TABLE IF EXISTS memory_sessions`);
+  initSchema(db);
+}
+function getSchemaInfo(db) {
+  const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' ORDER BY name`).all();
+  const tables = rows.map((row) => row.name);
+  const hasVec = tables.some((t) => t.endsWith("_vec"));
+  const hasFts = tables.some((t) => t.endsWith("_fts"));
+  return { tables, hasVec, hasFts };
+}
+
+// packages/storage/src/sqlite/sessions/statements.ts
+function prepareSessionStatements(db) {
+  return {
+    getByKey: db.prepare(
+      "SELECT id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches FROM sessions WHERE key = @key"
+    ),
+    getById: db.prepare(
+      "SELECT id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches FROM sessions WHERE id = @id"
+    ),
+    list: db.prepare(
+      "SELECT id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches FROM sessions ORDER BY created_at DESC"
+    ),
+    insert: db.prepare(
+      "INSERT OR IGNORE INTO sessions (id, key, created_at, updated_at, user_id, channel, chat_type, chat_id, peer_id, account_id, thread_id, label, current_provider, current_model, providers_used, provider_switches) VALUES (@id, @key, @created_at, @updated_at, @user_id, @channel, @chat_type, @chat_id, @peer_id, @account_id, @thread_id, @label, @current_provider, @current_model, @providers_used, @provider_switches)"
+    ),
+    update: db.prepare(
+      "UPDATE sessions SET key = @key, updated_at = @updated_at, user_id = @user_id, channel = @channel, chat_type = @chat_type, chat_id = @chat_id, peer_id = @peer_id, account_id = @account_id, thread_id = @thread_id, label = @label, current_provider = @current_provider, current_model = @current_model, providers_used = @providers_used, provider_switches = @provider_switches WHERE id = @id"
+    ),
+    eventInsert: db.prepare(
+      "INSERT INTO session_events (id, session_id, role, content, metadata, created_at) VALUES (@id, @session_id, @role, @content, @metadata, @created_at)"
+    ),
+    eventList: db.prepare(
+      "SELECT id, session_id, role, content, metadata, created_at FROM session_events WHERE session_id = @session_id ORDER BY created_at DESC LIMIT @limit"
+    ),
+    eventCount: db.prepare("SELECT COUNT(*) as count FROM session_events WHERE session_id = @session_id"),
+    summaryGet: db.prepare(
+      "SELECT session_id, summary, event_count, updated_at FROM session_summaries WHERE session_id = @session_id"
+    ),
+    summaryUpsert: db.prepare(
+      "INSERT INTO session_summaries (session_id, summary, event_count, updated_at) VALUES (@session_id, @summary, @event_count, @updated_at) ON CONFLICT(session_id) DO UPDATE SET summary = excluded.summary, event_count = excluded.event_count, updated_at = excluded.updated_at"
+    ),
+    toolPolicyGet: db.prepare("SELECT id, allow, deny, updated_at FROM tool_policy WHERE id = @id"),
+    toolPolicyUpsert: db.prepare(
+      "INSERT INTO tool_policy (id, allow, deny, updated_at) VALUES (@id, @allow, @deny, @updated_at) ON CONFLICT(id) DO UPDATE SET allow = excluded.allow, deny = excluded.deny, updated_at = excluded.updated_at"
+    ),
+    getPrefs: db.prepare(
+      "SELECT session_id, provider_id, model, system, auto_routing, language, language_updated_at, continuity_preferred_device_id, continuity_mode, proactive_allowed, proactive_observe, proactive_deliver, proactive_allowed_channels, proactive_paused_until, proactive_max_per_day, proactive_cooldown_ms, proactive_delivered_day, proactive_delivered_count, proactive_last_delivered_at, updated_at FROM session_prefs WHERE session_id = @session_id"
+    ),
+    upsertPrefs: db.prepare(
+      "INSERT INTO session_prefs (session_id, provider_id, model, system, auto_routing, language, language_updated_at, continuity_preferred_device_id, continuity_mode, proactive_allowed, proactive_observe, proactive_deliver, proactive_allowed_channels, proactive_paused_until, proactive_max_per_day, proactive_cooldown_ms, proactive_delivered_day, proactive_delivered_count, proactive_last_delivered_at, updated_at) VALUES (@session_id, @provider_id, @model, @system, @auto_routing, @language, @language_updated_at, @continuity_preferred_device_id, @continuity_mode, @proactive_allowed, @proactive_observe, @proactive_deliver, @proactive_allowed_channels, @proactive_paused_until, @proactive_max_per_day, @proactive_cooldown_ms, @proactive_delivered_day, @proactive_delivered_count, @proactive_last_delivered_at, @updated_at) ON CONFLICT(session_id) DO UPDATE SET provider_id = excluded.provider_id, model = excluded.model, system = excluded.system, auto_routing = excluded.auto_routing, language = excluded.language, language_updated_at = excluded.language_updated_at, continuity_preferred_device_id = excluded.continuity_preferred_device_id, continuity_mode = excluded.continuity_mode, proactive_allowed = excluded.proactive_allowed, proactive_observe = excluded.proactive_observe, proactive_deliver = excluded.proactive_deliver, proactive_allowed_channels = excluded.proactive_allowed_channels, proactive_paused_until = excluded.proactive_paused_until, proactive_max_per_day = excluded.proactive_max_per_day, proactive_cooldown_ms = excluded.proactive_cooldown_ms, proactive_delivered_day = excluded.proactive_delivered_day, proactive_delivered_count = excluded.proactive_delivered_count, proactive_last_delivered_at = excluded.proactive_last_delivered_at, updated_at = excluded.updated_at"
+    ),
+    deletePrefs: db.prepare("DELETE FROM session_prefs WHERE session_id = @session_id")
+  };
+}
+
+// packages/storage/src/sqlite/sessions/session-crud.ts
+import { randomUUID } from "node:crypto";
+
+// packages/storage/src/sqlite/sessions/mappers.ts
+function mapSession(row) {
+  const providersUsedRaw = row.providers_used ? String(row.providers_used) : "";
+  let providersUsed;
+  if (providersUsedRaw) {
+    try {
+      const parsed = JSON.parse(providersUsedRaw);
+      providersUsed = Array.isArray(parsed) ? parsed.map((value) => String(value)) : void 0;
+    } catch {
+      providersUsed = void 0;
+    }
+  }
+  return {
+    id: String(row.id),
+    key: String(row.key),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    userId: row.user_id ? String(row.user_id) : void 0,
+    channel: row.channel ? String(row.channel) : void 0,
+    chatType: row.chat_type ? String(row.chat_type) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    peerId: row.peer_id ? String(row.peer_id) : void 0,
+    accountId: row.account_id ? String(row.account_id) : void 0,
+    threadId: row.thread_id ? String(row.thread_id) : void 0,
+    label: row.label ? String(row.label) : void 0,
+    currentProviderId: row.current_provider ? String(row.current_provider) : void 0,
+    currentModel: row.current_model ? String(row.current_model) : void 0,
+    providersUsed,
+    providerSwitches: row.provider_switches === null || row.provider_switches === void 0 ? void 0 : Number(row.provider_switches)
+  };
+}
+function mapEvent(row) {
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    role: String(row.role),
+    content: String(row.content),
+    metadata: row.metadata ? JSON.parse(String(row.metadata)) : void 0,
+    createdAt: String(row.created_at)
+  };
+}
+function mapSummary(row) {
+  return {
+    sessionId: String(row.session_id),
+    summary: String(row.summary),
+    eventCount: row.event_count === null || row.event_count === void 0 ? void 0 : Number(row.event_count),
+    updatedAt: String(row.updated_at)
+  };
+}
+function mapPrefs(row) {
+  let proactiveAllowedChannels;
+  if (row.proactive_allowed_channels) {
+    try {
+      const parsed = JSON.parse(String(row.proactive_allowed_channels));
+      if (Array.isArray(parsed)) {
+        proactiveAllowedChannels = parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      proactiveAllowedChannels = void 0;
+    }
+  }
+  return {
+    sessionId: String(row.session_id),
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    autoRouting: row.auto_routing === null || row.auto_routing === void 0 ? void 0 : Boolean(row.auto_routing),
+    language: row.language ? String(row.language) : void 0,
+    languageUpdatedAt: row.language_updated_at ? String(row.language_updated_at) : void 0,
+    continuityPreferredDeviceId: row.continuity_preferred_device_id ? String(row.continuity_preferred_device_id) : void 0,
+    continuityMode: row.continuity_mode === "auto" || row.continuity_mode === "prompt" || row.continuity_mode === "off" ? row.continuity_mode : void 0,
+    proactiveAllowed: row.proactive_allowed === null || row.proactive_allowed === void 0 ? void 0 : Boolean(row.proactive_allowed),
+    proactiveObserve: row.proactive_observe === null || row.proactive_observe === void 0 ? void 0 : Boolean(row.proactive_observe),
+    proactiveDeliver: row.proactive_deliver === null || row.proactive_deliver === void 0 ? void 0 : Boolean(row.proactive_deliver),
+    proactiveAllowedChannels,
+    proactivePausedUntil: row.proactive_paused_until ? String(row.proactive_paused_until) : void 0,
+    proactiveMaxPerDay: row.proactive_max_per_day === null || row.proactive_max_per_day === void 0 ? void 0 : Number(row.proactive_max_per_day),
+    proactiveCooldownMs: row.proactive_cooldown_ms === null || row.proactive_cooldown_ms === void 0 ? void 0 : Number(row.proactive_cooldown_ms),
+    proactiveDeliveredDay: row.proactive_delivered_day ? String(row.proactive_delivered_day) : void 0,
+    proactiveDeliveredCount: row.proactive_delivered_count === null || row.proactive_delivered_count === void 0 ? void 0 : Number(row.proactive_delivered_count),
+    proactiveLastDeliveredAt: row.proactive_last_delivered_at ? String(row.proactive_last_delivered_at) : void 0,
+    updatedAt: String(row.updated_at)
+  };
+}
+
+// packages/storage/src/sqlite/sessions/session-crud.ts
+async function getSessionByKey(s, key) {
+  const row = s.getByKey.get({ key });
+  return row ? mapSession(row) : void 0;
+}
+async function getSessionById(s, id) {
+  const row = s.getById.get({ id });
+  return row ? mapSession(row) : void 0;
+}
+async function listSessions(s) {
+  const rows = s.list.all();
+  return rows.map(mapSession);
+}
+async function createSession(s, key, meta) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    id: randomUUID(),
+    key,
+    createdAt: now2,
+    updatedAt: now2,
+    userId: meta?.userId,
+    channel: meta?.channel,
+    chatType: meta?.chatType,
+    chatId: meta?.chatId,
+    peerId: meta?.peerId,
+    accountId: meta?.accountId,
+    threadId: meta?.threadId,
+    label: meta?.label,
+    currentProviderId: meta?.currentProviderId,
+    currentModel: meta?.currentModel,
+    providersUsed: meta?.providersUsed,
+    providerSwitches: meta?.providerSwitches
+  };
+  s.insert.run({
+    id: record.id,
+    key: record.key,
+    created_at: record.createdAt,
+    updated_at: record.updatedAt,
+    user_id: record.userId ?? null,
+    channel: record.channel ?? null,
+    chat_type: record.chatType ?? null,
+    chat_id: record.chatId ?? null,
+    peer_id: record.peerId ?? null,
+    account_id: record.accountId ?? null,
+    thread_id: record.threadId ?? null,
+    label: record.label ?? null,
+    current_provider: record.currentProviderId ?? null,
+    current_model: record.currentModel ?? null,
+    providers_used: record.providersUsed ? JSON.stringify(record.providersUsed) : null,
+    provider_switches: record.providerSwitches ?? null
+  });
+  const stored = await getSessionByKey(s, key);
+  return stored ?? record;
+}
+async function updateSession(s, id, update) {
+  const existing = await getSessionById(s, id);
+  if (!existing) return void 0;
+  const merged = {
+    ...existing,
+    ...update,
+    updatedAt: update.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.update.run({
+    id: merged.id,
+    key: merged.key,
+    updated_at: merged.updatedAt,
+    user_id: merged.userId ?? null,
+    channel: merged.channel ?? null,
+    chat_type: merged.chatType ?? null,
+    chat_id: merged.chatId ?? null,
+    peer_id: merged.peerId ?? null,
+    account_id: merged.accountId ?? null,
+    thread_id: merged.threadId ?? null,
+    label: merged.label ?? null,
+    current_provider: merged.currentProviderId ?? null,
+    current_model: merged.currentModel ?? null,
+    providers_used: merged.providersUsed ? JSON.stringify(merged.providersUsed) : null,
+    provider_switches: merged.providerSwitches ?? null
+  });
+  return merged;
+}
+
+// packages/storage/src/sqlite/sessions/events.ts
+async function appendSessionEvent(s, event) {
+  s.eventInsert.run({
+    id: event.id,
+    session_id: event.sessionId,
+    role: event.role,
+    content: event.content,
+    metadata: event.metadata ? JSON.stringify(event.metadata) : null,
+    created_at: event.createdAt
+  });
+}
+async function listSessionEvents(s, sessionId, options) {
+  const limit = options?.limit ?? 50;
+  const rows = s.eventList.all({ session_id: sessionId, limit });
+  return rows.map(mapEvent).reverse();
+}
+async function countSessionEvents(s, sessionId) {
+  const row = s.eventCount.get({ session_id: sessionId });
+  const value = row?.count;
+  return typeof value === "number" ? value : Number(value ?? 0);
+}
+
+// packages/storage/src/sqlite/sessions/summaries.ts
+async function getSessionSummary(s, sessionId) {
+  const row = s.summaryGet.get({ session_id: sessionId });
+  return row ? mapSummary(row) : void 0;
+}
+async function setSessionSummary(s, sessionId, summary, eventCount) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  s.summaryUpsert.run({
+    session_id: sessionId,
+    summary,
+    event_count: eventCount ?? null,
+    updated_at: now2
+  });
+  return await getSessionSummary(s, sessionId) ?? { sessionId, summary, eventCount, updatedAt: now2 };
+}
+
+// packages/storage/src/sqlite/sessions/tool-policy.ts
+async function getToolPolicy(s) {
+  const row = s.toolPolicyGet.get({ id: "global" });
+  if (!row) return void 0;
+  return {
+    allow: row.allow ? JSON.parse(String(row.allow)) : void 0,
+    deny: row.deny ? JSON.parse(String(row.deny)) : void 0,
+    updatedAt: row.updated_at ? String(row.updated_at) : void 0
+  };
+}
+async function setToolPolicy(s, policy) {
+  const record = {
+    allow: policy.allow ?? [],
+    deny: policy.deny ?? [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.toolPolicyUpsert.run({
+    id: "global",
+    allow: JSON.stringify(record.allow ?? []),
+    deny: JSON.stringify(record.deny ?? []),
+    updated_at: record.updatedAt
+  });
+  return record;
+}
+
+// packages/storage/src/sqlite/sessions/prefs.ts
+async function getSessionPrefs(s, sessionId) {
+  const row = s.getPrefs.get({ session_id: sessionId });
+  return row ? mapPrefs(row) : void 0;
+}
+async function setSessionPrefs(s, sessionId, prefs) {
+  const existing = await getSessionPrefs(s, sessionId);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const providerId = prefs.providerId ?? existing?.providerId ?? null;
+  const model = prefs.model ?? existing?.model ?? null;
+  const system = prefs.system ?? existing?.system ?? null;
+  const autoRouting = prefs.autoRouting ?? existing?.autoRouting;
+  const hasLanguage = Object.prototype.hasOwnProperty.call(prefs, "language");
+  const language = hasLanguage ? prefs.language ?? null : existing?.language ?? null;
+  const hasLanguageUpdatedAt = Object.prototype.hasOwnProperty.call(prefs, "languageUpdatedAt");
+  const languageUpdatedAt = hasLanguage ? prefs.language ? prefs.languageUpdatedAt ?? now2 : null : hasLanguageUpdatedAt ? prefs.languageUpdatedAt ?? null : existing?.languageUpdatedAt ?? null;
+  const hasContinuityDevice = Object.prototype.hasOwnProperty.call(prefs, "continuityPreferredDeviceId");
+  const continuityPreferredDeviceId = hasContinuityDevice ? prefs.continuityPreferredDeviceId ?? null : existing?.continuityPreferredDeviceId ?? null;
+  const hasContinuityMode = Object.prototype.hasOwnProperty.call(prefs, "continuityMode");
+  const continuityMode = hasContinuityMode ? prefs.continuityMode ?? null : existing?.continuityMode ?? null;
+  const proactiveAllowed = prefs.proactiveAllowed ?? existing?.proactiveAllowed;
+  const proactiveObserve = prefs.proactiveObserve ?? existing?.proactiveObserve;
+  const proactiveDeliver = prefs.proactiveDeliver ?? existing?.proactiveDeliver;
+  const hasAllowedChannels = Object.prototype.hasOwnProperty.call(prefs, "proactiveAllowedChannels");
+  const proactiveAllowedChannels = hasAllowedChannels ? prefs.proactiveAllowedChannels ?? null : existing?.proactiveAllowedChannels ?? null;
+  const hasPausedUntil = Object.prototype.hasOwnProperty.call(prefs, "proactivePausedUntil");
+  const proactivePausedUntil = hasPausedUntil ? prefs.proactivePausedUntil ?? null : existing?.proactivePausedUntil ?? null;
+  const hasMaxPerDay = Object.prototype.hasOwnProperty.call(prefs, "proactiveMaxPerDay");
+  const proactiveMaxPerDay = hasMaxPerDay ? prefs.proactiveMaxPerDay ?? null : existing?.proactiveMaxPerDay ?? null;
+  const hasCooldown = Object.prototype.hasOwnProperty.call(prefs, "proactiveCooldownMs");
+  const proactiveCooldownMs = hasCooldown ? prefs.proactiveCooldownMs ?? null : existing?.proactiveCooldownMs ?? null;
+  const hasDeliveredDay = Object.prototype.hasOwnProperty.call(prefs, "proactiveDeliveredDay");
+  const proactiveDeliveredDay = hasDeliveredDay ? prefs.proactiveDeliveredDay ?? null : existing?.proactiveDeliveredDay ?? null;
+  const hasDeliveredCount = Object.prototype.hasOwnProperty.call(prefs, "proactiveDeliveredCount");
+  const proactiveDeliveredCount = hasDeliveredCount ? prefs.proactiveDeliveredCount ?? null : existing?.proactiveDeliveredCount ?? null;
+  const hasLastDelivered = Object.prototype.hasOwnProperty.call(prefs, "proactiveLastDeliveredAt");
+  const proactiveLastDeliveredAt = hasLastDelivered ? prefs.proactiveLastDeliveredAt ?? null : existing?.proactiveLastDeliveredAt ?? null;
+  s.upsertPrefs.run({
+    session_id: sessionId,
+    provider_id: providerId,
+    model,
+    system,
+    auto_routing: autoRouting === void 0 ? null : autoRouting ? 1 : 0,
+    language,
+    language_updated_at: languageUpdatedAt,
+    continuity_preferred_device_id: continuityPreferredDeviceId,
+    continuity_mode: continuityMode,
+    proactive_allowed: proactiveAllowed === void 0 ? null : proactiveAllowed ? 1 : 0,
+    proactive_observe: proactiveObserve === void 0 ? null : proactiveObserve ? 1 : 0,
+    proactive_deliver: proactiveDeliver === void 0 ? null : proactiveDeliver ? 1 : 0,
+    proactive_allowed_channels: Array.isArray(proactiveAllowedChannels) ? JSON.stringify(proactiveAllowedChannels) : null,
+    proactive_paused_until: proactivePausedUntil,
+    proactive_max_per_day: proactiveMaxPerDay,
+    proactive_cooldown_ms: proactiveCooldownMs,
+    proactive_delivered_day: proactiveDeliveredDay,
+    proactive_delivered_count: proactiveDeliveredCount,
+    proactive_last_delivered_at: proactiveLastDeliveredAt,
+    updated_at: now2
+  });
+  const stored = await getSessionPrefs(s, sessionId);
+  return stored ?? {
+    sessionId,
+    providerId: providerId ?? void 0,
+    model: model ?? void 0,
+    system: system ?? void 0,
+    autoRouting,
+    language: language ?? void 0,
+    languageUpdatedAt: languageUpdatedAt ?? void 0,
+    continuityPreferredDeviceId: continuityPreferredDeviceId ?? void 0,
+    continuityMode: continuityMode ?? void 0,
+    proactiveAllowed,
+    proactiveObserve,
+    proactiveDeliver,
+    proactiveAllowedChannels: Array.isArray(proactiveAllowedChannels) ? proactiveAllowedChannels : void 0,
+    proactivePausedUntil: proactivePausedUntil ?? void 0,
+    proactiveMaxPerDay: proactiveMaxPerDay ?? void 0,
+    proactiveCooldownMs: proactiveCooldownMs ?? void 0,
+    proactiveDeliveredDay: proactiveDeliveredDay ?? void 0,
+    proactiveDeliveredCount: proactiveDeliveredCount ?? void 0,
+    proactiveLastDeliveredAt: proactiveLastDeliveredAt ?? void 0,
+    updatedAt: now2
+  };
+}
+async function clearSessionPrefs(s, sessionId) {
+  s.deletePrefs.run({ session_id: sessionId });
+}
+
+// packages/storage/src/sqlite/devices.ts
+function prepareDeviceStatements(db) {
+  return {
+    list: db.prepare(
+      "SELECT id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at FROM devices ORDER BY created_at DESC"
+    ),
+    getById: db.prepare(
+      "SELECT id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at FROM devices WHERE id = @id"
+    ),
+    getByToken: db.prepare(
+      "SELECT id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at FROM devices WHERE token_hash = @token_hash"
+    ),
+    insert: db.prepare(
+      "INSERT INTO devices (id, name, type, role, caps, status, scopes, auth_type, token_hash, token_hint, public_key, public_key_alg, created_at, updated_at, last_seen_at) VALUES (@id, @name, @type, @role, @caps, @status, @scopes, @auth_type, @token_hash, @token_hint, @public_key, @public_key_alg, @created_at, @updated_at, @last_seen_at)"
+    ),
+    update: db.prepare(
+      "UPDATE devices SET name = @name, type = @type, role = @role, caps = @caps, scopes = @scopes, updated_at = @updated_at WHERE id = @id"
+    ),
+    revoke: db.prepare(
+      "UPDATE devices SET status = @status, updated_at = @updated_at WHERE id = @id"
+    ),
+    touch: db.prepare(
+      "UPDATE devices SET last_seen_at = @last_seen_at, updated_at = @updated_at WHERE id = @id"
+    )
+  };
+}
+function mapDevice(row) {
+  return {
+    id: String(row.id),
+    name: row.name ? String(row.name) : void 0,
+    type: row.type ? String(row.type) : void 0,
+    role: row.role ? String(row.role) : void 0,
+    caps: row.caps ? JSON.parse(String(row.caps)) : void 0,
+    status: row.status === "revoked" ? "revoked" : "active",
+    scopes: row.scopes ? JSON.parse(String(row.scopes)) : void 0,
+    authType: row.auth_type === "keypair" ? "keypair" : "token",
+    tokenHash: row.token_hash ? String(row.token_hash) : void 0,
+    tokenHint: row.token_hint ? String(row.token_hint) : void 0,
+    publicKey: row.public_key ? String(row.public_key) : void 0,
+    publicKeyAlgorithm: row.public_key_alg ? String(row.public_key_alg) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    lastSeenAt: row.last_seen_at ? String(row.last_seen_at) : void 0
+  };
+}
+async function listDevices(s) {
+  const rows = s.list.all();
+  return rows.map(mapDevice);
+}
+async function getDeviceById(s, id) {
+  const row = s.getById.get({ id });
+  return row ? mapDevice(row) : void 0;
+}
+async function getDeviceByTokenHash(s, tokenHash) {
+  const row = s.getByToken.get({ token_hash: tokenHash });
+  return row ? mapDevice(row) : void 0;
+}
+async function createDevice(s, record) {
+  s.insert.run({
+    id: record.id,
+    name: record.name ?? null,
+    type: record.type ?? null,
+    role: record.role ?? null,
+    caps: record.caps ? JSON.stringify(record.caps) : null,
+    status: record.status,
+    scopes: record.scopes ? JSON.stringify(record.scopes) : null,
+    auth_type: record.authType,
+    token_hash: record.tokenHash ?? null,
+    token_hint: record.tokenHint ?? null,
+    public_key: record.publicKey ?? null,
+    public_key_alg: record.publicKeyAlgorithm ?? null,
+    created_at: record.createdAt,
+    updated_at: record.updatedAt,
+    last_seen_at: record.lastSeenAt ?? null
+  });
+  return record;
+}
+async function updateDevice(s, id, update) {
+  const existing = await getDeviceById(s, id);
+  if (!existing) {
+    return void 0;
+  }
+  const updated = {
+    ...existing,
+    name: update.name ?? existing.name,
+    type: update.type ?? existing.type,
+    scopes: update.scopes ?? existing.scopes,
+    role: update.role ?? existing.role,
+    caps: update.caps ?? existing.caps,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.update.run({
+    id,
+    name: updated.name ?? null,
+    type: updated.type ?? null,
+    role: updated.role ?? null,
+    caps: updated.caps ? JSON.stringify(updated.caps) : null,
+    scopes: updated.scopes ? JSON.stringify(updated.scopes) : null,
+    updated_at: updated.updatedAt
+  });
+  return updated;
+}
+async function revokeDevice(s, id) {
+  const existing = await getDeviceById(s, id);
+  if (!existing) {
+    return void 0;
+  }
+  const updated = {
+    ...existing,
+    status: "revoked",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.revoke.run({
+    id,
+    status: updated.status,
+    updated_at: updated.updatedAt
+  });
+  return updated;
+}
+async function touchDevice(s, id) {
+  s.touch.run({
+    id,
+    last_seen_at: (/* @__PURE__ */ new Date()).toISOString(),
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// packages/storage/src/sqlite/channels.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function prepareChannelStatements(db) {
+  return {
+    list: db.prepare(
+      "SELECT id, channel, chat_id, user_id, status, note, created_at, updated_at FROM channel_allows ORDER BY created_at DESC"
+    ),
+    listByChannel: db.prepare(
+      "SELECT id, channel, chat_id, user_id, status, note, created_at, updated_at FROM channel_allows WHERE channel = @channel ORDER BY created_at DESC"
+    ),
+    get: db.prepare(
+      "SELECT id, channel, chat_id, user_id, status, note, created_at, updated_at FROM channel_allows WHERE channel = @channel AND chat_id = @chat_id AND user_id = @user_id"
+    ),
+    insert: db.prepare(
+      "INSERT OR IGNORE INTO channel_allows (id, channel, chat_id, user_id, status, note, created_at, updated_at) VALUES (@id, @channel, @chat_id, @user_id, @status, @note, @created_at, @updated_at)"
+    ),
+    update: db.prepare(
+      "UPDATE channel_allows SET status = @status, note = @note, updated_at = @updated_at WHERE channel = @channel AND chat_id = @chat_id AND user_id = @user_id"
+    ),
+    revoke: db.prepare(
+      "UPDATE channel_allows SET status = @status, updated_at = @updated_at WHERE id = @id"
+    )
+  };
+}
+function mapChannelAllow(row) {
+  const userId = row.user_id ? String(row.user_id) : "";
+  return {
+    id: String(row.id),
+    channel: String(row.channel),
+    chatId: String(row.chat_id),
+    userId: userId.length > 0 ? userId : void 0,
+    status: row.status === "revoked" ? "revoked" : "allowed",
+    note: row.note ? String(row.note) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+async function listChannelAllows(s, channel) {
+  const rows = channel ? s.listByChannel.all({ channel }) : s.list.all();
+  return rows.map(mapChannelAllow);
+}
+async function getChannelAllow(s, channel, chatId, userId) {
+  const userKey = userId ?? "";
+  const row = s.get.get({
+    channel,
+    chat_id: chatId,
+    user_id: userKey
+  });
+  if (row) {
+    return mapChannelAllow(row);
+  }
+  if (userId) {
+    const fallback = s.get.get({
+      channel,
+      chat_id: chatId,
+      user_id: ""
+    });
+    return fallback ? mapChannelAllow(fallback) : void 0;
+  }
+  return void 0;
+}
+async function allowChannel(s, record) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const userKey = record.userId ?? "";
+  const existing = s.get.get({
+    channel: record.channel,
+    chat_id: record.chatId,
+    user_id: userKey
+  });
+  if (!existing) {
+    s.insert.run({
+      id: randomUUID2(),
+      channel: record.channel,
+      chat_id: record.chatId,
+      user_id: userKey,
+      status: "allowed",
+      note: record.note ?? null,
+      created_at: now2,
+      updated_at: now2
+    });
+  }
+  s.update.run({
+    channel: record.channel,
+    chat_id: record.chatId,
+    user_id: userKey,
+    status: "allowed",
+    note: record.note ?? null,
+    updated_at: now2
+  });
+  const stored = s.get.get({
+    channel: record.channel,
+    chat_id: record.chatId,
+    user_id: userKey
+  });
+  return stored ? mapChannelAllow(stored) : {
+    id: randomUUID2(),
+    channel: record.channel,
+    chatId: record.chatId,
+    userId: record.userId,
+    note: record.note,
+    status: "allowed",
+    createdAt: now2,
+    updatedAt: now2
+  };
+}
+async function revokeChannel(s, id) {
+  const rows = s.list.all();
+  const existing = rows.find((row) => String(row.id) === id);
+  if (!existing) {
+    return void 0;
+  }
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  s.revoke.run({
+    id,
+    status: "revoked",
+    updated_at: updatedAt
+  });
+  return { ...mapChannelAllow(existing), status: "revoked", updatedAt };
+}
+
+// packages/storage/src/sqlite/approvals.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function prepareApprovalStatements(db) {
+  return {
+    get: db.prepare(
+      "SELECT id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result FROM approval_requests WHERE id = @id"
+    ),
+    list: db.prepare(
+      "SELECT id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result FROM approval_requests ORDER BY created_at DESC LIMIT @limit"
+    ),
+    listByStatus: db.prepare(
+      "SELECT id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result FROM approval_requests WHERE status = @status ORDER BY created_at DESC LIMIT @limit"
+    ),
+    upsert: db.prepare(
+      "INSERT INTO approval_requests (id, status, kind, tool_name, tool_input, session_id, channel, chat_id, user_id, user_text, risk, reason, created_at, updated_at, expires_at, decided_at, decided_by, result) VALUES (@id, @status, @kind, @tool_name, @tool_input, @session_id, @channel, @chat_id, @user_id, @user_text, @risk, @reason, @created_at, @updated_at, @expires_at, @decided_at, @decided_by, @result) ON CONFLICT(id) DO UPDATE SET status = excluded.status, kind = excluded.kind, tool_name = excluded.tool_name, tool_input = excluded.tool_input, session_id = excluded.session_id, channel = excluded.channel, chat_id = excluded.chat_id, user_id = excluded.user_id, user_text = excluded.user_text, risk = excluded.risk, reason = excluded.reason, updated_at = excluded.updated_at, expires_at = excluded.expires_at, decided_at = excluded.decided_at, decided_by = excluded.decided_by, result = excluded.result"
+    )
+  };
+}
+function mapApproval(row) {
+  const parseJson = (value) => {
+    if (typeof value !== "string" || !value) return void 0;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
+  };
+  const toolInput = parseJson(row.tool_input);
+  const decidedBy = parseJson(row.decided_by);
+  const result = parseJson(row.result);
+  const kind = typeof row.kind === "string" && row.kind.trim() ? row.kind : "tool";
+  return {
+    id: String(row.id),
+    status: String(row.status),
+    kind,
+    toolName: String(row.tool_name),
+    toolInput: toolInput ?? {},
+    sessionId: String(row.session_id),
+    channel: String(row.channel),
+    chatId: String(row.chat_id),
+    userId: row.user_id ? String(row.user_id) : void 0,
+    userText: row.user_text ? String(row.user_text) : void 0,
+    risk: row.risk ? String(row.risk) : void 0,
+    reason: row.reason ? String(row.reason) : void 0,
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    expiresAt: row.expires_at ? String(row.expires_at) : void 0,
+    decidedAt: row.decided_at ? String(row.decided_at) : void 0,
+    decidedBy: decidedBy ?? void 0,
+    result: result ?? void 0
+  };
+}
+function toParams(record) {
+  return {
+    id: record.id,
+    status: record.status,
+    kind: record.kind,
+    tool_name: record.toolName,
+    tool_input: JSON.stringify(record.toolInput ?? {}),
+    session_id: record.sessionId,
+    channel: record.channel,
+    chat_id: record.chatId,
+    user_id: record.userId ?? null,
+    user_text: record.userText ?? null,
+    risk: record.risk ?? null,
+    reason: record.reason ?? null,
+    created_at: record.createdAt,
+    updated_at: record.updatedAt,
+    expires_at: record.expiresAt ?? null,
+    decided_at: record.decidedAt ?? null,
+    decided_by: record.decidedBy ? JSON.stringify(record.decidedBy) : null,
+    result: record.result ? JSON.stringify(record.result) : null
+  };
+}
+async function createApprovalRequest(s, request) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const id = request.id ?? randomUUID3();
+  const existing = await getApprovalRequest(s, id);
+  if (existing) {
+    return existing;
+  }
+  const record = {
+    id,
+    status: request.status ?? "pending",
+    kind: request.kind ?? "tool",
+    toolName: request.toolName,
+    toolInput: request.toolInput ?? {},
+    sessionId: request.sessionId,
+    channel: request.channel,
+    chatId: request.chatId,
+    userId: request.userId,
+    userText: request.userText,
+    risk: request.risk,
+    reason: request.reason,
+    createdAt: request.createdAt ?? now2,
+    updatedAt: request.updatedAt ?? now2,
+    expiresAt: request.expiresAt,
+    decidedAt: request.decidedAt,
+    decidedBy: request.decidedBy,
+    result: request.result
+  };
+  s.upsert.run(toParams(record));
+  return record;
+}
+async function getApprovalRequest(s, id) {
+  const row = s.get.get({ id });
+  return row ? mapApproval(row) : void 0;
+}
+async function listApprovalRequests(s, options) {
+  const limit = options?.limit ?? 50;
+  const status = options?.status;
+  const rows = status ? s.listByStatus.all({ status, limit }) : s.list.all({ limit });
+  return rows.map(mapApproval);
+}
+async function updateApprovalRequest(s, id, update) {
+  const existing = await getApprovalRequest(s, id);
+  if (!existing) {
+    return void 0;
+  }
+  const merged = {
+    ...existing,
+    ...update,
+    id: existing.id,
+    createdAt: existing.createdAt,
+    updatedAt: update.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  s.upsert.run(toParams(merged));
+  return merged;
+}
+
+// packages/storage/src/sqlite/audit.ts
+function prepareAuditStatements(db) {
+  return {
+    insert: db.prepare(
+      "INSERT INTO audit (id, time, type, payload) VALUES (@id, @time, @type, @payload)"
+    )
+  };
+}
+async function appendAudit(s, event) {
+  s.insert.run({
+    id: event.id,
+    time: event.time,
+    type: event.type,
+    payload: event.payload ? JSON.stringify(event.payload) : null
+  });
+}
+
+// packages/storage/src/sqlite/token-usage.ts
+function prepareTokenUsageStatements(db) {
+  return {
+    insert: db.prepare(
+      "INSERT INTO token_usage (id, session_id, provider_id, model, input_tokens, output_tokens, total_tokens, cost_micro, source, created_at) VALUES (@id, @session_id, @provider_id, @model, @input_tokens, @output_tokens, @total_tokens, @cost_micro, @source, @created_at)"
+    ),
+    list: db.prepare(
+      "SELECT id, session_id, provider_id, model, input_tokens, output_tokens, total_tokens, cost_micro, source, created_at FROM token_usage WHERE created_at >= @since ORDER BY created_at DESC LIMIT @limit"
+    ),
+    listBySession: db.prepare(
+      "SELECT id, session_id, provider_id, model, input_tokens, output_tokens, total_tokens, cost_micro, source, created_at FROM token_usage WHERE session_id = @session_id AND created_at >= @since ORDER BY created_at DESC LIMIT @limit"
+    ),
+    listByProvider: db.prepare(
+      "SELECT id, session_id, provider_id, model, input_tokens, output_tokens, total_tokens, cost_micro, source, created_at FROM token_usage WHERE provider_id = @provider_id AND created_at >= @since ORDER BY created_at DESC LIMIT @limit"
+    ),
+    summary: db.prepare(
+      "SELECT provider_id, model, SUM(input_tokens) as total_input_tokens, SUM(output_tokens) as total_output_tokens, SUM(total_tokens) as total_tokens, SUM(COALESCE(cost_micro, 0)) as total_cost_micro, COUNT(*) as call_count FROM token_usage WHERE created_at >= @since GROUP BY provider_id, model ORDER BY total_tokens DESC"
+    ),
+    summaryByProvider: db.prepare(
+      "SELECT provider_id, model, SUM(input_tokens) as total_input_tokens, SUM(output_tokens) as total_output_tokens, SUM(total_tokens) as total_tokens, SUM(COALESCE(cost_micro, 0)) as total_cost_micro, COUNT(*) as call_count FROM token_usage WHERE provider_id = @provider_id AND created_at >= @since GROUP BY provider_id, model ORDER BY total_tokens DESC"
+    )
+  };
+}
+function mapTokenUsage(row) {
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    providerId: String(row.provider_id),
+    model: String(row.model),
+    inputTokens: Number(row.input_tokens ?? 0),
+    outputTokens: Number(row.output_tokens ?? 0),
+    totalTokens: Number(row.total_tokens ?? 0),
+    costMicro: row.cost_micro != null ? Number(row.cost_micro) : void 0,
+    source: row.source ? String(row.source) : void 0,
+    createdAt: String(row.created_at)
+  };
+}
+function mapTokenUsageSummary(row, period) {
+  return {
+    providerId: String(row.provider_id),
+    model: String(row.model),
+    totalInputTokens: Number(row.total_input_tokens ?? 0),
+    totalOutputTokens: Number(row.total_output_tokens ?? 0),
+    totalTokens: Number(row.total_tokens ?? 0),
+    totalCostMicro: Number(row.total_cost_micro ?? 0),
+    callCount: Number(row.call_count ?? 0),
+    period
+  };
+}
+var EPOCH = "1970-01-01T00:00:00.000Z";
+async function appendTokenUsage(s, record) {
+  s.insert.run({
+    id: record.id,
+    session_id: record.sessionId,
+    provider_id: record.providerId,
+    model: record.model,
+    input_tokens: record.inputTokens,
+    output_tokens: record.outputTokens,
+    total_tokens: record.totalTokens,
+    cost_micro: record.costMicro ?? null,
+    source: record.source ?? null,
+    created_at: record.createdAt
+  });
+}
+async function listTokenUsage(s, options) {
+  const since = options?.since ?? EPOCH;
+  const limit = options?.limit ?? 100;
+  let rows;
+  if (options?.sessionId) {
+    rows = s.listBySession.all({
+      session_id: options.sessionId,
+      since,
+      limit
+    });
+  } else if (options?.providerId) {
+    rows = s.listByProvider.all({
+      provider_id: options.providerId,
+      since,
+      limit
+    });
+  } else {
+    rows = s.list.all({ since, limit });
+  }
+  return rows.map(mapTokenUsage);
+}
+async function getTokenUsageSummary(s, options) {
+  const since = options?.since ?? EPOCH;
+  const period = options?.since ? `since:${options.since}` : "all-time";
+  let rows;
+  if (options?.providerId) {
+    rows = s.summaryByProvider.all({
+      provider_id: options.providerId,
+      since
+    });
+  } else {
+    rows = s.summary.all({ since });
+  }
+  return rows.map((row) => mapTokenUsageSummary(row, period));
+}
+
+// packages/storage/src/sqlite/memory-utils.ts
+function generateId() {
+  return `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function serializeEmbedding(embedding) {
+  if (!embedding) return null;
+  return Buffer.from(embedding.buffer);
+}
+function deserializeEmbedding(blob) {
+  if (!blob) return void 0;
+  return new Float32Array(blob.buffer, blob.byteOffset, blob.length / 4);
+}
+function serializeArray(arr) {
+  if (!arr || arr.length === 0) return null;
+  return JSON.stringify(arr);
+}
+function deserializeArray(json) {
+  if (!json) return void 0;
+  try {
+    return JSON.parse(json);
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/storage/src/sqlite/memory-stats.ts
+function getMemoryStats(db) {
+  const tierStatsQuery = db.prepare(`
+    SELECT
+      ms.tier,
+      COUNT(DISTINCT ms.id) as session_count,
+      COALESCE(SUM(ms.message_count), 0) as message_count
+    FROM memory_sessions ms
+    GROUP BY ms.tier
+  `);
+  const tierRows = tierStatsQuery.all();
+  const tierMap = /* @__PURE__ */ new Map();
+  for (const row of tierRows) {
+    tierMap.set(row.tier, {
+      sessions: row.session_count,
+      messages: row.message_count
+    });
+  }
+  const factsCountQuery = db.prepare(`SELECT COUNT(*) as count FROM knowledge_base`);
+  const factsRow = factsCountQuery.get();
+  const totalFacts = factsRow?.count ?? 0;
+  const sessionBoundsQuery = db.prepare(`
+    SELECT
+      MIN(created_at) as oldest,
+      MAX(created_at) as newest
+    FROM memory_sessions
+  `);
+  const boundsRow = sessionBoundsQuery.get();
+  let totalSessions = 0;
+  let totalMessages = 0;
+  for (const stats of tierMap.values()) {
+    totalSessions += stats.sessions;
+    totalMessages += stats.messages;
+  }
+  const emptyTier = { sessions: 0, messages: 0 };
+  return {
+    tiers: {
+      tier1: tierMap.get(1) ?? emptyTier,
+      tier2: tierMap.get(2) ?? emptyTier,
+      tier3: tierMap.get(3) ?? emptyTier,
+      tier4: tierMap.get(4) ?? emptyTier,
+      tier5: tierMap.get(5) ?? emptyTier
+    },
+    totalSessions,
+    totalMessages,
+    totalFacts,
+    oldestSession: boundsRow?.oldest ?? null,
+    newestSession: boundsRow?.newest ?? null
+  };
+}
+
+// packages/storage/src/sqlite/memory.ts
+function prepareMemoryStatements(db) {
+  return {
+    // Sessions
+    getSessionById: db.prepare(`
+      SELECT * FROM memory_sessions WHERE id = ?
+    `),
+    getActiveSession: db.prepare(`
+      SELECT * FROM memory_sessions
+      WHERE user_id = ? AND ended_at IS NULL
+      ORDER BY started_at DESC LIMIT 1
+    `),
+    listSessions: db.prepare(`
+      SELECT * FROM memory_sessions
+      WHERE user_id = ?
+      ORDER BY started_at DESC
+      LIMIT ?
+    `),
+    listSessionsByTier: db.prepare(`
+      SELECT * FROM memory_sessions
+      WHERE user_id = ? AND tier = ?
+      ORDER BY started_at DESC
+      LIMIT ?
+    `),
+    insertSession: db.prepare(`
+      INSERT INTO memory_sessions
+      (id, user_id, started_at, ended_at, topic, message_count, summary, key_entities, importance_score, tier, archived, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+    updateSession: db.prepare(`
+      UPDATE memory_sessions SET
+        ended_at = COALESCE(?, ended_at),
+        topic = COALESCE(?, topic),
+        message_count = COALESCE(?, message_count),
+        summary = COALESCE(?, summary),
+        key_entities = COALESCE(?, key_entities),
+        importance_score = COALESCE(?, importance_score),
+        tier = COALESCE(?, tier),
+        archived = COALESCE(?, archived),
+        updated_at = ?
+      WHERE id = ?
+    `),
+    // Messages
+    getMessageById: db.prepare(`
+      SELECT * FROM memory_messages WHERE id = ?
+    `),
+    listMessages: db.prepare(`
+      SELECT * FROM memory_messages
+      WHERE session_id = ?
+      ORDER BY timestamp ASC
+      LIMIT ?
+    `),
+    listUnprunedMessages: db.prepare(`
+      SELECT * FROM memory_messages
+      WHERE session_id = ? AND pruned = 0
+      ORDER BY timestamp ASC
+      LIMIT ?
+    `),
+    insertMessage: db.prepare(`
+      INSERT INTO memory_messages
+      (id, session_id, content, embedding, embedding_dim, timestamp, role, entities, importance, pruned, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+    updateMessageImportance: db.prepare(`
+      UPDATE memory_messages SET importance = ? WHERE id = ?
+    `),
+    pruneMessages: db.prepare(`
+      UPDATE memory_messages SET pruned = 1 WHERE session_id = ? AND id NOT IN (SELECT value FROM json_each(?))
+    `),
+    // Summaries
+    getSummary: db.prepare(`
+      SELECT * FROM memory_summaries WHERE session_id = ? AND level = ?
+    `),
+    listSummaries: db.prepare(`
+      SELECT * FROM memory_summaries WHERE session_id = ? ORDER BY level ASC
+    `),
+    insertSummary: db.prepare(`
+      INSERT OR REPLACE INTO memory_summaries
+      (id, session_id, level, content, embedding, embedding_dim, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `),
+    // Knowledge
+    getFactById: db.prepare(`
+      SELECT * FROM knowledge_base WHERE id = ?
+    `),
+    listFacts: db.prepare(`
+      SELECT * FROM knowledge_base
+      WHERE user_id = ?
+      ORDER BY confidence DESC, updated_at DESC
+      LIMIT ?
+    `),
+    searchFacts: db.prepare(`
+      SELECT * FROM knowledge_base
+      WHERE user_id = ? AND fact LIKE ?
+      ORDER BY confidence DESC
+      LIMIT ?
+    `),
+    insertFact: db.prepare(`
+      INSERT INTO knowledge_base
+      (id, user_id, fact, source_session_id, confidence, category, embedding, embedding_dim, last_verified, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `),
+    updateFact: db.prepare(`
+      UPDATE knowledge_base SET
+        fact = COALESCE(?, fact),
+        confidence = COALESCE(?, confidence),
+        category = COALESCE(?, category),
+        embedding = COALESCE(?, embedding),
+        embedding_dim = COALESCE(?, embedding_dim),
+        last_verified = COALESCE(?, last_verified),
+        updated_at = ?
+      WHERE id = ?
+    `),
+    deleteFact: db.prepare(`
+      DELETE FROM knowledge_base WHERE id = ?
+    `)
+  };
+}
+function getSessionById2(s, id) {
+  const row = s.getSessionById.get(id);
+  if (!row) return void 0;
+  return mapSessionRow(row);
+}
+function getActiveSession(s, userId) {
+  const row = s.getActiveSession.get(userId);
+  if (!row) return void 0;
+  return mapSessionRow(row);
+}
+function listSessions2(s, userId, options) {
+  const limit = options?.limit ?? 100;
+  let rows;
+  if (options?.tier) {
+    rows = s.listSessionsByTier.all(userId, options.tier, limit);
+  } else {
+    rows = s.listSessions.all(userId, limit);
+  }
+  return rows.map(mapSessionRow);
+}
+function createSession2(s, session) {
+  const id = generateId();
+  const timestamp = now();
+  s.insertSession.run(
+    id,
+    session.userId,
+    session.startedAt,
+    session.endedAt ?? null,
+    session.topic ?? null,
+    session.messageCount,
+    session.summary ?? null,
+    serializeArray(session.keyEntities),
+    session.importanceScore,
+    session.tier,
+    session.archived ? 1 : 0,
+    timestamp,
+    timestamp
+  );
+  return { ...session, id, createdAt: timestamp, updatedAt: timestamp };
+}
+function updateSession2(s, id, update) {
+  s.updateSession.run(
+    update.endedAt ?? null,
+    update.topic ?? null,
+    update.messageCount ?? null,
+    update.summary ?? null,
+    update.keyEntities ? serializeArray(update.keyEntities) : null,
+    update.importanceScore ?? null,
+    update.tier ?? null,
+    update.archived !== void 0 ? update.archived ? 1 : 0 : null,
+    now(),
+    id
+  );
+}
+function mapSessionRow(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    startedAt: row.started_at,
+    endedAt: row.ended_at,
+    topic: row.topic,
+    messageCount: row.message_count,
+    summary: row.summary,
+    keyEntities: deserializeArray(row.key_entities),
+    importanceScore: row.importance_score,
+    tier: row.tier,
+    archived: Boolean(row.archived),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function listMessages(s, sessionId, options) {
+  const limit = options?.limit ?? 1e3;
+  const stmt = options?.includePruned ? s.listMessages : s.listUnprunedMessages;
+  const rows = stmt.all(sessionId, limit);
+  return rows.map(mapMessageRow);
+}
+function createMessage(s, message) {
+  const id = generateId();
+  const timestamp = now();
+  s.insertMessage.run(
+    id,
+    message.sessionId,
+    message.content,
+    serializeEmbedding(message.embedding),
+    message.embeddingDim ?? null,
+    message.timestamp,
+    message.role,
+    serializeArray(message.entities),
+    message.importance,
+    message.pruned ? 1 : 0,
+    timestamp
+  );
+  return { ...message, id, createdAt: timestamp };
+}
+function pruneMessages(s, sessionId, keepIds) {
+  const result = s.pruneMessages.run(sessionId, JSON.stringify(keepIds));
+  return result.changes;
+}
+function mapMessageRow(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    content: row.content,
+    embedding: deserializeEmbedding(row.embedding),
+    embeddingDim: row.embedding_dim,
+    timestamp: row.timestamp,
+    role: row.role,
+    entities: deserializeArray(row.entities),
+    importance: row.importance,
+    pruned: Boolean(row.pruned),
+    createdAt: row.created_at
+  };
+}
+function getSummary(s, sessionId, level) {
+  const row = s.getSummary.get(sessionId, level);
+  if (!row) return void 0;
+  return mapSummaryRow(row);
+}
+function createSummary(s, summary) {
+  const id = `${summary.sessionId}_L${summary.level}`;
+  const timestamp = now();
+  s.insertSummary.run(
+    id,
+    summary.sessionId,
+    summary.level,
+    summary.content,
+    serializeEmbedding(summary.embedding),
+    summary.embeddingDim ?? null,
+    timestamp
+  );
+  return { ...summary, id, createdAt: timestamp };
+}
+function mapSummaryRow(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    level: row.level,
+    content: row.content,
+    embedding: deserializeEmbedding(row.embedding),
+    embeddingDim: row.embedding_dim,
+    createdAt: row.created_at
+  };
+}
+function listFacts(s, userId, limit = 100) {
+  const rows = s.listFacts.all(userId, limit);
+  return rows.map(mapFactRow);
+}
+function searchFacts(s, userId, query, limit = 10) {
+  const rows = s.searchFacts.all(userId, `%${query}%`, limit);
+  return rows.map(mapFactRow);
+}
+function createFact(s, fact) {
+  const id = generateId();
+  const timestamp = now();
+  s.insertFact.run(
+    id,
+    fact.userId,
+    fact.fact,
+    fact.sourceSessionId ?? null,
+    fact.confidence,
+    fact.category ?? null,
+    serializeEmbedding(fact.embedding),
+    fact.embeddingDim ?? null,
+    fact.lastVerified ?? null,
+    timestamp,
+    timestamp
+  );
+  return { ...fact, id, createdAt: timestamp, updatedAt: timestamp };
+}
+function deleteFact(s, id) {
+  const result = s.deleteFact.run(id);
+  return result.changes > 0;
+}
+function mapFactRow(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    fact: row.fact,
+    sourceSessionId: row.source_session_id,
+    confidence: row.confidence,
+    category: row.category,
+    embedding: deserializeEmbedding(row.embedding),
+    embeddingDim: row.embedding_dim,
+    lastVerified: row.last_verified,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+
+// packages/storage/src/sqlite/sync.ts
+function prepareSyncStatements(db) {
+  return {
+    getByDeviceId: db.prepare(
+      "SELECT id, device_id, user_id, last_sync_at, pending_changes, created_at, updated_at FROM device_sync_state WHERE device_id = @device_id"
+    ),
+    listByUserId: db.prepare(
+      "SELECT id, device_id, user_id, last_sync_at, pending_changes, created_at, updated_at FROM device_sync_state WHERE user_id = @user_id ORDER BY updated_at DESC"
+    ),
+    insert: db.prepare(
+      "INSERT INTO device_sync_state (id, device_id, user_id, last_sync_at, pending_changes, created_at, updated_at) VALUES (@id, @device_id, @user_id, @last_sync_at, @pending_changes, @created_at, @updated_at)"
+    ),
+    update: db.prepare(
+      "UPDATE device_sync_state SET last_sync_at = @last_sync_at, pending_changes = @pending_changes, updated_at = @updated_at WHERE device_id = @device_id"
+    ),
+    delete: db.prepare("DELETE FROM device_sync_state WHERE device_id = @device_id"),
+    incrementPending: db.prepare(
+      "UPDATE device_sync_state SET pending_changes = pending_changes + @delta, updated_at = @updated_at WHERE user_id = @user_id AND device_id != @excluded_device_id"
+    )
+  };
+}
+function mapSyncState(row) {
+  return {
+    id: String(row.id),
+    deviceId: String(row.device_id),
+    userId: String(row.user_id),
+    lastSyncAt: row.last_sync_at != null ? Number(row.last_sync_at) : void 0,
+    pendingChanges: Number(row.pending_changes ?? 0),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at)
+  };
+}
+function getSyncState(s, deviceId) {
+  const row = s.getByDeviceId.get({ device_id: deviceId });
+  return row ? mapSyncState(row) : void 0;
+}
+function updateSyncState(s, deviceId, userId, update) {
+  const existing = getSyncState(s, deviceId);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) {
+    const updatedState = {
+      ...existing,
+      lastSyncAt: update.lastSyncAt ?? existing.lastSyncAt,
+      pendingChanges: update.pendingChanges ?? existing.pendingChanges,
+      updatedAt: now2
+    };
+    s.update.run({
+      device_id: deviceId,
+      last_sync_at: updatedState.lastSyncAt ?? null,
+      pending_changes: updatedState.pendingChanges,
+      updated_at: now2
+    });
+    return updatedState;
+  }
+  const id = crypto.randomUUID();
+  const newState = {
+    id,
+    deviceId,
+    userId,
+    lastSyncAt: update.lastSyncAt,
+    pendingChanges: update.pendingChanges ?? 0,
+    createdAt: now2,
+    updatedAt: now2
+  };
+  s.insert.run({
+    id,
+    device_id: deviceId,
+    user_id: userId,
+    last_sync_at: newState.lastSyncAt ?? null,
+    pending_changes: newState.pendingChanges,
+    created_at: now2,
+    updated_at: now2
+  });
+  return newState;
+}
+function listSyncStates(s, userId) {
+  const rows = s.listByUserId.all({ user_id: userId });
+  return rows.map(mapSyncState);
+}
+function deleteSyncState(s, deviceId) {
+  const result = s.delete.run({ device_id: deviceId });
+  return result.changes > 0;
+}
+function incrementPendingChanges(s, userId, excludedDeviceId, delta = 1) {
+  s.incrementPending.run({
+    user_id: userId,
+    excluded_device_id: excludedDeviceId,
+    delta,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function markDeviceSynced(s, deviceId, userId) {
+  return updateSyncState(s, deviceId, userId, {
+    lastSyncAt: Date.now(),
+    pendingChanges: 0
+  });
+}
+
+// packages/storage/src/sqlite/reactions.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+function prepareReactionStatements(db) {
+  return {
+    upsert: db.prepare(
+      "INSERT INTO message_reactions (id, session_id, message_id, reaction, created_at) VALUES (@id, @session_id, @message_id, @reaction, @created_at) ON CONFLICT(message_id) DO UPDATE SET reaction = excluded.reaction, created_at = excluded.created_at"
+    ),
+    getByMessageId: db.prepare(
+      "SELECT id, session_id, message_id, reaction, created_at FROM message_reactions WHERE message_id = @message_id"
+    ),
+    listBySession: db.prepare(
+      "SELECT id, session_id, message_id, reaction, created_at FROM message_reactions WHERE session_id = @session_id ORDER BY created_at DESC"
+    ),
+    deleteByMessageId: db.prepare(
+      "DELETE FROM message_reactions WHERE message_id = @message_id"
+    )
+  };
+}
+function mapReaction(row) {
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    messageId: String(row.message_id),
+    reaction: String(row.reaction),
+    createdAt: String(row.created_at)
+  };
+}
+function setReaction(s, sessionId, messageId, reaction) {
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const id = randomUUID4();
+  s.upsert.run({
+    id,
+    session_id: sessionId,
+    message_id: messageId,
+    reaction,
+    created_at: now2
+  });
+  const stored = getReactionByMessageId(s, messageId);
+  return stored ?? {
+    id,
+    sessionId,
+    messageId,
+    reaction,
+    createdAt: now2
+  };
+}
+function getReactionByMessageId(s, messageId) {
+  const row = s.getByMessageId.get({ message_id: messageId });
+  return row ? mapReaction(row) : void 0;
+}
+function listReactionsBySession(s, sessionId) {
+  const rows = s.listBySession.all({ session_id: sessionId });
+  return rows.map(mapReaction);
+}
+function deleteReaction(s, messageId) {
+  const result = s.deleteByMessageId.run({ message_id: messageId });
+  return result.changes > 0;
+}
+
+// packages/storage/src/sqlite/session-providers.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+function prepareSessionProviderStatements(db) {
+  return {
+    upsertUsage: db.prepare(
+      "INSERT INTO session_providers (session_id, provider_id, model, first_used_at, last_used_at, usage_count) VALUES (@session_id, @provider_id, @model, @first_used_at, @last_used_at, @usage_count) ON CONFLICT(session_id, provider_id) DO UPDATE SET model = excluded.model, last_used_at = excluded.last_used_at, usage_count = session_providers.usage_count + 1"
+    ),
+    insertSwitch: db.prepare(
+      "INSERT INTO provider_switches (id, session_id, from_provider_id, to_provider_id, from_model, to_model, reason, created_at) VALUES (@id, @session_id, @from_provider_id, @to_provider_id, @from_model, @to_model, @reason, @created_at)"
+    )
+  };
+}
+async function upsertSessionProviderUsage(s, entry) {
+  const usedAt = entry.usedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  s.upsertUsage.run({
+    session_id: entry.sessionId,
+    provider_id: entry.providerId,
+    model: entry.model ?? null,
+    first_used_at: usedAt,
+    last_used_at: usedAt,
+    usage_count: 1
+  });
+}
+async function appendProviderSwitch(s, record) {
+  const id = record.id ?? randomUUID5();
+  const createdAt = record.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  s.insertSwitch.run({
+    id,
+    session_id: record.sessionId,
+    from_provider_id: record.fromProviderId ?? null,
+    to_provider_id: record.toProviderId ?? null,
+    from_model: record.fromModel ?? null,
+    to_model: record.toModel ?? null,
+    reason: record.reason ?? null,
+    created_at: createdAt
+  });
+  return {
+    id,
+    sessionId: record.sessionId,
+    fromProviderId: record.fromProviderId,
+    toProviderId: record.toProviderId,
+    fromModel: record.fromModel,
+    toModel: record.toModel,
+    reason: record.reason,
+    createdAt
+  };
+}
+
+// packages/storage/src/sqlite/agent-runs.ts
+function prepareAgentRunStatements(db) {
+  return {
+    get: db.prepare(
+      "SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, timeout_ms, channel, chat_id, user_id, provider_id, model, system, text, metadata, metrics, result_summary, error FROM agent_runs WHERE id = @id"
+    ),
+    upsert: db.prepare(
+      "INSERT INTO agent_runs (id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, timeout_ms, channel, chat_id, user_id, provider_id, model, system, text, metadata, metrics, result_summary, error) VALUES (@id, @session_id, @agent_id, @parent_agent_id, @parent_run_id, @lane, @status, @created_at, @started_at, @ended_at, @timeout_ms, @channel, @chat_id, @user_id, @provider_id, @model, @system, @text, @metadata, @metrics, @result_summary, @error) ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, agent_id = excluded.agent_id, parent_agent_id = excluded.parent_agent_id, parent_run_id = excluded.parent_run_id, lane = excluded.lane, status = excluded.status, created_at = excluded.created_at, started_at = excluded.started_at, ended_at = excluded.ended_at, timeout_ms = excluded.timeout_ms, channel = excluded.channel, chat_id = excluded.chat_id, user_id = excluded.user_id, provider_id = excluded.provider_id, model = excluded.model, system = excluded.system, text = excluded.text, metadata = excluded.metadata, metrics = excluded.metrics, result_summary = excluded.result_summary, error = excluded.error"
+    ),
+    eventInsert: db.prepare(
+      "INSERT INTO agent_run_events (id, run_id, time, type, payload) VALUES (@id, @run_id, @time, @type, @payload)"
+    ),
+    eventList: db.prepare(
+      "SELECT id, run_id, time, type, payload FROM agent_run_events WHERE run_id = @run_id ORDER BY time DESC LIMIT @limit"
+    )
+  };
+}
+function mapAgentRun(row) {
+  const parseJson = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: row.session_id ? String(row.session_id) : void 0,
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    parentAgentId: row.parent_agent_id ? String(row.parent_agent_id) : void 0,
+    parentRunId: row.parent_run_id ? String(row.parent_run_id) : void 0,
+    lane: String(row.lane),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    timeoutMs: row.timeout_ms === null || row.timeout_ms === void 0 ? void 0 : Number(row.timeout_ms),
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    metadata: parseJson(row.metadata),
+    metrics: parseJson(row.metrics),
+    resultSummary: row.result_summary ? String(row.result_summary) : void 0,
+    error: row.error ? String(row.error) : void 0
+  };
+}
+function mapAgentRunEvent(row) {
+  return {
+    id: String(row.id),
+    runId: String(row.run_id),
+    time: String(row.time),
+    type: String(row.type),
+    payload: row.payload ? JSON.parse(String(row.payload)) : void 0
+  };
+}
+async function getAgentRun(s, id) {
+  const row = s.get.get({ id });
+  return row ? mapAgentRun(row) : void 0;
+}
+async function upsertAgentRun(s, record) {
+  s.upsert.run({
+    id: record.id,
+    session_id: record.sessionId ?? null,
+    agent_id: record.agentId ?? null,
+    parent_agent_id: record.parentAgentId ?? null,
+    parent_run_id: record.parentRunId ?? null,
+    lane: record.lane,
+    status: record.status,
+    created_at: record.createdAt,
+    started_at: record.startedAt ?? null,
+    ended_at: record.endedAt ?? null,
+    timeout_ms: record.timeoutMs ?? null,
+    channel: record.channel ?? null,
+    chat_id: record.chatId ?? null,
+    user_id: record.userId ?? null,
+    provider_id: record.providerId ?? null,
+    model: record.model ?? null,
+    system: record.system ?? null,
+    text: record.text ?? null,
+    metadata: record.metadata ? JSON.stringify(record.metadata) : null,
+    metrics: record.metrics ? JSON.stringify(record.metrics) : null,
+    result_summary: record.resultSummary ?? null,
+    error: record.error ?? null
+  });
+  return record;
+}
+async function listAgentRuns(db, options) {
+  const clauses = [];
+  const params = {};
+  if (options?.status) {
+    clauses.push("status = @status");
+    params.status = options.status;
+  }
+  if (options?.lane) {
+    clauses.push("lane = @lane");
+    params.lane = options.lane;
+  }
+  if (options?.sessionId) {
+    clauses.push("session_id = @session_id");
+    params.session_id = options.sessionId;
+  }
+  if (options?.since) {
+    clauses.push("created_at >= @since");
+    params.since = options.since;
+  }
+  const limit = options?.limit ?? 50;
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const query = `SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, timeout_ms, channel, chat_id, user_id, provider_id, model, system, text, metadata, metrics, result_summary, error FROM agent_runs ${where} ORDER BY created_at DESC LIMIT @limit`;
+  const stmt = db.prepare(query);
+  const rows = stmt.all({ ...params, limit });
+  return rows.map(mapAgentRun);
+}
+async function appendAgentRunEvent(s, event) {
+  s.eventInsert.run({
+    id: event.id,
+    run_id: event.runId,
+    time: event.time,
+    type: event.type,
+    payload: event.payload ? JSON.stringify(event.payload) : null
+  });
+}
+async function listAgentRunEvents(s, runId, options) {
+  const limit = options?.limit ?? 50;
+  const rows = s.eventList.all({ run_id: runId, limit });
+  return rows.map(mapAgentRunEvent).reverse();
+}
+
+// packages/storage/src/sqlite/agent-queue.ts
+function prepareAgentQueueStatements(db) {
+  return {
+    get: db.prepare(
+      "SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, lease_until, priority, channel, chat_id, user_id, provider_id, model, system, text, timeout_ms, tool_policy, metadata, error FROM agent_queue WHERE id = @id"
+    ),
+    upsert: db.prepare(
+      "INSERT INTO agent_queue (id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, lease_until, priority, channel, chat_id, user_id, provider_id, model, system, text, timeout_ms, tool_policy, metadata, error) VALUES (@id, @session_id, @agent_id, @parent_agent_id, @parent_run_id, @lane, @status, @created_at, @started_at, @ended_at, @lease_until, @priority, @channel, @chat_id, @user_id, @provider_id, @model, @system, @text, @timeout_ms, @tool_policy, @metadata, @error) ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, agent_id = excluded.agent_id, parent_agent_id = excluded.parent_agent_id, parent_run_id = excluded.parent_run_id, lane = excluded.lane, status = excluded.status, created_at = excluded.created_at, started_at = excluded.started_at, ended_at = excluded.ended_at, lease_until = excluded.lease_until, priority = excluded.priority, channel = excluded.channel, chat_id = excluded.chat_id, user_id = excluded.user_id, provider_id = excluded.provider_id, model = excluded.model, system = excluded.system, text = excluded.text, timeout_ms = excluded.timeout_ms, tool_policy = excluded.tool_policy, metadata = excluded.metadata, error = excluded.error"
+    )
+  };
+}
+var mapRecord = (row) => {
+  const parseJson = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: row.session_id ? String(row.session_id) : void 0,
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    parentAgentId: row.parent_agent_id ? String(row.parent_agent_id) : void 0,
+    parentRunId: row.parent_run_id ? String(row.parent_run_id) : void 0,
+    lane: String(row.lane),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    leaseUntil: row.lease_until ? String(row.lease_until) : void 0,
+    priority: row.priority === null || row.priority === void 0 ? void 0 : Number(row.priority),
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    providerId: row.provider_id ? String(row.provider_id) : void 0,
+    model: row.model ? String(row.model) : void 0,
+    system: row.system ? String(row.system) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    timeoutMs: row.timeout_ms === null || row.timeout_ms === void 0 ? void 0 : Number(row.timeout_ms),
+    toolPolicy: parseJson(row.tool_policy),
+    metadata: parseJson(row.metadata),
+    error: row.error ? String(row.error) : void 0
+  };
+};
+async function getAgentQueue(s, id) {
+  const row = s.get.get({ id });
+  return row ? mapRecord(row) : void 0;
+}
+async function upsertAgentQueue(s, record) {
+  s.upsert.run({
+    id: record.id,
+    session_id: record.sessionId ?? null,
+    agent_id: record.agentId ?? null,
+    parent_agent_id: record.parentAgentId ?? null,
+    parent_run_id: record.parentRunId ?? null,
+    lane: record.lane,
+    status: record.status,
+    created_at: record.createdAt,
+    started_at: record.startedAt ?? null,
+    ended_at: record.endedAt ?? null,
+    lease_until: record.leaseUntil ?? null,
+    priority: record.priority ?? null,
+    channel: record.channel ?? null,
+    chat_id: record.chatId ?? null,
+    user_id: record.userId ?? null,
+    provider_id: record.providerId ?? null,
+    model: record.model ?? null,
+    system: record.system ?? null,
+    text: record.text ?? null,
+    timeout_ms: record.timeoutMs ?? null,
+    tool_policy: record.toolPolicy ? JSON.stringify(record.toolPolicy) : null,
+    metadata: record.metadata ? JSON.stringify(record.metadata) : null,
+    error: record.error ?? null
+  });
+  return record;
+}
+async function listAgentQueue(db, options) {
+  const clauses = [];
+  const params = {};
+  if (options?.status) {
+    clauses.push("status = @status");
+    params.status = options.status;
+  }
+  if (options?.lane) {
+    clauses.push("lane = @lane");
+    params.lane = options.lane;
+  }
+  if (options?.sessionId) {
+    clauses.push("session_id = @session_id");
+    params.session_id = options.sessionId;
+  }
+  if (options?.agentId) {
+    clauses.push("agent_id = @agent_id");
+    params.agent_id = options.agentId;
+  }
+  const limit = options?.limit ?? 50;
+  const order = options?.order === "asc" ? "ASC" : "DESC";
+  const orderBy = options?.orderBy === "priority" ? "COALESCE(priority, 0) DESC, created_at" : "created_at";
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const query = `SELECT id, session_id, agent_id, parent_agent_id, parent_run_id, lane, status, created_at, started_at, ended_at, lease_until, priority, channel, chat_id, user_id, provider_id, model, system, text, timeout_ms, tool_policy, metadata, error FROM agent_queue ${where} ORDER BY ${orderBy} ${order} LIMIT @limit`;
+  const stmt = db.prepare(query);
+  const rows = stmt.all({ ...params, limit });
+  return rows.map(mapRecord);
+}
+
+// packages/storage/src/sqlite/session-inbox.ts
+function prepareSessionInboxStatements(db) {
+  return {
+    get: db.prepare(
+      "SELECT id, session_id, status, created_at, started_at, ended_at, channel, chat_id, user_id, text, metadata, error FROM session_inbox WHERE id = @id"
+    ),
+    upsert: db.prepare(
+      "INSERT INTO session_inbox (id, session_id, status, created_at, started_at, ended_at, channel, chat_id, user_id, text, metadata, error) VALUES (@id, @session_id, @status, @created_at, @started_at, @ended_at, @channel, @chat_id, @user_id, @text, @metadata, @error) ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, status = excluded.status, created_at = excluded.created_at, started_at = excluded.started_at, ended_at = excluded.ended_at, channel = excluded.channel, chat_id = excluded.chat_id, user_id = excluded.user_id, text = excluded.text, metadata = excluded.metadata, error = excluded.error"
+    )
+  };
+}
+var mapRecord2 = (row) => {
+  const parseJson = (value) => {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(String(value));
+    } catch {
+      return void 0;
+    }
+  };
+  return {
+    id: String(row.id),
+    sessionId: String(row.session_id),
+    status: String(row.status),
+    createdAt: String(row.created_at),
+    startedAt: row.started_at ? String(row.started_at) : void 0,
+    endedAt: row.ended_at ? String(row.ended_at) : void 0,
+    channel: row.channel ? String(row.channel) : void 0,
+    chatId: row.chat_id ? String(row.chat_id) : void 0,
+    userId: row.user_id ? String(row.user_id) : void 0,
+    text: row.text ? String(row.text) : void 0,
+    metadata: parseJson(row.metadata),
+    error: row.error ? String(row.error) : void 0
+  };
+};
+async function getSessionInbox(s, id) {
+  const row = s.get.get({ id });
+  return row ? mapRecord2(row) : void 0;
+}
+async function upsertSessionInbox(s, record) {
+  s.upsert.run({
+    id: record.id,
+    session_id: record.sessionId,
+    status: record.status,
+    created_at: record.createdAt,
+    started_at: record.startedAt ?? null,
+    ended_at: record.endedAt ?? null,
+    channel: record.channel ?? null,
+    chat_id: record.chatId ?? null,
+    user_id: record.userId ?? null,
+    text: record.text ?? null,
+    metadata: record.metadata ? JSON.stringify(record.metadata) : null,
+    error: record.error ?? null
+  });
+  return record;
+}
+async function listSessionInbox(db, options) {
+  const clauses = [];
+  const params = {};
+  if (options?.sessionId) {
+    clauses.push("session_id = @session_id");
+    params.session_id = options.sessionId;
+  }
+  if (options?.status) {
+    clauses.push("status = @status");
+    params.status = options.status;
+  }
+  const limit = options?.limit ?? 50;
+  const order = options?.order === "asc" ? "ASC" : "DESC";
+  const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+  const query = `SELECT id, session_id, status, created_at, started_at, ended_at, channel, chat_id, user_id, text, metadata, error FROM session_inbox ${where} ORDER BY created_at ${order} LIMIT @limit`;
+  const stmt = db.prepare(query);
+  const rows = stmt.all({ ...params, limit });
+  return rows.map(mapRecord2);
+}
+
+// packages/storage/src/sqlite/session-routes.ts
+function prepareSessionRouteStatements(db) {
+  return {
+    get: db.prepare(
+      "SELECT session_id, agent_id, lane_id, queue_mode, announce_mode, updated_at FROM session_routes WHERE session_id = @session_id"
+    ),
+    upsert: db.prepare(
+      "INSERT INTO session_routes (session_id, agent_id, lane_id, queue_mode, announce_mode, updated_at) VALUES (@session_id, @agent_id, @lane_id, @queue_mode, @announce_mode, @updated_at) ON CONFLICT(session_id) DO UPDATE SET agent_id = excluded.agent_id, lane_id = excluded.lane_id, queue_mode = excluded.queue_mode, announce_mode = excluded.announce_mode, updated_at = excluded.updated_at"
+    ),
+    list: db.prepare(
+      "SELECT session_id, agent_id, lane_id, queue_mode, announce_mode, updated_at FROM session_routes ORDER BY updated_at DESC LIMIT @limit"
+    )
+  };
+}
+var mapRoute = (row) => {
+  return {
+    sessionId: String(row.session_id),
+    agentId: row.agent_id ? String(row.agent_id) : void 0,
+    laneId: row.lane_id ? String(row.lane_id) : void 0,
+    queueMode: row.queue_mode ? String(row.queue_mode) : void 0,
+    announceMode: row.announce_mode ? String(row.announce_mode) : void 0,
+    updatedAt: row.updated_at ? String(row.updated_at) : (/* @__PURE__ */ new Date()).toISOString()
+  };
+};
+async function getSessionRoute(s, sessionId) {
+  const row = s.get.get({ session_id: sessionId });
+  return row ? mapRoute(row) : void 0;
+}
+async function upsertSessionRoute(s, record) {
+  s.upsert.run({
+    session_id: record.sessionId,
+    agent_id: record.agentId ?? null,
+    lane_id: record.laneId ?? null,
+    queue_mode: record.queueMode ?? null,
+    announce_mode: record.announceMode ?? null,
+    updated_at: record.updatedAt
+  });
+  return record;
+}
+async function listSessionRoutes(s, options) {
+  const limit = options?.limit ?? 100;
+  const rows = s.list.all({ limit });
+  return rows.map(mapRoute);
+}
+
+// packages/storage/src/sqlite/agent-store.ts
+var createSqliteAgentStore = (db, agentRunStmts, agentQueueStmts, inboxStmts) => {
+  return {
+    async upsertAgentRun(record) {
+      return upsertAgentRun(agentRunStmts, record);
+    },
+    async updateAgentRun(id, update) {
+      const existing = await getAgentRun(agentRunStmts, id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      await upsertAgentRun(agentRunStmts, merged);
+      return merged;
+    },
+    async getAgentRun(id) {
+      return getAgentRun(agentRunStmts, id);
+    },
+    async listAgentRuns(options) {
+      return listAgentRuns(db, options);
+    },
+    async enqueueAgentQueue(record) {
+      return upsertAgentQueue(agentQueueStmts, record);
+    },
+    async updateAgentQueue(id, update) {
+      const existing = await getAgentQueue(agentQueueStmts, id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      await upsertAgentQueue(agentQueueStmts, merged);
+      return merged;
+    },
+    async getAgentQueue(id) {
+      return getAgentQueue(agentQueueStmts, id);
+    },
+    async listAgentQueue(options) {
+      return listAgentQueue(db, options);
+    },
+    async appendAgentRunEvent(event) {
+      return appendAgentRunEvent(agentRunStmts, event);
+    },
+    async listAgentRunEvents(runId, options) {
+      return listAgentRunEvents(agentRunStmts, runId, options);
+    },
+    async enqueueSessionInbox(record) {
+      return upsertSessionInbox(inboxStmts, record);
+    },
+    async updateSessionInbox(id, update) {
+      const existing = await getSessionInbox(inboxStmts, id);
+      if (!existing) return void 0;
+      const merged = { ...existing, ...update };
+      await upsertSessionInbox(inboxStmts, merged);
+      return merged;
+    },
+    async getSessionInbox(id) {
+      return getSessionInbox(inboxStmts, id);
+    },
+    async listSessionInbox(options) {
+      return listSessionInbox(db, options);
+    }
+  };
+};
+
+// packages/storage/src/sqlite/memory-store.ts
+var createSqliteMemoryStore = (db, memoryStmts, syncStmts, reactionStmts) => {
+  return {
+    getMemorySession: (id) => getSessionById2(memoryStmts, id),
+    getActiveMemorySession: (userId) => getActiveSession(memoryStmts, userId),
+    listMemorySessions: (userId, options) => listSessions2(memoryStmts, userId, options),
+    createMemorySession: (session) => createSession2(memoryStmts, session),
+    updateMemorySession: (id, update) => updateSession2(memoryStmts, id, update),
+    listMemoryMessages: (sessionId, options) => listMessages(memoryStmts, sessionId, options),
+    createMemoryMessage: (message) => createMessage(memoryStmts, message),
+    pruneMemoryMessages: (sessionId, keepIds) => pruneMessages(memoryStmts, sessionId, keepIds),
+    createMemorySummary: (summary) => createSummary(memoryStmts, summary),
+    listKnowledgeFacts: (userId, limit) => listFacts(memoryStmts, userId, limit),
+    searchKnowledgeFacts: (userId, query, limit) => searchFacts(memoryStmts, userId, query, limit),
+    createKnowledgeFact: (fact) => createFact(memoryStmts, fact),
+    deleteKnowledgeFact: (id) => deleteFact(memoryStmts, id),
+    getMemoryStats: () => getMemoryStats(db),
+    getSyncState: (deviceId) => getSyncState(syncStmts, deviceId),
+    updateSyncState: (deviceId, userId, update) => updateSyncState(syncStmts, deviceId, userId, update),
+    listSyncStates: (userId) => listSyncStates(syncStmts, userId),
+    deleteSyncState: (deviceId) => deleteSyncState(syncStmts, deviceId),
+    incrementPendingChanges: (userId, excludedDeviceId, delta = 1) => incrementPendingChanges(syncStmts, userId, excludedDeviceId, delta),
+    markDeviceSynced: (deviceId, userId) => markDeviceSynced(syncStmts, deviceId, userId),
+    setMessageReaction: (sessionId, messageId, reaction) => setReaction(reactionStmts, sessionId, messageId, reaction),
+    getMessageReaction: (messageId) => getReactionByMessageId(reactionStmts, messageId),
+    listMessageReactions: (sessionId) => listReactionsBySession(reactionStmts, sessionId),
+    deleteMessageReaction: (messageId) => deleteReaction(reactionStmts, messageId)
+  };
+};
+
+// packages/storage/src/sqlite/session-route-store.ts
+var createSqliteSessionRouteStore = (routeStmts) => {
+  return {
+    async getSessionRoute(sessionId) {
+      return getSessionRoute(routeStmts, sessionId);
+    },
+    async setSessionRoute(sessionId, route) {
+      const record = {
+        sessionId,
+        ...route,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return upsertSessionRoute(routeStmts, record);
+    },
+    async listSessionRoutes(options) {
+      return listSessionRoutes(routeStmts, options);
+    }
+  };
+};
+
+// packages/storage/src/sqlite/storage.ts
+var SqliteStorage = class {
+  db;
+  sessionStmts;
+  deviceStmts;
+  channelStmts;
+  approvalStmts;
+  auditStmts;
+  tokenUsageStmts;
+  memoryStmts;
+  syncStmts;
+  reactionStmts;
+  sessionProviderStmts;
+  agentRunStmts;
+  agentQueueStmts;
+  sessionInboxStmts;
+  sessionRouteStmts;
+  constructor(options) {
+    this.db = createConnection(options.sqlitePath);
+    initSchema(this.db);
+    this.sessionStmts = prepareSessionStatements(this.db);
+    this.deviceStmts = prepareDeviceStatements(this.db);
+    this.channelStmts = prepareChannelStatements(this.db);
+    this.approvalStmts = prepareApprovalStatements(this.db);
+    this.auditStmts = prepareAuditStatements(this.db);
+    this.tokenUsageStmts = prepareTokenUsageStatements(this.db);
+    this.memoryStmts = prepareMemoryStatements(this.db);
+    this.syncStmts = prepareSyncStatements(this.db);
+    this.reactionStmts = prepareReactionStatements(this.db);
+    this.sessionProviderStmts = prepareSessionProviderStatements(this.db);
+    this.agentRunStmts = prepareAgentRunStatements(this.db);
+    this.agentQueueStmts = prepareAgentQueueStatements(this.db);
+    this.sessionInboxStmts = prepareSessionInboxStatements(this.db);
+    this.sessionRouteStmts = prepareSessionRouteStatements(this.db);
+    Object.assign(
+      this,
+      createSqliteAgentStore(
+        this.db,
+        this.agentRunStmts,
+        this.agentQueueStmts,
+        this.sessionInboxStmts
+      )
+    );
+    Object.assign(this, createSqliteSessionRouteStore(this.sessionRouteStmts));
+    Object.assign(
+      this,
+      createSqliteMemoryStore(this.db, this.memoryStmts, this.syncStmts, this.reactionStmts)
+    );
+  }
+  // -- Sessions -----------------------------------------------------------
+  async getSessionByKey(key) {
+    return getSessionByKey(this.sessionStmts, key);
+  }
+  async getSessionById(id) {
+    return getSessionById(this.sessionStmts, id);
+  }
+  async listSessions() {
+    return listSessions(this.sessionStmts);
+  }
+  async createSession(key, meta) {
+    return createSession(this.sessionStmts, key, meta);
+  }
+  async updateSession(id, update) {
+    return updateSession(this.sessionStmts, id, update);
+  }
+  async appendSessionEvent(event) {
+    return appendSessionEvent(this.sessionStmts, event);
+  }
+  async listSessionEvents(sessionId, options) {
+    return listSessionEvents(this.sessionStmts, sessionId, options);
+  }
+  async countSessionEvents(sessionId) {
+    return countSessionEvents(this.sessionStmts, sessionId);
+  }
+  async getSessionSummary(sessionId) {
+    return getSessionSummary(this.sessionStmts, sessionId);
+  }
+  async setSessionSummary(sessionId, summary, eventCount) {
+    return setSessionSummary(this.sessionStmts, sessionId, summary, eventCount);
+  }
+  async getToolPolicy() {
+    return getToolPolicy(this.sessionStmts);
+  }
+  async setToolPolicy(policy) {
+    return setToolPolicy(this.sessionStmts, policy);
+  }
+  async appendProviderSwitch(record) {
+    await appendProviderSwitch(this.sessionProviderStmts, record);
+  }
+  async upsertSessionProviderUsage(entry) {
+    await upsertSessionProviderUsage(this.sessionProviderStmts, entry);
+  }
+  async getSessionPrefs(sessionId) {
+    return getSessionPrefs(this.sessionStmts, sessionId);
+  }
+  async setSessionPrefs(sessionId, prefs) {
+    return setSessionPrefs(this.sessionStmts, sessionId, prefs);
+  }
+  async clearSessionPrefs(sessionId) {
+    return clearSessionPrefs(this.sessionStmts, sessionId);
+  }
+  // -- Devices ------------------------------------------------------------
+  async listDevices() {
+    return listDevices(this.deviceStmts);
+  }
+  async getDeviceById(id) {
+    return getDeviceById(this.deviceStmts, id);
+  }
+  async getDeviceByTokenHash(tokenHash) {
+    return getDeviceByTokenHash(this.deviceStmts, tokenHash);
+  }
+  async createDevice(record) {
+    return createDevice(this.deviceStmts, record);
+  }
+  async updateDevice(id, update) {
+    return updateDevice(this.deviceStmts, id, update);
+  }
+  async revokeDevice(id) {
+    return revokeDevice(this.deviceStmts, id);
+  }
+  async touchDevice(id) {
+    return touchDevice(this.deviceStmts, id);
+  }
+  // -- Channel Allows -----------------------------------------------------
+  async listChannelAllows(channel) {
+    return listChannelAllows(this.channelStmts, channel);
+  }
+  async getChannelAllow(channel, chatId, userId) {
+    return getChannelAllow(this.channelStmts, channel, chatId, userId);
+  }
+  async allowChannel(record) {
+    return allowChannel(this.channelStmts, record);
+  }
+  async revokeChannel(id) {
+    return revokeChannel(this.channelStmts, id);
+  }
+  // -- Approval Requests --------------------------------------------------
+  async createApprovalRequest(request) {
+    return createApprovalRequest(this.approvalStmts, request);
+  }
+  async getApprovalRequest(id) {
+    return getApprovalRequest(this.approvalStmts, id);
+  }
+  async listApprovalRequests(options) {
+    return listApprovalRequests(this.approvalStmts, options);
+  }
+  async updateApprovalRequest(id, update) {
+    return updateApprovalRequest(this.approvalStmts, id, update);
+  }
+  // -- Audit --------------------------------------------------------------
+  async appendAudit(event) {
+    return appendAudit(this.auditStmts, event);
+  }
+  // -- Session Inbox (methods provided via createSqliteAgentStore) ---------
+  // -- Token Usage --------------------------------------------------------
+  async appendTokenUsage(record) {
+    return appendTokenUsage(this.tokenUsageStmts, record);
+  }
+  async listTokenUsage(options) {
+    return listTokenUsage(this.tokenUsageStmts, options);
+  }
+  async getTokenUsageSummary(options) {
+    return getTokenUsageSummary(this.tokenUsageStmts, options);
+  }
+  // -- Memory/Sync/Reactions (methods provided via createSqliteMemoryStore) --
+  // -- Lifecycle ----------------------------------------------------------
+  async close() {
+    this.db.close();
+  }
+};
+
+export {
+  createConnection,
+  initSchema,
+  resetMemoryTables,
+  getSchemaInfo,
+  prepareSessionStatements,
+  getSessionByKey,
+  getSessionById,
+  listSessions,
+  createSession,
+  updateSession,
+  appendSessionEvent,
+  listSessionEvents,
+  countSessionEvents,
+  getSessionSummary,
+  setSessionSummary,
+  getToolPolicy,
+  setToolPolicy,
+  getSessionPrefs,
+  setSessionPrefs,
+  clearSessionPrefs,
+  prepareDeviceStatements,
+  listDevices,
+  getDeviceById,
+  getDeviceByTokenHash,
+  createDevice,
+  updateDevice,
+  revokeDevice,
+  touchDevice,
+  prepareChannelStatements,
+  listChannelAllows,
+  getChannelAllow,
+  allowChannel,
+  revokeChannel,
+  prepareApprovalStatements,
+  createApprovalRequest,
+  getApprovalRequest,
+  listApprovalRequests,
+  updateApprovalRequest,
+  prepareAuditStatements,
+  appendAudit,
+  prepareTokenUsageStatements,
+  appendTokenUsage,
+  listTokenUsage,
+  getTokenUsageSummary,
+  getMemoryStats,
+  prepareMemoryStatements,
+  getSessionById2,
+  getActiveSession,
+  listSessions2,
+  createSession2,
+  updateSession2,
+  listMessages,
+  createMessage,
+  pruneMessages,
+  getSummary,
+  createSummary,
+  listFacts,
+  searchFacts,
+  createFact,
+  deleteFact,
+  prepareSyncStatements,
+  getSyncState,
+  updateSyncState,
+  listSyncStates,
+  deleteSyncState,
+  incrementPendingChanges,
+  markDeviceSynced,
+  prepareReactionStatements,
+  setReaction,
+  getReactionByMessageId,
+  listReactionsBySession,
+  deleteReaction,
+  SqliteStorage
+};
+//# sourceMappingURL=chunk-SMVJRPAH.js.map