@axiom-lattice/local-stores 1.0.1

package/dist/index.js

@@ -0,0 +1,3372 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DatabaseWrapper: () => DatabaseWrapper,
+  LocalA2AApiKeyStore: () => LocalA2AApiKeyStore,
+  LocalAssistantStore: () => LocalAssistantStore,
+  LocalChannelBindingStore: () => LocalChannelBindingStore,
+  LocalChannelInstallationStore: () => LocalChannelInstallationStore,
+  LocalDatabaseConfigStore: () => LocalDatabaseConfigStore,
+  LocalEvalStore: () => LocalEvalStore,
+  LocalMcpServerConfigStore: () => LocalMcpServerConfigStore,
+  LocalMetricsServerConfigStore: () => LocalMetricsServerConfigStore,
+  LocalProjectStore: () => LocalProjectStore,
+  LocalScheduleStorage: () => LocalScheduleStorage,
+  LocalSkillStore: () => LocalSkillStore,
+  LocalTenantStore: () => LocalTenantStore,
+  LocalThreadMessageQueueStore: () => LocalThreadMessageQueueStore,
+  LocalThreadStore: () => LocalThreadStore,
+  LocalUserStore: () => LocalUserStore,
+  LocalUserTenantLinkStore: () => LocalUserTenantLinkStore,
+  LocalWorkflowTrackingStore: () => LocalWorkflowTrackingStore,
+  LocalWorkspaceStore: () => LocalWorkspaceStore,
+  RunResult: () => RunResult,
+  StatementWrapper: () => StatementWrapper,
+  closeDatabase: () => closeDatabase,
+  createLocalStoreConfig: () => createLocalStoreConfig,
+  ensureTable: () => ensureTable,
+  getDatabase: () => getDatabase,
+  initDatabase: () => initDatabase,
+  nowISO: () => nowISO,
+  parseISO: () => parseISO
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/database.ts
+var import_sql = __toESM(require("sql.js"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var fs = __toESM(require("fs"));
+var _SQL = null;
+var _db = null;
+function expandHome(filePath) {
+  if (filePath.startsWith("~")) {
+    return path.join(os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+var DatabaseWrapper = class {
+  constructor(sql, dbPath) {
+    this.dbPath = dbPath;
+    if (fs.existsSync(dbPath)) {
+      const buffer = fs.readFileSync(dbPath);
+      this.db = new sql.Database(buffer);
+    } else {
+      this.db = new sql.Database();
+    }
+  }
+  /**
+   * Execute a SQL statement and return the wrapper for chaining (run).
+   * Automatically persists changes to disk.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  run(sql, ...params) {
+    this.db.run(sql, params);
+    this.save();
+    return new RunResult(this.db);
+  }
+  /**
+   * Prepare and execute a query returning all matching rows as objects.
+   */
+  prepare(sql) {
+    return new StatementWrapper(this.db, sql, this);
+  }
+  /**
+   * Execute raw SQL (for DDL statements).
+   */
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  /**
+   * Persist the database to disk.
+   */
+  save() {
+    const data = this.db.export();
+    const buffer = Buffer.from(data);
+    fs.writeFileSync(this.dbPath, buffer);
+  }
+  /**
+   * Close the database.
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Get the underlying sql.js database instance.
+   */
+  getRawDb() {
+    return this.db;
+  }
+};
+var StatementWrapper = class {
+  constructor(db, sql, parent) {
+    this.db = db;
+    this.sql = sql;
+    this.parent = parent || null;
+  }
+  /**
+   * Execute and return all rows as objects.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  all(...params) {
+    const stmt = this.db.prepare(this.sql);
+    try {
+      if (params.length > 0) {
+        stmt.bind(params);
+      }
+      const rows = [];
+      while (stmt.step()) {
+        rows.push(stmt.getAsObject());
+      }
+      return rows;
+    } finally {
+      stmt.free();
+    }
+  }
+  /**
+   * Execute and return the first row as an object, or undefined.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(...params) {
+    const stmt = this.db.prepare(this.sql);
+    try {
+      if (params.length > 0) {
+        stmt.bind(params);
+      }
+      if (stmt.step()) {
+        return stmt.getAsObject();
+      }
+      return void 0;
+    } finally {
+      stmt.free();
+    }
+  }
+  /**
+   * Execute without returning rows (INSERT/UPDATE/DELETE).
+   * Automatically persists changes to disk.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  run(...params) {
+    this.db.run(this.sql, params);
+    if (this.parent) {
+      this.parent.save();
+    }
+    return new RunResult(this.db);
+  }
+};
+var RunResult = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /** Number of rows modified by the last INSERT/UPDATE/DELETE. */
+  get changes() {
+    return this.db.getRowsModified();
+  }
+};
+async function initDatabase(options = {}) {
+  if (_db) return _db;
+  if (!_SQL) {
+    _SQL = await (0, import_sql.default)();
+  }
+  const rawPath = options.dbPath || "~/.axiom/lattice.db";
+  const dbPath = expandHome(rawPath);
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  _db = new DatabaseWrapper(_SQL, dbPath);
+  _db.exec("PRAGMA journal_mode = WAL;");
+  _db.exec("PRAGMA foreign_keys = ON;");
+  return _db;
+}
+function getDatabase() {
+  if (!_db) {
+    throw new Error("Database not initialized. Call await initDatabase() first.");
+  }
+  return _db;
+}
+function closeDatabase() {
+  if (_db) {
+    _db.save();
+    _db.close();
+    _db = null;
+  }
+}
+function ensureTable(db, ddl) {
+  db.exec(ddl);
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function parseISO(iso) {
+  return new Date(iso);
+}
+
+// src/createLocalStoreConfig.ts
+var import_langgraph_checkpoint_sqlite = require("@langchain/langgraph-checkpoint-sqlite");
+
+// src/stores/LocalThreadStore.ts
+var DDL = `
+CREATE TABLE IF NOT EXISTS lt_threads (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_threads_assistant ON lt_threads(tenant_id, assistant_id);
+`;
+var LocalThreadStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL);
+  }
+  async getThreadsByAssistantId(tenantId, assistantId, metadataFilter) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_threads WHERE tenant_id = ? AND assistant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId, assistantId);
+    let threads = rows.map(mapRowToThread);
+    if (metadataFilter && Object.keys(metadataFilter).length > 0) {
+      threads = threads.filter(
+        (t) => Object.entries(metadataFilter).every(
+          ([key, value]) => t.metadata?.[key] === value
+        )
+      );
+    }
+    return threads;
+  }
+  async getThreadById(tenantId, threadId) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_threads WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, threadId);
+    return row ? mapRowToThread(row) : void 0;
+  }
+  async createThread(tenantId, assistantId, threadId, data) {
+    const now = nowISO();
+    const metadata = JSON.stringify(data.metadata || {});
+    this.db.prepare(
+      `INSERT INTO lt_threads (id, tenant_id, assistant_id, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         assistant_id = excluded.assistant_id,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`
+    ).run(threadId, tenantId, assistantId, metadata, now, now);
+    return {
+      id: threadId,
+      tenantId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateThread(tenantId, threadId, updates) {
+    const existing = await this.getThreadById(tenantId, threadId);
+    if (!existing) return null;
+    const updatedMetadata = {
+      ...existing.metadata,
+      ...updates.metadata || {}
+    };
+    const now = nowISO();
+    this.db.prepare(
+      `UPDATE lt_threads SET metadata = ?, updated_at = ? WHERE tenant_id = ? AND id = ?`
+    ).run(JSON.stringify(updatedMetadata), now, tenantId, threadId);
+    return {
+      ...existing,
+      metadata: updatedMetadata,
+      updatedAt: parseISO(now)
+    };
+  }
+  async deleteThread(tenantId, threadId) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_threads WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, threadId);
+    return result.changes > 0;
+  }
+  async hasThread(tenantId, threadId) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_threads WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, threadId);
+    return row !== void 0;
+  }
+};
+function mapRowToThread(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalAssistantStore.ts
+var DDL2 = `
+CREATE TABLE IF NOT EXISTS lt_assistants (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  graph_definition TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+var LocalAssistantStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL2);
+  }
+  async getAllAssistants(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_assistants WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToAssistant);
+  }
+  async getAssistantById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_assistants WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToAssistant(row) : null;
+  }
+  async createAssistant(tenantId, id, data) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_assistants (id, tenant_id, name, description, graph_definition, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         graph_definition = excluded.graph_definition,
+         updated_at = excluded.updated_at`
+    ).run(id, tenantId, data.name, data.description || null, JSON.stringify(data.graphDefinition), now, now);
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      graphDefinition: data.graphDefinition,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateAssistant(tenantId, id, updates) {
+    const existing = await this.getAssistantById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.graphDefinition !== void 0) {
+      setClauses.push("graph_definition = ?");
+      values.push(JSON.stringify(updates.graphDefinition));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_assistants SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getAssistantById(tenantId, id);
+  }
+  async deleteAssistant(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_assistants WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+  async hasAssistant(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_assistants WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, id);
+    return row !== void 0;
+  }
+};
+function mapRowToAssistant(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    description: row.description || void 0,
+    graphDefinition: JSON.parse(row.graph_definition),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalWorkspaceStore.ts
+var DDL3 = `
+CREATE TABLE IF NOT EXISTS lt_workspaces (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  storage_type TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+var LocalWorkspaceStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL3);
+  }
+  async getAllWorkspaces(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workspaces WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToWorkspace);
+  }
+  async getWorkspaceById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_workspaces WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToWorkspace(row) : null;
+  }
+  async createWorkspace(tenantId, id, data) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_workspaces (id, tenant_id, name, description, storage_type, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         storage_type = excluded.storage_type,
+         updated_at = excluded.updated_at`
+    ).run(id, tenantId, data.name, data.description || null, data.storageType, now, now);
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      storageType: data.storageType,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateWorkspace(tenantId, id, updates) {
+    const existing = await this.getWorkspaceById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.storageType !== void 0) {
+      setClauses.push("storage_type = ?");
+      values.push(updates.storageType);
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_workspaces SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getWorkspaceById(tenantId, id);
+  }
+  async deleteWorkspace(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_workspaces WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+};
+function mapRowToWorkspace(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    description: row.description || void 0,
+    storageType: row.storage_type,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalProjectStore.ts
+var DDL4 = `
+CREATE TABLE IF NOT EXISTS lt_projects (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  workspace_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  config TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_projects_workspace ON lt_projects(tenant_id, workspace_id);
+`;
+var LocalProjectStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL4);
+  }
+  async getProjectsByWorkspace(tenantId, workspaceId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_projects WHERE tenant_id = ? AND workspace_id = ? ORDER BY created_at DESC`
+    ).all(tenantId, workspaceId);
+    return rows.map(mapRowToProject);
+  }
+  async getProjectById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_projects WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToProject(row) : null;
+  }
+  async createProject(tenantId, workspaceId, id, data) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_projects (id, tenant_id, workspace_id, name, description, config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         workspace_id = excluded.workspace_id,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         updated_at = excluded.updated_at`
+    ).run(id, tenantId, workspaceId, data.name, data.description || null, data.config ? JSON.stringify(data.config) : null, now, now);
+    return {
+      id,
+      tenantId,
+      workspaceId,
+      name: data.name,
+      description: data.description,
+      config: data.config,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateProject(tenantId, id, updates) {
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.config !== void 0) {
+      setClauses.push("config = ?");
+      values.push(updates.config ? JSON.stringify(updates.config) : null);
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_projects SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getProjectById(tenantId, id);
+  }
+  async deleteProject(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_projects WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+};
+function mapRowToProject(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id,
+    name: row.name,
+    description: row.description || void 0,
+    config: row.config ? JSON.parse(row.config) : void 0,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalUserStore.ts
+var DDL5 = `
+CREATE TABLE IF NOT EXISTS lt_users (
+  id TEXT PRIMARY KEY,
+  email TEXT NOT NULL,
+  name TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_users_email ON lt_users(email);
+`;
+var LocalUserStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL5);
+  }
+  async getAllUsers() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_users ORDER BY created_at DESC`
+    ).all();
+    return rows.map(mapRowToUser);
+  }
+  async getUserById(id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_users WHERE id = ?`
+    ).get(id);
+    return row ? mapRowToUser(row) : null;
+  }
+  async getUserByEmail(email) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_users WHERE email = ?`
+    ).get(email);
+    return row ? mapRowToUser(row) : null;
+  }
+  async createUser(id, data) {
+    const now = nowISO();
+    const status = data.status || "pending";
+    const metadata = JSON.stringify(data.metadata || {});
+    this.db.prepare(
+      `INSERT INTO lt_users (id, email, name, status, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         email = excluded.email,
+         name = excluded.name,
+         status = excluded.status,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`
+    ).run(id, data.email, data.name, status, metadata, now, now);
+    return {
+      id,
+      email: data.email,
+      name: data.name,
+      status,
+      metadata: data.metadata,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateUser(id, updates) {
+    const existing = await this.getUserById(id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.email !== void 0) {
+      setClauses.push("email = ?");
+      values.push(updates.email);
+    }
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+    this.db.prepare(
+      `UPDATE lt_users SET ${setClauses.join(", ")} WHERE id = ?`
+    ).run(...values);
+    return this.getUserById(id);
+  }
+  async deleteUser(id) {
+    const result = this.db.prepare(`DELETE FROM lt_users WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+};
+function mapRowToUser(row) {
+  return {
+    id: row.id,
+    email: row.email,
+    name: row.name,
+    status: row.status,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalTenantStore.ts
+var DDL6 = `
+CREATE TABLE IF NOT EXISTS lt_tenants (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  status TEXT NOT NULL DEFAULT 'active',
+  metadata TEXT DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
+var LocalTenantStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL6);
+  }
+  async getAllTenants() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_tenants ORDER BY created_at DESC`
+    ).all();
+    return rows.map(mapRowToTenant);
+  }
+  async getTenantById(id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_tenants WHERE id = ?`
+    ).get(id);
+    return row ? mapRowToTenant(row) : null;
+  }
+  async createTenant(id, data) {
+    const now = nowISO();
+    const status = data.status || "active";
+    const metadata = JSON.stringify(data.metadata || {});
+    this.db.prepare(
+      `INSERT INTO lt_tenants (id, name, description, status, metadata, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         description = excluded.description,
+         status = excluded.status,
+         metadata = excluded.metadata,
+         updated_at = excluded.updated_at`
+    ).run(id, data.name, data.description || null, status, metadata, now, now);
+    return {
+      id,
+      name: data.name,
+      description: data.description,
+      status,
+      metadata: data.metadata,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateTenant(id, updates) {
+    const existing = await this.getTenantById(id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+    this.db.prepare(
+      `UPDATE lt_tenants SET ${setClauses.join(", ")} WHERE id = ?`
+    ).run(...values);
+    return this.getTenantById(id);
+  }
+  async deleteTenant(id) {
+    const result = this.db.prepare(`DELETE FROM lt_tenants WHERE id = ?`).run(id);
+    return result.changes > 0;
+  }
+};
+function mapRowToTenant(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description || void 0,
+    status: row.status,
+    metadata: JSON.parse(row.metadata || "{}"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalUserTenantLinkStore.ts
+var DDL7 = `
+CREATE TABLE IF NOT EXISTS lt_user_tenant_links (
+  user_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'member',
+  joined_at TEXT NOT NULL,
+  metadata TEXT DEFAULT '{}',
+  PRIMARY KEY (user_id, tenant_id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_utl_user ON lt_user_tenant_links(user_id);
+CREATE INDEX IF NOT EXISTS idx_lt_utl_tenant ON lt_user_tenant_links(tenant_id);
+`;
+var LocalUserTenantLinkStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL7);
+  }
+  async getTenantsByUser(userId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE user_id = ? ORDER BY joined_at DESC`
+    ).all(userId);
+    return rows.map(mapRowToLink);
+  }
+  async getUsersByTenant(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE tenant_id = ? ORDER BY joined_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToLink);
+  }
+  async getLink(userId, tenantId) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ?`
+    ).get(userId, tenantId);
+    return row ? mapRowToLink(row) : null;
+  }
+  async createLink(data) {
+    const now = nowISO();
+    const role = data.role || "member";
+    const metadata = JSON.stringify(data.metadata || {});
+    this.db.prepare(
+      `INSERT INTO lt_user_tenant_links (user_id, tenant_id, role, joined_at, metadata)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(user_id, tenant_id) DO UPDATE SET
+         role = excluded.role,
+         metadata = excluded.metadata`
+    ).run(data.userId, data.tenantId, role, now, metadata);
+    return {
+      userId: data.userId,
+      tenantId: data.tenantId,
+      role,
+      joinedAt: parseISO(now),
+      metadata: data.metadata
+    };
+  }
+  async updateLink(userId, tenantId, updates) {
+    const existing = await this.getLink(userId, tenantId);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.role !== void 0) {
+      setClauses.push("role = ?");
+      values.push(updates.role);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata));
+    }
+    if (setClauses.length === 0) return existing;
+    values.push(userId, tenantId);
+    this.db.prepare(
+      `UPDATE lt_user_tenant_links SET ${setClauses.join(", ")} WHERE user_id = ? AND tenant_id = ?`
+    ).run(...values);
+    return this.getLink(userId, tenantId);
+  }
+  async deleteLink(userId, tenantId) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ?`
+    ).run(userId, tenantId);
+    return result.changes > 0;
+  }
+  async hasLink(userId, tenantId) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_user_tenant_links WHERE user_id = ? AND tenant_id = ? LIMIT 1`
+    ).get(userId, tenantId);
+    return row !== void 0;
+  }
+};
+function mapRowToLink(row) {
+  return {
+    userId: row.user_id,
+    tenantId: row.tenant_id,
+    role: row.role,
+    joinedAt: parseISO(row.joined_at),
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+
+// src/stores/LocalDatabaseConfigStore.ts
+var import_core = require("@axiom-lattice/core");
+var DDL8 = `
+CREATE TABLE IF NOT EXISTS lt_database_configs (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT,
+  description TEXT,
+  config TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_dbconfig_key ON lt_database_configs(tenant_id, key);
+`;
+var LocalDatabaseConfigStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL8);
+  }
+  async getAllConfigs(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map((r) => mapRowToEntry(r));
+  }
+  async getAllConfigsWithoutTenant() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_database_configs ORDER BY created_at DESC`
+    ).all();
+    return rows.map((r) => mapRowToEntry(r));
+  }
+  async getConfigById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToEntry(row) : null;
+  }
+  async getConfigByKey(tenantId, key) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_database_configs WHERE tenant_id = ? AND key = ?`
+    ).get(tenantId, key);
+    return row ? mapRowToEntry(row) : null;
+  }
+  async createConfig(tenantId, id, data) {
+    const now = nowISO();
+    const configWithEncrypted = encryptPasswordInConfig(data.config);
+    this.db.prepare(
+      `INSERT INTO lt_database_configs (id, tenant_id, key, name, description, config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         key = excluded.key,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         updated_at = excluded.updated_at`
+    ).run(id, tenantId, data.key, data.name || null, data.description || null, JSON.stringify(configWithEncrypted), now, now);
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateConfig(tenantId, id, updates) {
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.key !== void 0) {
+      setClauses.push("key = ?");
+      values.push(updates.key);
+    }
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name || null);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.config !== void 0) {
+      setClauses.push("config = ?");
+      values.push(JSON.stringify(encryptPasswordInConfig(updates.config)));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_database_configs SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getConfigById(tenantId, id);
+  }
+  async deleteConfig(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_database_configs WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+  async hasConfig(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_database_configs WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, id);
+    return row !== void 0;
+  }
+};
+function mapRowToEntry(row) {
+  const config = JSON.parse(row.config);
+  if (config.password) {
+    try {
+      config.password = (0, import_core.decrypt)(config.password);
+    } catch {
+    }
+  }
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config,
+    name: row.name || void 0,
+    description: row.description || void 0,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+function encryptPasswordInConfig(config) {
+  if (config.password) {
+    return { ...config, password: (0, import_core.encrypt)(config.password) };
+  }
+  return config;
+}
+
+// src/stores/LocalMetricsServerConfigStore.ts
+var DDL9 = `
+CREATE TABLE IF NOT EXISTS lt_metrics_configs (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT,
+  description TEXT,
+  config TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_metrics_key ON lt_metrics_configs(tenant_id, key);
+`;
+var LocalMetricsServerConfigStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL9);
+  }
+  async getAllConfigs(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToEntry2);
+  }
+  async getAllConfigsWithoutTenant() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs ORDER BY created_at DESC`
+    ).all();
+    return rows.map(mapRowToEntry2);
+  }
+  async getConfigById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToEntry2(row) : null;
+  }
+  async getConfigByKey(tenantId, key) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_metrics_configs WHERE tenant_id = ? AND key = ?`
+    ).get(tenantId, key);
+    return row ? mapRowToEntry2(row) : null;
+  }
+  async createConfig(tenantId, id, data) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_metrics_configs (id, tenant_id, key, name, description, config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         key = excluded.key,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         updated_at = excluded.updated_at`
+    ).run(id, tenantId, data.key, data.name || null, data.description || null, JSON.stringify(data.config), now, now);
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateConfig(tenantId, id, updates) {
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.key !== void 0) {
+      setClauses.push("key = ?");
+      values.push(updates.key);
+    }
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name || null);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.config !== void 0) {
+      setClauses.push("config = ?");
+      values.push(JSON.stringify(updates.config));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_metrics_configs SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getConfigById(tenantId, id);
+  }
+  async deleteConfig(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_metrics_configs WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+  async hasConfig(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_metrics_configs WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, id);
+    return row !== void 0;
+  }
+};
+function mapRowToEntry2(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config: JSON.parse(row.config),
+    name: row.name || void 0,
+    description: row.description || void 0,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalMcpServerConfigStore.ts
+var import_core2 = require("@axiom-lattice/core");
+var DDL10 = `
+CREATE TABLE IF NOT EXISTS lt_mcp_configs (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  name TEXT,
+  description TEXT,
+  config TEXT NOT NULL,
+  selected_tools TEXT DEFAULT '[]',
+  is_env_encrypted INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'disconnected',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_mcp_key ON lt_mcp_configs(tenant_id, key);
+`;
+var LocalMcpServerConfigStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL10);
+  }
+  async getAllConfigs(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToEntry3);
+  }
+  async getAllConfigsWithoutTenant() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs ORDER BY created_at DESC`
+    ).all();
+    return rows.map(mapRowToEntry3);
+  }
+  async getConfigById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToEntry3(row) : null;
+  }
+  async getConfigByKey(tenantId, key) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_mcp_configs WHERE tenant_id = ? AND key = ?`
+    ).get(tenantId, key);
+    return row ? mapRowToEntry3(row) : null;
+  }
+  async createConfig(tenantId, id, data) {
+    const now = nowISO();
+    const { config: configWithEncryptedEnv, isEnvEncrypted } = encryptEnvInConfig(data.config);
+    this.db.prepare(
+      `INSERT INTO lt_mcp_configs (id, tenant_id, key, name, description, config, selected_tools, is_env_encrypted, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         key = excluded.key,
+         name = excluded.name,
+         description = excluded.description,
+         config = excluded.config,
+         selected_tools = excluded.selected_tools,
+         is_env_encrypted = excluded.is_env_encrypted,
+         status = excluded.status,
+         updated_at = excluded.updated_at`
+    ).run(
+      id,
+      tenantId,
+      data.key,
+      data.name || null,
+      data.description || null,
+      JSON.stringify(configWithEncryptedEnv),
+      JSON.stringify(data.selectedTools || []),
+      isEnvEncrypted ? 1 : 0,
+      "disconnected",
+      now,
+      now
+    );
+    return {
+      id,
+      tenantId,
+      key: data.key,
+      config: data.config,
+      name: data.name,
+      description: data.description,
+      selectedTools: data.selectedTools || [],
+      isEnvEncrypted,
+      status: "disconnected",
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateConfig(tenantId, id, updates) {
+    const existing = await this.getConfigById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.key !== void 0) {
+      setClauses.push("key = ?");
+      values.push(updates.key);
+    }
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name || null);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description || null);
+    }
+    if (updates.config !== void 0) {
+      const { config: configWithEncryptedEnv, isEnvEncrypted } = encryptEnvInConfig(updates.config);
+      setClauses.push("config = ?");
+      values.push(JSON.stringify(configWithEncryptedEnv));
+      setClauses.push("is_env_encrypted = ?");
+      values.push(isEnvEncrypted ? 1 : 0);
+    }
+    if (updates.selectedTools !== void 0) {
+      setClauses.push("selected_tools = ?");
+      values.push(JSON.stringify(updates.selectedTools));
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_mcp_configs SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getConfigById(tenantId, id);
+  }
+  async deleteConfig(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_mcp_configs WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+  async hasConfig(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_mcp_configs WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, id);
+    return row !== void 0;
+  }
+};
+function mapRowToEntry3(row) {
+  const config = JSON.parse(row.config);
+  if (config.env && row.is_env_encrypted) {
+    try {
+      const decryptedEnv = {};
+      for (const [key, value] of Object.entries(config.env)) {
+        decryptedEnv[key] = (0, import_core2.decrypt)(value);
+      }
+      config.env = decryptedEnv;
+    } catch (error) {
+      console.error("Failed to decrypt MCP server env:", error);
+      throw new Error("Failed to decrypt MCP server configuration");
+    }
+  }
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.key,
+    config,
+    name: row.name || void 0,
+    description: row.description || void 0,
+    selectedTools: JSON.parse(row.selected_tools || "[]"),
+    isEnvEncrypted: row.is_env_encrypted === 1,
+    status: row.status,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+function encryptEnvInConfig(config) {
+  const configCopy = { ...config };
+  let isEnvEncrypted = false;
+  if (configCopy.env && Object.keys(configCopy.env).length > 0) {
+    const encryptedEnv = {};
+    for (const [key, value] of Object.entries(configCopy.env)) {
+      encryptedEnv[key] = (0, import_core2.encrypt)(value);
+    }
+    configCopy.env = encryptedEnv;
+    isEnvEncrypted = true;
+  }
+  return { config: configCopy, isEnvEncrypted };
+}
+
+// src/stores/LocalWorkflowTrackingStore.ts
+var DDL11 = `
+CREATE TABLE IF NOT EXISTS lt_workflow_runs (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  topology_edges TEXT NOT NULL DEFAULT '[]',
+  total_edges INTEGER NOT NULL DEFAULT 0,
+  completed_edges INTEGER NOT NULL DEFAULT 0,
+  error_message TEXT,
+  metadata TEXT DEFAULT '{}',
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_wr_thread ON lt_workflow_runs(tenant_id, thread_id);
+CREATE INDEX IF NOT EXISTS idx_lt_wr_assistant ON lt_workflow_runs(tenant_id, assistant_id);
+
+CREATE TABLE IF NOT EXISTS lt_workflow_steps (
+  id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  step_type TEXT NOT NULL,
+  step_name TEXT NOT NULL,
+  edge_from TEXT,
+  edge_to TEXT,
+  edge_purpose TEXT,
+  input TEXT,
+  output TEXT,
+  status TEXT NOT NULL DEFAULT 'running',
+  error_message TEXT,
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  duration_ms INTEGER,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (run_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ws_type ON lt_workflow_steps(run_id, step_type);
+`;
+var LocalWorkflowTrackingStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL11);
+  }
+  async createWorkflowRun(request) {
+    const now = nowISO();
+    const id = `${request.threadId}_${Date.now()}`;
+    this.db.prepare(
+      `INSERT INTO lt_workflow_runs (id, tenant_id, assistant_id, thread_id, status, topology_edges, total_edges, completed_edges, metadata, started_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, 'running', ?, ?, 0, ?, ?, ?, ?)`
+    ).run(
+      id,
+      request.tenantId,
+      request.assistantId,
+      request.threadId,
+      JSON.stringify(request.topologyEdges),
+      request.topologyEdges.length,
+      JSON.stringify(request.metadata || {}),
+      now,
+      now,
+      now
+    );
+    return {
+      id,
+      tenantId: request.tenantId,
+      assistantId: request.assistantId,
+      threadId: request.threadId,
+      status: "running",
+      topologyEdges: request.topologyEdges,
+      totalEdges: request.topologyEdges.length,
+      completedEdges: 0,
+      metadata: request.metadata,
+      startedAt: parseISO(now),
+      completedAt: void 0,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async getWorkflowRun(runId) {
+    const row = this.db.prepare(`SELECT * FROM lt_workflow_runs WHERE id = ?`).get(runId);
+    return row ? mapRowToRun(row) : null;
+  }
+  async updateWorkflowRun(runId, updates) {
+    const existing = await this.getWorkflowRun(runId);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.completedEdges !== void 0) {
+      setClauses.push("completed_edges = ?");
+      values.push(updates.completedEdges);
+    }
+    if (updates.errorMessage !== void 0) {
+      setClauses.push("error_message = ?");
+      values.push(updates.errorMessage);
+    }
+    if (updates.completedAt !== void 0) {
+      setClauses.push("completed_at = ?");
+      values.push(updates.completedAt ? updates.completedAt.toISOString() : null);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(runId);
+    this.db.prepare(
+      `UPDATE lt_workflow_runs SET ${setClauses.join(", ")} WHERE id = ?`
+    ).run(...values);
+    return this.getWorkflowRun(runId);
+  }
+  async deleteWorkflowRun(runId) {
+    this.db.prepare(`DELETE FROM lt_workflow_runs WHERE id = ?`).run(runId);
+  }
+  async getWorkflowRunsByThreadId(tenantId, threadId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? AND thread_id = ? ORDER BY created_at DESC`
+    ).all(tenantId, threadId);
+    return rows.map(mapRowToRun);
+  }
+  async getWorkflowRunsByAssistantId(tenantId, assistantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? AND assistant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId, assistantId);
+    return rows.map(mapRowToRun);
+  }
+  async getWorkflowRunsByTenantId(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToRun);
+  }
+  async createRunStep(request) {
+    const now = nowISO();
+    const id = `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.db.prepare(
+      `INSERT INTO lt_workflow_steps (id, run_id, tenant_id, step_type, step_name, edge_from, edge_to, edge_purpose, input, status, started_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', ?, ?, ?)`
+    ).run(
+      id,
+      request.runId,
+      request.tenantId,
+      request.stepType,
+      request.stepName,
+      request.edgeFrom || null,
+      request.edgeTo || null,
+      request.edgePurpose || null,
+      request.input ? JSON.stringify(request.input) : null,
+      now,
+      now,
+      now
+    );
+    return {
+      id,
+      runId: request.runId,
+      tenantId: request.tenantId,
+      stepType: request.stepType,
+      stepName: request.stepName,
+      edgeFrom: request.edgeFrom,
+      edgeTo: request.edgeTo,
+      edgePurpose: request.edgePurpose,
+      input: request.input,
+      status: "running",
+      startedAt: parseISO(now),
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateRunStep(runId, stepId, updates) {
+    const setClauses = [];
+    const values = [];
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.output !== void 0) {
+      setClauses.push("output = ?");
+      values.push(JSON.stringify(updates.output));
+    }
+    if (updates.errorMessage !== void 0) {
+      setClauses.push("error_message = ?");
+      values.push(updates.errorMessage);
+    }
+    if (updates.completedAt !== void 0) {
+      setClauses.push("completed_at = ?");
+      values.push(updates.completedAt ? updates.completedAt.toISOString() : null);
+    }
+    if (updates.durationMs !== void 0) {
+      setClauses.push("duration_ms = ?");
+      values.push(updates.durationMs);
+    }
+    if (setClauses.length === 0) {
+      return this.getStepById(runId, stepId);
+    }
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(runId, stepId);
+    this.db.prepare(
+      `UPDATE lt_workflow_steps SET ${setClauses.join(", ")} WHERE run_id = ? AND id = ?`
+    ).run(...values);
+    return this.getStepById(runId, stepId);
+  }
+  async getRunSteps(runId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? ORDER BY created_at ASC`
+    ).all(runId);
+    return rows.map(mapRowToStep);
+  }
+  async getRunStepsByType(runId, stepType) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND step_type = ? ORDER BY created_at ASC`
+    ).all(runId, stepType);
+    return rows.map(mapRowToStep);
+  }
+  async getInterruptedSteps(runId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND status = 'interrupted' ORDER BY created_at ASC`
+    ).all(runId);
+    return rows.map(mapRowToStep);
+  }
+  getStepById(runId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_workflow_steps WHERE run_id = ? AND id = ?`
+    ).get(runId, id);
+    return row ? mapRowToStep(row) : null;
+  }
+};
+function mapRowToRun(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    threadId: row.thread_id,
+    status: row.status,
+    topologyEdges: JSON.parse(row.topology_edges || "[]"),
+    totalEdges: row.total_edges,
+    completedEdges: row.completed_edges,
+    errorMessage: row.error_message || void 0,
+    metadata: JSON.parse(row.metadata || "{}"),
+    startedAt: parseISO(row.started_at),
+    completedAt: row.completed_at ? parseISO(row.completed_at) : void 0,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+function mapRowToStep(row) {
+  return {
+    id: row.id,
+    runId: row.run_id,
+    tenantId: row.tenant_id,
+    stepType: row.step_type,
+    stepName: row.step_name,
+    edgeFrom: row.edge_from || void 0,
+    edgeTo: row.edge_to || void 0,
+    edgePurpose: row.edge_purpose || void 0,
+    input: row.input ? JSON.parse(row.input) : void 0,
+    output: row.output ? JSON.parse(row.output) : void 0,
+    status: row.status,
+    errorMessage: row.error_message || void 0,
+    startedAt: parseISO(row.started_at),
+    completedAt: row.completed_at ? parseISO(row.completed_at) : void 0,
+    durationMs: row.duration_ms ?? void 0,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalEvalStore.ts
+var import_crypto = require("crypto");
+var DDL12 = `
+CREATE TABLE IF NOT EXISTS lt_eval_projects (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  version TEXT,
+  judge_model_config TEXT NOT NULL DEFAULT '{}',
+  target_server_config TEXT NOT NULL DEFAULT '{}',
+  concurrency INTEGER NOT NULL DEFAULT 3,
+  report_config TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+
+CREATE TABLE IF NOT EXISTS lt_eval_suites (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_es_project ON lt_eval_suites(tenant_id, project_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_cases (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  suite_id TEXT NOT NULL,
+  input_message TEXT NOT NULL,
+  input_files TEXT,
+  steps TEXT NOT NULL DEFAULT '[]',
+  output_type TEXT NOT NULL DEFAULT 'message_content',
+  content_assertion TEXT NOT NULL DEFAULT '',
+  rubrics TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ec_suite ON lt_eval_cases(tenant_id, suite_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_runs (
+  id TEXT NOT NULL,
+  project_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'running',
+  concurrency INTEGER NOT NULL DEFAULT 3,
+  total_cases INTEGER NOT NULL DEFAULT 0,
+  passed_cases INTEGER NOT NULL DEFAULT 0,
+  failed_cases INTEGER NOT NULL DEFAULT 0,
+  avg_score REAL NOT NULL DEFAULT 0,
+  error TEXT,
+  created_at TEXT NOT NULL,
+  started_at TEXT,
+  completed_at TEXT,
+  PRIMARY KEY (tenant_id, id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_er_project ON lt_eval_runs(tenant_id, project_id);
+
+CREATE TABLE IF NOT EXISTS lt_eval_run_results (
+  id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  suite_name TEXT NOT NULL,
+  case_id TEXT,
+  pass INTEGER NOT NULL DEFAULT 0,
+  score REAL NOT NULL DEFAULT 0,
+  summary TEXT,
+  dimension_results TEXT DEFAULT '[]',
+  duration_ms INTEGER,
+  messages TEXT DEFAULT '[]',
+  logs TEXT DEFAULT '[]',
+  error TEXT,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (run_id, id)
+);
+`;
+function parseJson(val, fallback) {
+  if (val == null) return fallback;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return fallback;
+    }
+  }
+  return val;
+}
+function parseOptionalJson(val) {
+  if (val == null) return void 0;
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return void 0;
+    }
+  }
+  return val;
+}
+var LocalEvalStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL12);
+  }
+  // -------------------------------------------------------------------------
+  // Projects
+  // -------------------------------------------------------------------------
+  async getProjectsByTenant(tenantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_eval_projects WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(this.mapRowToProject);
+  }
+  async getProjectById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? this.mapRowToProject(row) : null;
+  }
+  async createProject(tenantId, id, data) {
+    const actualId = id || (0, import_crypto.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO lt_eval_projects (id, tenant_id, name, description, version, judge_model_config, target_server_config, concurrency, report_config, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      actualId,
+      tenantId,
+      data.name,
+      data.description || null,
+      data.version || null,
+      JSON.stringify(data.judgeModelConfig),
+      JSON.stringify(data.targetServerConfig),
+      data.concurrency ?? 3,
+      data.reportConfig === void 0 ? null : JSON.stringify(data.reportConfig),
+      nowISO(),
+      nowISO()
+    );
+    return await this.getProjectById(tenantId, actualId);
+  }
+  async updateProject(tenantId, id, updates) {
+    const existing = await this.getProjectById(tenantId, id);
+    if (!existing) return null;
+    const set = [];
+    const vals = [];
+    if (updates.name !== void 0) {
+      set.push("name = ?");
+      vals.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      set.push("description = ?");
+      vals.push(updates.description || null);
+    }
+    if (updates.version !== void 0) {
+      set.push("version = ?");
+      vals.push(updates.version || null);
+    }
+    if (updates.judgeModelConfig !== void 0) {
+      set.push("judge_model_config = ?");
+      vals.push(JSON.stringify(updates.judgeModelConfig));
+    }
+    if (updates.targetServerConfig !== void 0) {
+      set.push("target_server_config = ?");
+      vals.push(JSON.stringify(updates.targetServerConfig));
+    }
+    if (updates.concurrency !== void 0) {
+      set.push("concurrency = ?");
+      vals.push(updates.concurrency);
+    }
+    if (updates.reportConfig !== void 0) {
+      set.push("report_config = ?");
+      vals.push(JSON.stringify(updates.reportConfig));
+    }
+    set.push("updated_at = ?");
+    vals.push(nowISO());
+    vals.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_eval_projects SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...vals);
+    return this.getProjectById(tenantId, id);
+  }
+  async deleteProject(tenantId, id) {
+    const result = this.db.prepare(`DELETE FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+  // -------------------------------------------------------------------------
+  // Suites
+  // -------------------------------------------------------------------------
+  async getSuitesByProject(tenantId, projectId) {
+    const rows = this.db.prepare(
+      `SELECT s.*, (SELECT COUNT(*) FROM lt_eval_cases c WHERE c.suite_id = s.id AND c.tenant_id = s.tenant_id) as case_count
+       FROM lt_eval_suites s WHERE s.tenant_id = ? AND s.project_id = ? ORDER BY s.created_at DESC`
+    ).all(tenantId, projectId);
+    return rows.map(this.mapRowToSuite);
+  }
+  async getSuiteById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT s.*, (SELECT COUNT(*) FROM lt_eval_cases c WHERE c.suite_id = s.id AND c.tenant_id = s.tenant_id) as case_count
+       FROM lt_eval_suites s WHERE s.tenant_id = ? AND s.id = ?`
+    ).get(tenantId, id);
+    return row ? this.mapRowToSuite(row) : null;
+  }
+  async createSuite(tenantId, projectId, id, data) {
+    const actualId = id || (0, import_crypto.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO lt_eval_suites (id, tenant_id, project_id, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)`
+    ).run(actualId, tenantId, projectId, data.name, nowISO(), nowISO());
+    return await this.getSuiteById(tenantId, actualId);
+  }
+  async updateSuite(tenantId, id, updates) {
+    const existing = await this.getSuiteById(tenantId, id);
+    if (!existing) return null;
+    const set = [];
+    const vals = [];
+    if (updates.name !== void 0) {
+      set.push("name = ?");
+      vals.push(updates.name);
+    }
+    set.push("updated_at = ?");
+    vals.push(nowISO());
+    vals.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_eval_suites SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...vals);
+    return this.getSuiteById(tenantId, id);
+  }
+  async deleteSuite(tenantId, id) {
+    const result = this.db.prepare(`DELETE FROM lt_eval_suites WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+  // -------------------------------------------------------------------------
+  // Cases
+  // -------------------------------------------------------------------------
+  async getCasesBySuite(tenantId, suiteId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_eval_cases WHERE tenant_id = ? AND suite_id = ? ORDER BY created_at DESC`
+    ).all(tenantId, suiteId);
+    return rows.map(this.mapRowToCase);
+  }
+  async getCaseById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_cases WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? this.mapRowToCase(row) : null;
+  }
+  async createCase(tenantId, suiteId, id, data) {
+    const actualId = id || (0, import_crypto.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO lt_eval_cases (id, tenant_id, suite_id, input_message, input_files, steps, output_type, content_assertion, rubrics, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      actualId,
+      tenantId,
+      suiteId,
+      data.inputMessage,
+      data.inputFiles ? JSON.stringify(data.inputFiles) : null,
+      JSON.stringify(data.steps),
+      data.outputType || "message_content",
+      data.contentAssertion || "",
+      data.rubrics ? JSON.stringify(data.rubrics) : null,
+      nowISO(),
+      nowISO()
+    );
+    return await this.getCaseById(tenantId, actualId);
+  }
+  async updateCase(tenantId, id, updates) {
+    const existing = await this.getCaseById(tenantId, id);
+    if (!existing) return null;
+    const set = [];
+    const vals = [];
+    if (updates.inputMessage !== void 0) {
+      set.push("input_message = ?");
+      vals.push(updates.inputMessage);
+    }
+    if (updates.inputFiles !== void 0) {
+      set.push("input_files = ?");
+      vals.push(JSON.stringify(updates.inputFiles));
+    }
+    if (updates.steps !== void 0) {
+      set.push("steps = ?");
+      vals.push(JSON.stringify(updates.steps));
+    }
+    if (updates.outputType !== void 0) {
+      set.push("output_type = ?");
+      vals.push(updates.outputType);
+    }
+    if (updates.contentAssertion !== void 0) {
+      set.push("content_assertion = ?");
+      vals.push(updates.contentAssertion);
+    }
+    if (updates.rubrics !== void 0) {
+      set.push("rubrics = ?");
+      vals.push(JSON.stringify(updates.rubrics));
+    }
+    set.push("updated_at = ?");
+    vals.push(nowISO());
+    vals.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_eval_cases SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...vals);
+    return this.getCaseById(tenantId, id);
+  }
+  async deleteCase(tenantId, id) {
+    const result = this.db.prepare(`DELETE FROM lt_eval_cases WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+  // -------------------------------------------------------------------------
+  // Runs
+  // -------------------------------------------------------------------------
+  async getRunsByTenant(tenantId, opts) {
+    let query = `SELECT * FROM lt_eval_runs WHERE tenant_id = ?`;
+    const vals = [tenantId];
+    if (opts?.projectId) {
+      query += ` AND project_id = ?`;
+      vals.push(opts.projectId);
+    }
+    if (opts?.status) {
+      query += ` AND status = ?`;
+      vals.push(opts.status);
+    }
+    query += ` ORDER BY created_at DESC`;
+    const rows = this.db.prepare(query).all(...vals);
+    return rows.map(this.mapRowToRun);
+  }
+  async getRunById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_eval_runs WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? this.mapRowToRun(row) : null;
+  }
+  async createRun(tenantId, projectId, id, data) {
+    const actualId = id || (0, import_crypto.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO lt_eval_runs (id, project_id, tenant_id, status, concurrency, total_cases, passed_cases, failed_cases, avg_score, created_at)
+       VALUES (?, ?, ?, 'running', ?, ?, 0, 0, 0, ?)`
+    ).run(actualId, projectId, tenantId, data.concurrency, data.totalCases, nowISO());
+    return await this.getRunById(tenantId, actualId);
+  }
+  async updateRunStatus(tenantId, id, updates) {
+    const existing = await this.getRunById(tenantId, id);
+    if (!existing) return null;
+    const set = [];
+    const vals = [];
+    if (updates.status !== void 0) {
+      set.push("status = ?");
+      vals.push(updates.status);
+    }
+    if (updates.passedCases !== void 0) {
+      set.push("passed_cases = ?");
+      vals.push(updates.passedCases);
+    }
+    if (updates.failedCases !== void 0) {
+      set.push("failed_cases = ?");
+      vals.push(updates.failedCases);
+    }
+    if (updates.avgScore !== void 0) {
+      set.push("avg_score = ?");
+      vals.push(updates.avgScore);
+    }
+    if (updates.error !== void 0) {
+      set.push("error = ?");
+      vals.push(updates.error || null);
+    }
+    if (updates.completedAt !== void 0) {
+      set.push("completed_at = ?");
+      vals.push(updates.completedAt ? updates.completedAt.toISOString() : null);
+    }
+    vals.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_eval_runs SET ${set.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...vals);
+    return this.getRunById(tenantId, id);
+  }
+  async deleteRun(tenantId, id) {
+    const result = this.db.prepare(`DELETE FROM lt_eval_runs WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
+    return result.changes > 0;
+  }
+  // -------------------------------------------------------------------------
+  // Run Results
+  // -------------------------------------------------------------------------
+  async getResultsByRun(tenantId, runId) {
+    const rows = this.db.prepare(
+      `SELECT rr.* FROM lt_eval_run_results rr
+       INNER JOIN lt_eval_runs r ON r.id = rr.run_id
+       WHERE r.tenant_id = ? AND rr.run_id = ? ORDER BY rr.created_at ASC`
+    ).all(tenantId, runId);
+    return rows.map(this.mapRowToRunResult);
+  }
+  async getRunResultById(tenantId, id) {
+    const row = this.db.prepare(
+      `SELECT rr.* FROM lt_eval_run_results rr
+       INNER JOIN lt_eval_runs r ON r.id = rr.run_id
+       WHERE r.tenant_id = ? AND rr.id = ?`
+    ).get(tenantId, id);
+    return row ? this.mapRowToRunResult(row) : null;
+  }
+  async createRunResult(tenantId, runId, id, data) {
+    const actualId = id || (0, import_crypto.randomUUID)();
+    this.db.prepare(
+      `INSERT INTO lt_eval_run_results (id, run_id, suite_name, case_id, pass, score, summary, dimension_results, duration_ms, messages, logs, error, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      actualId,
+      runId,
+      data.suiteName,
+      data.caseId || null,
+      data.pass ? 1 : 0,
+      data.score,
+      data.summary || null,
+      JSON.stringify(data.dimensionResults || []),
+      data.durationMs ?? null,
+      JSON.stringify(data.messages || []),
+      JSON.stringify(data.logs || []),
+      data.error || null,
+      nowISO()
+    );
+    return await this.getRunResultById(tenantId, actualId);
+  }
+  async updateRunResult(tenantId, id, updates) {
+    if (updates.runId !== void 0) throw new Error("runId cannot be updated on an existing result");
+    const set = [];
+    const vals = [];
+    if (updates.suiteName !== void 0) {
+      set.push("suite_name = ?");
+      vals.push(updates.suiteName);
+    }
+    if (updates.caseId !== void 0) {
+      set.push("case_id = ?");
+      vals.push(updates.caseId);
+    }
+    if (updates.pass !== void 0) {
+      set.push("pass = ?");
+      vals.push(updates.pass ? 1 : 0);
+    }
+    if (updates.score !== void 0) {
+      set.push("score = ?");
+      vals.push(updates.score);
+    }
+    if (updates.summary !== void 0) {
+      set.push("summary = ?");
+      vals.push(updates.summary || null);
+    }
+    if (updates.dimensionResults !== void 0) {
+      set.push("dimension_results = ?");
+      vals.push(JSON.stringify(updates.dimensionResults));
+    }
+    if (updates.durationMs !== void 0) {
+      set.push("duration_ms = ?");
+      vals.push(updates.durationMs ?? null);
+    }
+    if (updates.messages !== void 0) {
+      set.push("messages = ?");
+      vals.push(JSON.stringify(updates.messages));
+    }
+    if (updates.logs !== void 0) {
+      set.push("logs = ?");
+      vals.push(JSON.stringify(updates.logs));
+    }
+    if (updates.error !== void 0) {
+      set.push("error = ?");
+      vals.push(updates.error || null);
+    }
+    if (set.length === 0) return this.getRunResultById(tenantId, id);
+    vals.push(id, tenantId);
+    this.db.prepare(
+      `UPDATE lt_eval_run_results SET ${set.join(", ")}
+       WHERE id = ? AND run_id IN (SELECT id FROM lt_eval_runs WHERE tenant_id = ?)`
+    ).run(...vals);
+    return this.getRunResultById(tenantId, id);
+  }
+  // -------------------------------------------------------------------------
+  // Reports
+  // -------------------------------------------------------------------------
+  async getProjectReport(tenantId, projectId) {
+    const project = await this.getProjectById(tenantId, projectId);
+    if (!project) return null;
+    const runs = await this.getRunsByTenant(tenantId, { projectId });
+    const totalRuns = runs.length;
+    const latestPassRate = runs.length > 0 ? runs[0].totalCases > 0 ? runs[0].passedCases / runs[0].totalCases : 0 : 0;
+    const avgScore = runs.length > 0 ? runs.reduce((sum, r) => sum + r.avgScore, 0) / runs.length : 0;
+    return { projectId: project.id, projectName: project.name, totalRuns, latestPassRate, avgScore, runs };
+  }
+  // -------------------------------------------------------------------------
+  // Row mappers
+  // -------------------------------------------------------------------------
+  mapRowToProject(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      name: row.name,
+      description: row.description,
+      version: row.version,
+      judgeModelConfig: parseJson(row.judge_model_config, {}),
+      targetServerConfig: parseJson(row.target_server_config, {}),
+      concurrency: row.concurrency ?? 3,
+      reportConfig: parseOptionalJson(row.report_config),
+      createdAt: parseISO(row.created_at),
+      updatedAt: parseISO(row.updated_at)
+    };
+  }
+  mapRowToSuite(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      projectId: row.project_id,
+      name: row.name,
+      createdAt: parseISO(row.created_at),
+      updatedAt: parseISO(row.updated_at),
+      caseCount: row.case_count !== void 0 ? row.case_count : void 0
+    };
+  }
+  mapRowToCase(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      suiteId: row.suite_id,
+      inputMessage: row.input_message,
+      inputFiles: parseOptionalJson(row.input_files),
+      steps: parseJson(row.steps, []),
+      outputType: row.output_type || "message_content",
+      contentAssertion: row.content_assertion || "",
+      rubrics: parseOptionalJson(row.rubrics),
+      createdAt: parseISO(row.created_at),
+      updatedAt: parseISO(row.updated_at)
+    };
+  }
+  mapRowToRun(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      tenantId: row.tenant_id,
+      status: row.status,
+      concurrency: row.concurrency ?? 3,
+      totalCases: row.total_cases ?? 0,
+      passedCases: row.passed_cases ?? 0,
+      failedCases: row.failed_cases ?? 0,
+      avgScore: row.avg_score ?? 0,
+      error: row.error,
+      createdAt: parseISO(row.created_at),
+      startedAt: row.started_at ? parseISO(row.started_at) : void 0,
+      completedAt: row.completed_at ? parseISO(row.completed_at) : void 0
+    };
+  }
+  mapRowToRunResult(row) {
+    return {
+      id: row.id,
+      runId: row.run_id,
+      suiteName: row.suite_name,
+      caseId: row.case_id,
+      pass: row.pass === 1,
+      score: row.score ?? 0,
+      summary: row.summary,
+      dimensionResults: parseOptionalJson(row.dimension_results),
+      durationMs: row.duration_ms,
+      messages: parseOptionalJson(row.messages),
+      logs: parseOptionalJson(row.logs),
+      error: row.error,
+      createdAt: parseISO(row.created_at)
+    };
+  }
+};
+
+// src/stores/LocalChannelBindingStore.ts
+var import_crypto2 = require("crypto");
+var DDL13 = `
+CREATE TABLE IF NOT EXISTS lt_channel_bindings (
+  id TEXT PRIMARY KEY,
+  channel TEXT NOT NULL,
+  channel_installation_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  sender_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  thread_id TEXT,
+  workspace_id TEXT,
+  project_id TEXT,
+  thread_mode TEXT NOT NULL DEFAULT 'fixed',
+  sender_display_name TEXT,
+  sender_metadata TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_cb_resolve ON lt_channel_bindings(channel, sender_id, channel_installation_id, tenant_id);
+`;
+var LocalChannelBindingStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL13);
+  }
+  async resolve(params) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings
+       WHERE channel = ? AND sender_id = ? AND channel_installation_id = ? AND tenant_id = ? AND enabled = 1
+       LIMIT 1`
+    ).get(params.channel, params.senderId, params.channelInstallationId, params.tenantId);
+    return row ? mapRowToBinding(row) : null;
+  }
+  async create(input) {
+    const id = (0, import_crypto2.randomUUID)();
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_channel_bindings
+       (id, channel, channel_installation_id, tenant_id, sender_id, agent_id,
+        thread_mode, sender_display_name, sender_metadata, workspace_id, project_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      input.channel,
+      input.channelInstallationId,
+      input.tenantId,
+      input.senderId,
+      input.agentId,
+      input.threadMode || "fixed",
+      input.senderDisplayName || null,
+      input.senderMetadata ? JSON.stringify(input.senderMetadata) : null,
+      input.workspaceId || null,
+      input.projectId || null,
+      now,
+      now
+    );
+    return await this.getById(id);
+  }
+  async update(id, patch) {
+    const existing = await this.getById(id);
+    if (!existing) throw new Error(`Binding ${id} not found`);
+    const updated = {
+      channel: patch.channel ?? existing.channel,
+      channelInstallationId: patch.channelInstallationId ?? existing.channelInstallationId,
+      senderId: patch.senderId ?? existing.senderId,
+      agentId: patch.agentId ?? existing.agentId,
+      threadId: patch.threadId !== void 0 ? patch.threadId : existing.threadId,
+      workspaceId: patch.workspaceId !== void 0 ? patch.workspaceId : existing.workspaceId,
+      projectId: patch.projectId !== void 0 ? patch.projectId : existing.projectId,
+      threadMode: patch.threadMode ?? existing.threadMode,
+      senderDisplayName: patch.senderDisplayName !== void 0 ? patch.senderDisplayName : existing.senderDisplayName,
+      senderMetadata: patch.senderMetadata !== void 0 ? patch.senderMetadata : existing.senderMetadata,
+      enabled: patch.enabled ?? existing.enabled
+    };
+    const now = nowISO();
+    this.db.prepare(
+      `UPDATE lt_channel_bindings SET
+         channel = ?, channel_installation_id = ?, sender_id = ?, agent_id = ?,
+         thread_id = ?, workspace_id = ?, project_id = ?, thread_mode = ?,
+         sender_display_name = ?, sender_metadata = ?, enabled = ?, updated_at = ?
+       WHERE id = ?`
+    ).run(
+      updated.channel,
+      updated.channelInstallationId,
+      updated.senderId,
+      updated.agentId,
+      updated.threadId || null,
+      updated.workspaceId || null,
+      updated.projectId || null,
+      updated.threadMode,
+      updated.senderDisplayName || null,
+      updated.senderMetadata ? JSON.stringify(updated.senderMetadata) : null,
+      updated.enabled ? 1 : 0,
+      now,
+      id
+    );
+    return await this.getById(id);
+  }
+  async delete(id) {
+    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ?`).run(id);
+  }
+  async list(params) {
+    const conditions = ["tenant_id = ?"];
+    const values = [params.tenantId];
+    if (params.channel) {
+      conditions.push("channel = ?");
+      values.push(params.channel);
+    }
+    if (params.agentId) {
+      conditions.push("agent_id = ?");
+      values.push(params.agentId);
+    }
+    if (params.channelInstallationId) {
+      conditions.push("channel_installation_id = ?");
+      values.push(params.channelInstallationId);
+    }
+    const limit = params.limit ?? 50;
+    const offset = params.offset ?? 0;
+    values.push(limit, offset);
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY created_at DESC
+       LIMIT ? OFFSET ?`
+    ).all(...values);
+    return rows.map(mapRowToBinding);
+  }
+  async import(bindings) {
+    const result = [];
+    for (const input of bindings) {
+      result.push(await this.create(input));
+    }
+    return result;
+  }
+  async export(params) {
+    return this.list({ tenantId: params.tenantId, limit: 1e4, offset: 0 });
+  }
+  async getById(id) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_bindings WHERE id = ?`
+    ).get(id);
+    return row ? mapRowToBinding(row) : null;
+  }
+};
+function mapRowToBinding(row) {
+  return {
+    id: row.id,
+    channel: row.channel,
+    channelInstallationId: row.channel_installation_id,
+    tenantId: row.tenant_id,
+    senderId: row.sender_id,
+    agentId: row.agent_id,
+    threadId: row.thread_id || void 0,
+    workspaceId: row.workspace_id || void 0,
+    projectId: row.project_id || void 0,
+    threadMode: row.thread_mode,
+    senderDisplayName: row.sender_display_name || void 0,
+    senderMetadata: row.sender_metadata ? JSON.parse(row.sender_metadata) : void 0,
+    enabled: row.enabled === 1,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalChannelInstallationStore.ts
+var DDL14 = `
+CREATE TABLE IF NOT EXISTS lt_channel_installations (
+  id TEXT PRIMARY KEY,
+  tenant_id TEXT NOT NULL,
+  channel TEXT NOT NULL,
+  name TEXT,
+  config TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  fallback_agent_id TEXT,
+  reject_when_no_binding INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_ci_tenant ON lt_channel_installations(tenant_id);
+`;
+var LocalChannelInstallationStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL14);
+  }
+  async getInstallationById(installationId) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_channel_installations WHERE id = ?`
+    ).get(installationId);
+    return row ? mapRow(row) : null;
+  }
+  async getInstallationsByTenant(tenantId, channel) {
+    let rows;
+    if (channel) {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations WHERE tenant_id = ? AND channel = ? ORDER BY created_at DESC`
+      ).all(tenantId, channel);
+    } else {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_channel_installations WHERE tenant_id = ? ORDER BY created_at DESC`
+      ).all(tenantId);
+    }
+    return rows.map(mapRow);
+  }
+  async createInstallation(tenantId, installationId, data) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_channel_installations
+       (id, tenant_id, channel, name, config, enabled, fallback_agent_id, reject_when_no_binding, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         channel = excluded.channel,
+         name = excluded.name,
+         config = excluded.config,
+         enabled = excluded.enabled,
+         fallback_agent_id = excluded.fallback_agent_id,
+         reject_when_no_binding = excluded.reject_when_no_binding,
+         updated_at = excluded.updated_at`
+    ).run(
+      installationId,
+      tenantId,
+      data.channel,
+      data.name || null,
+      JSON.stringify(data.config),
+      data.enabled !== false ? 1 : 0,
+      data.fallbackAgentId || null,
+      data.rejectWhenNoBinding ? 1 : 0,
+      now,
+      now
+    );
+    return {
+      id: installationId,
+      tenantId,
+      channel: data.channel,
+      name: data.name,
+      config: data.config,
+      enabled: data.enabled !== false,
+      fallbackAgentId: data.fallbackAgentId,
+      rejectWhenNoBinding: data.rejectWhenNoBinding ?? false,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateInstallation(tenantId, installationId, updates) {
+    const existing = await this.getInstallationById(installationId);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name || null);
+    }
+    if (updates.config !== void 0) {
+      setClauses.push("config = ?");
+      values.push(JSON.stringify(updates.config));
+    }
+    if (updates.enabled !== void 0) {
+      setClauses.push("enabled = ?");
+      values.push(updates.enabled ? 1 : 0);
+    }
+    if (updates.fallbackAgentId !== void 0) {
+      setClauses.push("fallback_agent_id = ?");
+      values.push(updates.fallbackAgentId || null);
+    }
+    if (updates.rejectWhenNoBinding !== void 0) {
+      setClauses.push("reject_when_no_binding = ?");
+      values.push(updates.rejectWhenNoBinding ? 1 : 0);
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(installationId);
+    this.db.prepare(
+      `UPDATE lt_channel_installations SET ${setClauses.join(", ")} WHERE id = ?`
+    ).run(...values);
+    return this.getInstallationById(installationId);
+  }
+  async deleteInstallation(tenantId, installationId) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_channel_installations WHERE id = ? AND tenant_id = ?`
+    ).run(installationId, tenantId);
+    return result.changes > 0;
+  }
+};
+function mapRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    channel: row.channel,
+    name: row.name || void 0,
+    config: JSON.parse(row.config),
+    enabled: row.enabled === 1,
+    fallbackAgentId: row.fallback_agent_id || void 0,
+    rejectWhenNoBinding: row.reject_when_no_binding === 1,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalA2AApiKeyStore.ts
+var import_core3 = require("@axiom-lattice/core");
+var import_crypto3 = require("crypto");
+var DDL15 = `
+CREATE TABLE IF NOT EXISTS lt_a2a_api_keys (
+  id TEXT PRIMARY KEY,
+  key_value TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  project_id TEXT,
+  workspace_id TEXT,
+  label TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+`;
+function generateApiKey() {
+  return `a2a_${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`;
+}
+var LocalA2AApiKeyStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL15);
+  }
+  async findByKey(key) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_a2a_api_keys WHERE enabled = 1`
+    ).all();
+    for (const row of rows) {
+      try {
+        if ((0, import_core3.decrypt)(row.key_value) === key) return mapRowToRecord(row);
+      } catch {
+      }
+    }
+    return null;
+  }
+  async list(params) {
+    const limit = params.limit || 100;
+    const offset = params.offset || 0;
+    let rows;
+    if (params.tenantId) {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_a2a_api_keys WHERE tenant_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`
+      ).all(params.tenantId, limit, offset);
+    } else {
+      rows = this.db.prepare(
+        `SELECT * FROM lt_a2a_api_keys ORDER BY created_at DESC LIMIT ? OFFSET ?`
+      ).all(limit, offset);
+    }
+    return rows.map(mapRowToRecord);
+  }
+  async create(input) {
+    const key = generateApiKey();
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_a2a_api_keys (key_value, tenant_id, project_id, workspace_id, label, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run((0, import_core3.encrypt)(key), input.tenantId, input.projectId || null, input.workspaceId || null, input.label || null, now, now);
+    const lastId = this.db.prepare(`SELECT last_insert_rowid() as id`).get();
+    const record = {
+      id: String(lastId.id),
+      key,
+      tenantId: input.tenantId,
+      projectId: input.projectId,
+      workspaceId: input.workspaceId,
+      label: input.label,
+      enabled: true,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+    return record;
+  }
+  async disable(id) {
+    const now = nowISO();
+    this.db.prepare(
+      `UPDATE lt_a2a_api_keys SET enabled = 0, updated_at = ? WHERE id = ?`
+    ).run(now, id);
+    const row = this.db.prepare(`SELECT * FROM lt_a2a_api_keys WHERE id = ?`).get(id);
+    if (!row) throw new Error(`A2A API key not found: ${id}`);
+    return mapRowToRecord(row);
+  }
+  async enable(id) {
+    const now = nowISO();
+    this.db.prepare(
+      `UPDATE lt_a2a_api_keys SET enabled = 1, updated_at = ? WHERE id = ?`
+    ).run(now, id);
+    const row = this.db.prepare(`SELECT * FROM lt_a2a_api_keys WHERE id = ?`).get(id);
+    if (!row) throw new Error(`A2A API key not found: ${id}`);
+    return mapRowToRecord(row);
+  }
+  async rotate(id) {
+    const key = generateApiKey();
+    const now = nowISO();
+    this.db.prepare(
+      `UPDATE lt_a2a_api_keys SET key_value = ?, updated_at = ? WHERE id = ?`
+    ).run((0, import_core3.encrypt)(key), now, id);
+    const row = this.db.prepare(`SELECT * FROM lt_a2a_api_keys WHERE id = ?`).get(id);
+    if (!row) throw new Error(`A2A API key not found: ${id}`);
+    const record = mapRowToRecord(row);
+    record.key = key;
+    return record;
+  }
+  async delete(id) {
+    this.db.prepare(`DELETE FROM lt_a2a_api_keys WHERE id = ?`).run(id);
+  }
+  async loadIntoMap() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_a2a_api_keys WHERE enabled = 1`
+    ).all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      try {
+        const key = (0, import_core3.decrypt)(row.key_value);
+        map.set(key, {
+          key,
+          tenantId: row.tenant_id,
+          projectId: row.project_id || void 0,
+          workspaceId: row.workspace_id || void 0
+        });
+      } catch {
+      }
+    }
+    return map;
+  }
+};
+function mapRowToRecord(row) {
+  let key = "";
+  try {
+    key = (0, import_core3.decrypt)(row.key_value);
+  } catch {
+    key = row.key_value;
+  }
+  return {
+    id: row.id,
+    key,
+    tenantId: row.tenant_id,
+    projectId: row.project_id || void 0,
+    workspaceId: row.workspace_id || void 0,
+    label: row.label || void 0,
+    enabled: row.enabled === 1,
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalThreadMessageQueueStore.ts
+var import_crypto4 = require("crypto");
+var DDL16 = `
+CREATE TABLE IF NOT EXISTS lt_thread_message_queue (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL,
+  message_content TEXT NOT NULL,
+  message_type TEXT NOT NULL DEFAULT 'human',
+  sequence_order INTEGER NOT NULL DEFAULT 0,
+  priority INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'pending',
+  command TEXT,
+  custom_run_config TEXT,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_lt_tmq_thread ON lt_thread_message_queue(thread_id, status);
+CREATE INDEX IF NOT EXISTS idx_lt_tmq_pending ON lt_thread_message_queue(status, priority DESC, sequence_order ASC);
+`;
+var LocalThreadMessageQueueStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL16);
+  }
+  async addMessage(params) {
+    const now = nowISO();
+    const id = params.id || (0, import_crypto4.randomUUID)();
+    const seqRow = this.db.prepare(
+      `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq FROM lt_thread_message_queue WHERE thread_id = ?`
+    ).get(params.threadId);
+    const nextSeq = seqRow.next_seq;
+    this.db.prepare(
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      params.threadId,
+      params.tenantId,
+      params.assistantId,
+      JSON.stringify(params.content),
+      params.type || "human",
+      nextSeq,
+      params.priority || 0,
+      params.command ? JSON.stringify(params.command) : null,
+      params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      now
+    );
+    return this.getById(id);
+  }
+  async addMessageAtHead(params) {
+    const now = nowISO();
+    const id = params.id || (0, import_crypto4.randomUUID)();
+    const seqRow = this.db.prepare(
+      `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq FROM lt_thread_message_queue WHERE thread_id = ?`
+    ).get(params.threadId);
+    this.db.prepare(
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`
+    ).run(
+      id,
+      params.threadId,
+      params.tenantId,
+      params.assistantId,
+      JSON.stringify(params.content),
+      params.type || "human",
+      seqRow.next_seq,
+      params.command ? JSON.stringify(params.command) : null,
+      params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      now
+    );
+    return this.getById(id);
+  }
+  async getPendingMessages(threadId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending' ORDER BY priority DESC, sequence_order ASC`
+    ).all(threadId);
+    return rows.map(rowToMessage);
+  }
+  async getProcessingMessages(threadId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'processing' ORDER BY priority DESC, sequence_order ASC`
+    ).all(threadId);
+    return rows.map(rowToMessage);
+  }
+  async getQueueSize(threadId) {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as count FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'`
+    ).get(threadId);
+    return row.count;
+  }
+  async getThreadsWithPendingMessages() {
+    const rows = this.db.prepare(
+      `SELECT DISTINCT tenant_id, assistant_id, thread_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') ORDER BY thread_id`
+    ).all();
+    return rows.map((r) => ({
+      tenantId: r.tenant_id,
+      assistantId: r.assistant_id,
+      threadId: r.thread_id
+    }));
+  }
+  async removeMessage(messageId) {
+    const result = this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE id = ?`).run(messageId);
+    return result.changes > 0;
+  }
+  async clearMessages(threadId) {
+    this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE thread_id = ?`).run(threadId);
+  }
+  async markProcessing(messageId) {
+    this.db.prepare(`UPDATE lt_thread_message_queue SET status = 'processing' WHERE id = ?`).run(messageId);
+  }
+  async resetProcessingToPending(threadId) {
+    const result = this.db.prepare(
+      `UPDATE lt_thread_message_queue SET status = 'pending' WHERE thread_id = ? AND status = 'processing'`
+    ).run(threadId);
+    return result.changes;
+  }
+  getById(id) {
+    const row = this.db.prepare(`SELECT * FROM lt_thread_message_queue WHERE id = ?`).get(id);
+    return rowToMessage(row);
+  }
+};
+function rowToMessage(row) {
+  return {
+    id: row.id,
+    content: JSON.parse(row.message_content),
+    type: row.message_type,
+    sequence: row.sequence_order,
+    createdAt: parseISO(row.created_at),
+    priority: row.priority || 0,
+    command: row.command ? JSON.parse(row.command) : void 0,
+    custom_run_config: row.custom_run_config ? JSON.parse(row.custom_run_config) : void 0
+  };
+}
+
+// src/stores/LocalSkillStore.ts
+var DDL17 = `
+CREATE TABLE IF NOT EXISTS lt_skills (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  license TEXT,
+  compatibility TEXT,
+  metadata TEXT DEFAULT '{}',
+  content TEXT,
+  sub_skills TEXT DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+var LocalSkillStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL17);
+  }
+  async getAllSkills(tenantId, _context) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? ORDER BY created_at DESC`
+    ).all(tenantId);
+    return rows.map(mapRowToSkill);
+  }
+  async getSkillById(tenantId, id, _context) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND id = ?`
+    ).get(tenantId, id);
+    return row ? mapRowToSkill(row) : null;
+  }
+  async createSkill(tenantId, id, data, _context) {
+    const now = nowISO();
+    this.db.prepare(
+      `INSERT INTO lt_skills (id, tenant_id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(tenant_id, id) DO UPDATE SET
+         name = excluded.name, description = excluded.description,
+         license = excluded.license, compatibility = excluded.compatibility,
+         metadata = excluded.metadata, content = excluded.content,
+         sub_skills = excluded.sub_skills, updated_at = excluded.updated_at`
+    ).run(
+      id,
+      tenantId,
+      data.name,
+      data.description,
+      data.license || null,
+      data.compatibility || null,
+      JSON.stringify(data.metadata || {}),
+      data.content || null,
+      JSON.stringify(data.subSkills || []),
+      now,
+      now
+    );
+    return {
+      id,
+      tenantId,
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata || {},
+      content: data.content,
+      subSkills: data.subSkills,
+      createdAt: parseISO(now),
+      updatedAt: parseISO(now)
+    };
+  }
+  async updateSkill(tenantId, id, updates, _context) {
+    const existing = await this.getSkillById(tenantId, id);
+    if (!existing) return null;
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description);
+    }
+    if (updates.license !== void 0) {
+      setClauses.push("license = ?");
+      values.push(updates.license || null);
+    }
+    if (updates.compatibility !== void 0) {
+      setClauses.push("compatibility = ?");
+      values.push(updates.compatibility || null);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(JSON.stringify(updates.metadata || {}));
+    }
+    if (updates.content !== void 0) {
+      setClauses.push("content = ?");
+      values.push(updates.content || null);
+    }
+    if (updates.subSkills !== void 0) {
+      setClauses.push("sub_skills = ?");
+      values.push(JSON.stringify(updates.subSkills || []));
+    }
+    if (setClauses.length === 0) return existing;
+    const now = nowISO();
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(tenantId, id);
+    this.db.prepare(
+      `UPDATE lt_skills SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
+    ).run(...values);
+    return this.getSkillById(tenantId, id);
+  }
+  async deleteSkill(tenantId, id, _context) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_skills WHERE tenant_id = ? AND id = ?`
+    ).run(tenantId, id);
+    return result.changes > 0;
+  }
+  async hasSkill(tenantId, id, _context) {
+    const row = this.db.prepare(
+      `SELECT 1 FROM lt_skills WHERE tenant_id = ? AND id = ? LIMIT 1`
+    ).get(tenantId, id);
+    return row !== void 0;
+  }
+  async searchByMetadata(tenantId, metadataKey, metadataValue, _context) {
+    const all = await this.getAllSkills(tenantId);
+    return all.filter((s) => s.metadata?.[metadataKey] === metadataValue);
+  }
+  async filterByCompatibility(tenantId, compatibility, _context) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND compatibility = ? ORDER BY created_at DESC`
+    ).all(tenantId, compatibility);
+    return rows.map(mapRowToSkill);
+  }
+  async filterByLicense(tenantId, license, _context) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_skills WHERE tenant_id = ? AND license = ? ORDER BY created_at DESC`
+    ).all(tenantId, license);
+    return rows.map(mapRowToSkill);
+  }
+  async getSubSkills(tenantId, parentSkillName, _context) {
+    const all = await this.getAllSkills(tenantId);
+    return all.filter((s) => s.subSkills?.includes(parentSkillName));
+  }
+  async listSkillResources(_tenantId, _id, _context) {
+    return [];
+  }
+  async loadSkillResource(_tenantId, _id, _resourcePath, _context) {
+    return null;
+  }
+};
+function mapRowToSkill(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    name: row.name,
+    description: row.description,
+    license: row.license || void 0,
+    compatibility: row.compatibility || void 0,
+    metadata: JSON.parse(row.metadata || "{}"),
+    content: row.content || void 0,
+    subSkills: JSON.parse(row.sub_skills || "[]"),
+    createdAt: parseISO(row.created_at),
+    updatedAt: parseISO(row.updated_at)
+  };
+}
+
+// src/stores/LocalScheduleStorage.ts
+var DDL18 = `
+CREATE TABLE IF NOT EXISTS lt_scheduled_tasks (
+  task_id TEXT PRIMARY KEY,
+  task_type TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  payload TEXT NOT NULL DEFAULT '{}',
+  assistant_id TEXT,
+  thread_id TEXT,
+  execution_type TEXT NOT NULL,
+  execute_at TEXT,
+  delay_ms INTEGER,
+  cron_expression TEXT,
+  timezone TEXT,
+  next_run_at TEXT,
+  last_run_at TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  run_count INTEGER NOT NULL DEFAULT 0,
+  max_runs INTEGER,
+  retry_count INTEGER NOT NULL DEFAULT 0,
+  max_retries INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  expires_at TEXT,
+  metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_lt_st_status ON lt_scheduled_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_lt_st_type ON lt_scheduled_tasks(task_type);
+CREATE INDEX IF NOT EXISTS idx_lt_st_tenant ON lt_scheduled_tasks(tenant_id);
+`;
+var LocalScheduleStorage = class {
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL18);
+  }
+  async save(task) {
+    this.db.prepare(
+      `INSERT INTO lt_scheduled_tasks (
+         task_id, task_type, tenant_id, payload, assistant_id, thread_id, execution_type,
+         execute_at, delay_ms, cron_expression, timezone, next_run_at, last_run_at,
+         status, run_count, max_runs, retry_count, max_retries, last_error,
+         created_at, updated_at, expires_at, metadata
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(task_id) DO UPDATE SET
+         task_type = excluded.task_type, tenant_id = excluded.tenant_id,
+         payload = excluded.payload, assistant_id = excluded.assistant_id,
+         thread_id = excluded.thread_id, execution_type = excluded.execution_type,
+         execute_at = excluded.execute_at, delay_ms = excluded.delay_ms,
+         cron_expression = excluded.cron_expression, timezone = excluded.timezone,
+         next_run_at = excluded.next_run_at, last_run_at = excluded.last_run_at,
+         status = excluded.status, run_count = excluded.run_count,
+         max_runs = excluded.max_runs, retry_count = excluded.retry_count,
+         max_retries = excluded.max_retries, last_error = excluded.last_error,
+         updated_at = excluded.updated_at, expires_at = excluded.expires_at,
+         metadata = excluded.metadata`
+    ).run(
+      task.taskId,
+      task.taskType,
+      task.tenantId,
+      JSON.stringify(task.payload),
+      task.assistantId ?? null,
+      task.threadId ?? null,
+      task.executionType,
+      task.executeAt ? new Date(task.executeAt).toISOString() : null,
+      task.delayMs ?? null,
+      task.cronExpression ?? null,
+      task.timezone ?? null,
+      task.nextRunAt ? new Date(task.nextRunAt).toISOString() : null,
+      task.lastRunAt ? new Date(task.lastRunAt).toISOString() : null,
+      task.status,
+      task.runCount,
+      task.maxRuns ?? null,
+      task.retryCount,
+      task.maxRetries,
+      task.lastError ?? null,
+      new Date(task.createdAt).toISOString(),
+      new Date(task.updatedAt).toISOString(),
+      task.expiresAt ? new Date(task.expiresAt).toISOString() : null,
+      task.metadata ? JSON.stringify(task.metadata) : null
+    );
+  }
+  async get(taskId) {
+    const row = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE task_id = ?`
+    ).get(taskId);
+    return row ? mapRowToTask(row) : null;
+  }
+  async update(taskId, updates) {
+    const setClauses = [];
+    const values = [];
+    if (updates.taskType !== void 0) {
+      setClauses.push("task_type = ?");
+      values.push(updates.taskType);
+    }
+    if (updates.tenantId !== void 0) {
+      setClauses.push("tenant_id = ?");
+      values.push(updates.tenantId);
+    }
+    if (updates.payload !== void 0) {
+      setClauses.push("payload = ?");
+      values.push(JSON.stringify(updates.payload));
+    }
+    if (updates.assistantId !== void 0) {
+      setClauses.push("assistant_id = ?");
+      values.push(updates.assistantId ?? null);
+    }
+    if (updates.threadId !== void 0) {
+      setClauses.push("thread_id = ?");
+      values.push(updates.threadId ?? null);
+    }
+    if (updates.executionType !== void 0) {
+      setClauses.push("execution_type = ?");
+      values.push(updates.executionType);
+    }
+    if (updates.executeAt !== void 0) {
+      setClauses.push("execute_at = ?");
+      values.push(updates.executeAt ? new Date(updates.executeAt).toISOString() : null);
+    }
+    if (updates.delayMs !== void 0) {
+      setClauses.push("delay_ms = ?");
+      values.push(updates.delayMs ?? null);
+    }
+    if (updates.cronExpression !== void 0) {
+      setClauses.push("cron_expression = ?");
+      values.push(updates.cronExpression ?? null);
+    }
+    if (updates.timezone !== void 0) {
+      setClauses.push("timezone = ?");
+      values.push(updates.timezone ?? null);
+    }
+    if (updates.nextRunAt !== void 0) {
+      setClauses.push("next_run_at = ?");
+      values.push(updates.nextRunAt ? new Date(updates.nextRunAt).toISOString() : null);
+    }
+    if (updates.lastRunAt !== void 0) {
+      setClauses.push("last_run_at = ?");
+      values.push(updates.lastRunAt ? new Date(updates.lastRunAt).toISOString() : null);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.runCount !== void 0) {
+      setClauses.push("run_count = ?");
+      values.push(updates.runCount);
+    }
+    if (updates.maxRuns !== void 0) {
+      setClauses.push("max_runs = ?");
+      values.push(updates.maxRuns ?? null);
+    }
+    if (updates.retryCount !== void 0) {
+      setClauses.push("retry_count = ?");
+      values.push(updates.retryCount);
+    }
+    if (updates.maxRetries !== void 0) {
+      setClauses.push("max_retries = ?");
+      values.push(updates.maxRetries);
+    }
+    if (updates.lastError !== void 0) {
+      setClauses.push("last_error = ?");
+      values.push(updates.lastError ?? null);
+    }
+    if (updates.expiresAt !== void 0) {
+      setClauses.push("expires_at = ?");
+      values.push(updates.expiresAt ? new Date(updates.expiresAt).toISOString() : null);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push("metadata = ?");
+      values.push(updates.metadata ? JSON.stringify(updates.metadata) : null);
+    }
+    if (setClauses.length === 0) return;
+    setClauses.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(taskId);
+    this.db.prepare(
+      `UPDATE lt_scheduled_tasks SET ${setClauses.join(", ")} WHERE task_id = ?`
+    ).run(...values);
+  }
+  async delete(taskId) {
+    this.db.prepare(`DELETE FROM lt_scheduled_tasks WHERE task_id = ?`).run(taskId);
+  }
+  async getActiveTasks() {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE status IN ('pending', 'paused') ORDER BY created_at ASC`
+    ).all();
+    return rows.map(mapRowToTask);
+  }
+  async getTasksByType(taskType) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE task_type = ? ORDER BY created_at DESC`
+    ).all(taskType);
+    return rows.map(mapRowToTask);
+  }
+  async getTasksByStatus(status) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE status = ? ORDER BY created_at DESC`
+    ).all(status);
+    return rows.map(mapRowToTask);
+  }
+  async getTasksByExecutionType(executionType) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE execution_type = ? ORDER BY created_at DESC`
+    ).all(executionType);
+    return rows.map(mapRowToTask);
+  }
+  async getTasksByAssistantId(assistantId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE assistant_id = ? ORDER BY created_at DESC`
+    ).all(assistantId);
+    return rows.map(mapRowToTask);
+  }
+  async getTasksByThreadId(threadId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_scheduled_tasks WHERE thread_id = ? ORDER BY created_at DESC`
+    ).all(threadId);
+    return rows.map(mapRowToTask);
+  }
+  async getAllTasks(filters) {
+    const conditions = [];
+    const values = [];
+    if (filters?.tenantId !== void 0) {
+      conditions.push("tenant_id = ?");
+      values.push(filters.tenantId);
+    }
+    if (filters?.status !== void 0) {
+      conditions.push("status = ?");
+      values.push(filters.status);
+    }
+    if (filters?.executionType !== void 0) {
+      conditions.push("execution_type = ?");
+      values.push(filters.executionType);
+    }
+    if (filters?.taskType !== void 0) {
+      conditions.push("task_type = ?");
+      values.push(filters.taskType);
+    }
+    if (filters?.assistantId !== void 0) {
+      conditions.push("assistant_id = ?");
+      values.push(filters.assistantId);
+    }
+    if (filters?.threadId !== void 0) {
+      conditions.push("thread_id = ?");
+      values.push(filters.threadId);
+    }
+    let query = `SELECT * FROM lt_scheduled_tasks`;
+    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+    query += ` ORDER BY created_at DESC`;
+    if (filters?.limit !== void 0) {
+      query += ` LIMIT ?`;
+      values.push(filters.limit);
+    }
+    if (filters?.offset !== void 0) {
+      query += ` OFFSET ?`;
+      values.push(filters.offset);
+    }
+    const rows = this.db.prepare(query).all(...values);
+    return rows.map(mapRowToTask);
+  }
+  async countTasks(filters) {
+    const conditions = [];
+    const values = [];
+    if (filters?.tenantId !== void 0) {
+      conditions.push("tenant_id = ?");
+      values.push(filters.tenantId);
+    }
+    if (filters?.status !== void 0) {
+      conditions.push("status = ?");
+      values.push(filters.status);
+    }
+    if (filters?.executionType !== void 0) {
+      conditions.push("execution_type = ?");
+      values.push(filters.executionType);
+    }
+    if (filters?.taskType !== void 0) {
+      conditions.push("task_type = ?");
+      values.push(filters.taskType);
+    }
+    if (filters?.assistantId !== void 0) {
+      conditions.push("assistant_id = ?");
+      values.push(filters.assistantId);
+    }
+    if (filters?.threadId !== void 0) {
+      conditions.push("thread_id = ?");
+      values.push(filters.threadId);
+    }
+    let query = `SELECT COUNT(*) as count FROM lt_scheduled_tasks`;
+    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+    const row = this.db.prepare(query).get(...values);
+    return row.count;
+  }
+  async deleteOldTasks(olderThanMs) {
+    const cutoff = new Date(Date.now() - olderThanMs).toISOString();
+    const result = this.db.prepare(
+      `DELETE FROM lt_scheduled_tasks WHERE status IN ('completed', 'cancelled', 'failed') AND updated_at < ?`
+    ).run(cutoff);
+    return result.changes;
+  }
+};
+function mapRowToTask(row) {
+  return {
+    taskId: row.task_id,
+    taskType: row.task_type,
+    tenantId: row.tenant_id,
+    payload: JSON.parse(row.payload || "{}"),
+    assistantId: row.assistant_id ?? void 0,
+    threadId: row.thread_id ?? void 0,
+    executionType: row.execution_type,
+    executeAt: row.execute_at ? new Date(row.execute_at).getTime() : void 0,
+    delayMs: row.delay_ms ?? void 0,
+    cronExpression: row.cron_expression ?? void 0,
+    timezone: row.timezone ?? void 0,
+    nextRunAt: row.next_run_at ? new Date(row.next_run_at).getTime() : void 0,
+    lastRunAt: row.last_run_at ? new Date(row.last_run_at).getTime() : void 0,
+    status: row.status,
+    runCount: row.run_count,
+    maxRuns: row.max_runs ?? void 0,
+    retryCount: row.retry_count,
+    maxRetries: row.max_retries,
+    lastError: row.last_error ?? void 0,
+    createdAt: new Date(row.created_at).getTime(),
+    updatedAt: new Date(row.updated_at).getTime(),
+    expiresAt: row.expires_at ? new Date(row.expires_at).getTime() : void 0,
+    metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+  };
+}
+
+// src/createLocalStoreConfig.ts
+async function createLocalStoreConfig(options = {}) {
+  const dbPath = options.dbPath || "~/.axiom/lattice.db";
+  const db = await initDatabase({ dbPath });
+  return {
+    thread: new LocalThreadStore(db),
+    assistant: new LocalAssistantStore(db),
+    workspace: new LocalWorkspaceStore(db),
+    project: new LocalProjectStore(db),
+    user: new LocalUserStore(db),
+    tenant: new LocalTenantStore(db),
+    userTenantLink: new LocalUserTenantLinkStore(db),
+    database: new LocalDatabaseConfigStore(db),
+    metrics: new LocalMetricsServerConfigStore(db),
+    mcp: new LocalMcpServerConfigStore(db),
+    workflowTracking: new LocalWorkflowTrackingStore(db),
+    eval: new LocalEvalStore(db),
+    channelBinding: new LocalChannelBindingStore(db),
+    channelInstallation: new LocalChannelInstallationStore(db),
+    a2aApiKey: new LocalA2AApiKeyStore(db),
+    threadMessageQueue: new LocalThreadMessageQueueStore(db),
+    skill: new LocalSkillStore(db),
+    schedule: new LocalScheduleStorage(db),
+    checkpoint: import_langgraph_checkpoint_sqlite.SqliteSaver.fromConnString(dbPath)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseWrapper,
+  LocalA2AApiKeyStore,
+  LocalAssistantStore,
+  LocalChannelBindingStore,
+  LocalChannelInstallationStore,
+  LocalDatabaseConfigStore,
+  LocalEvalStore,
+  LocalMcpServerConfigStore,
+  LocalMetricsServerConfigStore,
+  LocalProjectStore,
+  LocalScheduleStorage,
+  LocalSkillStore,
+  LocalTenantStore,
+  LocalThreadMessageQueueStore,
+  LocalThreadStore,
+  LocalUserStore,
+  LocalUserTenantLinkStore,
+  LocalWorkflowTrackingStore,
+  LocalWorkspaceStore,
+  RunResult,
+  StatementWrapper,
+  closeDatabase,
+  createLocalStoreConfig,
+  ensureTable,
+  getDatabase,
+  initDatabase,
+  nowISO,
+  parseISO
+});
+//# sourceMappingURL=index.js.map