@axiom-lattice/local-stores 3.1.1 → 3.1.2

package/dist/index.mjs

@@ -81,11 +81,11 @@ var StatementWrapper = class {
       if (params.length > 0) {
         stmt.bind(params);
       }
-      const rows = [];
+      const rows2 = [];
       while (stmt.step()) {
-        rows.push(stmt.getAsObject());
+        rows2.push(stmt.getAsObject());
       }
-      return rows;
+      return rows2;
     } finally {
       stmt.free();
     }
@@ -160,8 +160,8 @@ function closeDatabase() {
     _db = null;
   }
 }
-function ensureTable(db, ddl) {
-  db.exec(ddl);
+function ensureTable(db, ddl2) {
+  db.exec(ddl2);
 }
 function nowISO() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -205,7 +205,10 @@ var MigrationManager = class {
       this.db.run(
         `INSERT INTO lattice_schema_migrations (store_name, name, version, applied_at)
          VALUES (?, ?, ?, ?)`,
-        [this.storeName, m.name, m.version, (/* @__PURE__ */ new Date()).toISOString()]
+        this.storeName,
+        m.name,
+        m.version,
+        (/* @__PURE__ */ new Date()).toISOString()
       );
     }
   }
@@ -255,10 +258,10 @@ var MigrationManager = class {
     `);
   }
   getAppliedNames() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT name FROM lattice_schema_migrations WHERE store_name = ? ORDER BY version`
     ).all(this.storeName);
-    return new Set(rows.map((r) => r.name));
+    return new Set(rows2.map((r) => r.name));
   }
 };
 
@@ -293,10 +296,10 @@ var LocalThreadStore = class {
     mm.migrate();
   }
   async getThreadsByAssistantId(tenantId, assistantId, metadataFilter) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    let threads = rows2.map(mapRowToThread);
     if (metadataFilter && Object.keys(metadataFilter).length > 0) {
       threads = threads.filter(
         (t) => Object.entries(metadataFilter).every(
@@ -393,10 +396,10 @@ var LocalAssistantStore = class {
     ensureTable(db, DDL2);
   }
   async getAllAssistants(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_assistants WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToAssistant);
+    return rows2.map(mapRowToAssistant);
   }
   async getAssistantById(tenantId, id) {
     const row = this.db.prepare(
@@ -509,10 +512,10 @@ var LocalWorkspaceStore = class {
     ensureTable(db, DDL3);
   }
   async getAllWorkspaces(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_workspaces WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToWorkspace);
+    return rows2.map(mapRowToWorkspace);
   }
   async getWorkspaceById(tenantId, id) {
     const row = this.db.prepare(
@@ -612,15 +615,15 @@ var LocalProjectStore = class {
   }
   async getProjectsByWorkspace(tenantId, workspaceId, filter) {
     if (filter?.kind !== void 0) {
-      const rows2 = this.db.prepare(
+      const rows3 = this.db.prepare(
         `SELECT * FROM lt_projects WHERE tenant_id = ? AND workspace_id = ? AND kind = ? ORDER BY created_at DESC`
       ).all(tenantId, workspaceId, filter.kind);
-      return rows2.map(mapRowToProject);
+      return rows3.map(mapRowToProject);
     }
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToProject);
   }
   async getProjectById(tenantId, id) {
     const row = this.db.prepare(
@@ -724,8 +727,8 @@ var LocalProjectStore = class {
     return await this.getProjectById(tenantId, projectId) ? { status: "bundle_not_found" } : { status: "project_not_found" };
   }
   async isCapabilityBundleReferenced(tenantId, bundleId) {
-    const rows = this.db.prepare("SELECT config FROM lt_projects WHERE tenant_id = ?").all(tenantId);
-    return rows.some((row) => {
+    const rows2 = this.db.prepare("SELECT config FROM lt_projects WHERE tenant_id = ?").all(tenantId);
+    return rows2.some((row) => {
       if (!row.config) return false;
       let config;
       try {
@@ -739,10 +742,10 @@ var LocalProjectStore = class {
     });
   }
   /** Add a column if it does not exist (SQLite version compatible). */
-  ensureColumn(table, column, ddl) {
+  ensureColumn(table, column, ddl2) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === column)) {
-      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl2}`);
     }
   }
 };
@@ -760,6 +763,640 @@ function mapRowToProject(row) {
   };
 }
 
+// src/stores/project-room-schema.ts
+var schemaMarker = Symbol("projectRoomSchema");
+var activeTransactions = /* @__PURE__ */ new WeakSet();
+var migrationName = "create_project_room_tables";
+var migrationTableDdl = `CREATE TABLE IF NOT EXISTS lattice_schema_migrations (
+  store_name TEXT NOT NULL, name TEXT NOT NULL, version INTEGER NOT NULL, applied_at TEXT NOT NULL,
+  PRIMARY KEY (store_name, name)
+)`;
+var ddl = `
+CREATE TABLE IF NOT EXISTS lt_project_rooms (
+  id TEXT NOT NULL, tenant_id TEXT NOT NULL, workspace_id TEXT NOT NULL, project_id TEXT NOT NULL,
+  type TEXT NOT NULL CHECK (type = 'main'), name TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id), UNIQUE (tenant_id, project_id, type)
+);
+CREATE TABLE IF NOT EXISTS lt_project_memberships (
+  id TEXT NOT NULL, tenant_id TEXT NOT NULL, project_id TEXT NOT NULL, user_id TEXT NOT NULL,
+  role TEXT NOT NULL CHECK (role IN ('owner','admin','member','viewer')),
+  status TEXT NOT NULL CHECK (status IN ('active','removed')), joined_at TEXT NOT NULL, updated_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id), UNIQUE (tenant_id, project_id, user_id)
+);
+CREATE INDEX IF NOT EXISTS idx_lt_project_memberships_project ON lt_project_memberships (tenant_id, project_id);
+CREATE TABLE IF NOT EXISTS lt_project_bot_memberships (
+  id TEXT NOT NULL, tenant_id TEXT NOT NULL, workspace_id TEXT NOT NULL, project_id TEXT NOT NULL,
+  room_id TEXT NOT NULL, assistant_id TEXT NOT NULL, role TEXT NOT NULL CHECK (role IN ('coordinator','specialist')),
+  title TEXT NOT NULL, responsibility TEXT, mention_name TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('active','paused','removed')), room_thread_id TEXT NOT NULL,
+  joined_at TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY (tenant_id, id),
+  UNIQUE (tenant_id, project_id, assistant_id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uq_lt_project_bot_memberships_coordinator
+  ON lt_project_bot_memberships (tenant_id, project_id) WHERE role = 'coordinator' AND status IN ('active','paused');
+CREATE UNIQUE INDEX IF NOT EXISTS uq_lt_project_bot_memberships_mention
+  ON lt_project_bot_memberships (tenant_id, room_id, mention_name) WHERE status IN ('active','paused');
+CREATE INDEX IF NOT EXISTS idx_lt_project_bot_memberships_project ON lt_project_bot_memberships (tenant_id, project_id);
+CREATE INDEX IF NOT EXISTS idx_lt_project_bot_memberships_room ON lt_project_bot_memberships (tenant_id, room_id);
+CREATE TABLE IF NOT EXISTS lt_project_room_messages (
+  id TEXT NOT NULL, tenant_id TEXT NOT NULL, workspace_id TEXT NOT NULL, project_id TEXT NOT NULL, room_id TEXT NOT NULL,
+  author TEXT NOT NULL, content TEXT NOT NULL, mentions TEXT NOT NULL DEFAULT '[]', reply_to_message_id TEXT,
+  source TEXT NOT NULL CHECK (source IN ('user','agent','task','routine','system')), source_id TEXT,
+  idempotency_key TEXT, created_at TEXT NOT NULL, PRIMARY KEY (tenant_id, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS uq_lt_project_room_messages_idempotency
+  ON lt_project_room_messages (tenant_id, room_id, idempotency_key) WHERE idempotency_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_lt_project_room_messages_room_created
+  ON lt_project_room_messages (tenant_id, room_id, created_at DESC, id DESC);
+`;
+var tableColumns = {
+  lt_project_rooms: ["id", "tenant_id", "workspace_id", "project_id", "type", "name", "created_at", "updated_at"],
+  lt_project_memberships: ["id", "tenant_id", "project_id", "user_id", "role", "status", "joined_at", "updated_at"],
+  lt_project_bot_memberships: ["id", "tenant_id", "workspace_id", "project_id", "room_id", "assistant_id", "role", "title", "responsibility", "mention_name", "status", "room_thread_id", "joined_at", "updated_at"],
+  lt_project_room_messages: ["id", "tenant_id", "workspace_id", "project_id", "room_id", "author", "content", "mentions", "reply_to_message_id", "source", "source_id", "idempotency_key", "created_at"]
+};
+var indexes = {
+  idx_lt_project_memberships_project: { table: "lt_project_memberships", columns: ["tenant_id", "project_id"], unique: false, partial: false },
+  uq_lt_project_bot_memberships_coordinator: { table: "lt_project_bot_memberships", columns: ["tenant_id", "project_id"], unique: true, partial: true, sql: ["role = 'coordinator'", "status in ('active','paused')"] },
+  uq_lt_project_bot_memberships_mention: { table: "lt_project_bot_memberships", columns: ["tenant_id", "room_id", "mention_name"], unique: true, partial: true, sql: ["status in ('active','paused')"] },
+  idx_lt_project_bot_memberships_project: { table: "lt_project_bot_memberships", columns: ["tenant_id", "project_id"], unique: false, partial: false },
+  idx_lt_project_bot_memberships_room: { table: "lt_project_bot_memberships", columns: ["tenant_id", "room_id"], unique: false, partial: false },
+  uq_lt_project_room_messages_idempotency: { table: "lt_project_room_messages", columns: ["tenant_id", "room_id", "idempotency_key"], unique: true, partial: true, sql: ["idempotency_key is not null"] },
+  idx_lt_project_room_messages_room_created: { table: "lt_project_room_messages", columns: ["tenant_id", "room_id", "created_at", "id"], unique: false, partial: false, sql: ["created_at desc", "id desc"] }
+};
+var uniqueConstraints = {
+  lt_project_rooms: [["tenant_id", "id"], ["tenant_id", "project_id", "type"]],
+  lt_project_memberships: [["tenant_id", "id"], ["tenant_id", "project_id", "user_id"]],
+  lt_project_bot_memberships: [["tenant_id", "id"], ["tenant_id", "project_id", "assistant_id"]],
+  lt_project_room_messages: [["tenant_id", "id"]]
+};
+var checkConstraints = {
+  lt_project_rooms: [{ name: "type", fragment: "type='main'" }],
+  lt_project_memberships: [
+    { name: "role", fragment: "role in ('owner','admin','member','viewer')" },
+    { name: "status", fragment: "status in ('active','removed')" }
+  ],
+  lt_project_bot_memberships: [
+    { name: "role", fragment: "role in ('coordinator','specialist')" },
+    { name: "status", fragment: "status in ('active','paused','removed')" }
+  ],
+  lt_project_room_messages: [{ name: "source", fragment: "source in ('user','agent','task','routine','system')" }]
+};
+function rows(db, sql) {
+  const result = db.getRawDb().exec(sql);
+  if (!result[0]) return [];
+  return result[0].values.map((values) => Object.fromEntries(result[0].columns.map((column, index) => [column, values[index]])));
+}
+function normalizeSql(value) {
+  return value.toLowerCase().replace(/["`]/g, "").replace(/\[|\]/g, "").replace(/\s+/g, " ").replace(/\s*([=,])\s*/g, "$1").replace(/[()]/g, "").trim();
+}
+function extractCheckExpressions(sql) {
+  const checks = [];
+  let quoted = false;
+  for (let index = 0; index < sql.length; index += 1) {
+    if (sql[index] === "'") {
+      if (quoted && sql[index + 1] === "'") {
+        index += 1;
+        continue;
+      }
+      quoted = !quoted;
+      continue;
+    }
+    if (quoted || sql.slice(index, index + 5).toLowerCase() !== "check") continue;
+    const before = sql[index - 1];
+    const after = sql[index + 5];
+    if (before && /[a-z0-9_]/i.test(before) || after && /[a-z0-9_]/i.test(after)) continue;
+    let opening = index + 5;
+    while (/\s/.test(sql[opening] ?? "")) opening += 1;
+    if (sql[opening] !== "(") continue;
+    let depth = 1;
+    let expressionQuoted = false;
+    for (let cursor = opening + 1; cursor < sql.length; cursor += 1) {
+      if (sql[cursor] === "'") {
+        if (expressionQuoted && sql[cursor + 1] === "'") {
+          cursor += 1;
+          continue;
+        }
+        expressionQuoted = !expressionQuoted;
+      } else if (!expressionQuoted && sql[cursor] === "(") {
+        depth += 1;
+      } else if (!expressionQuoted && sql[cursor] === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          checks.push(sql.slice(opening + 1, cursor));
+          index = cursor;
+          break;
+        }
+      }
+    }
+  }
+  return checks;
+}
+function validateProjectRoomSchema(db) {
+  for (const [table, expected] of Object.entries(tableColumns)) {
+    const actual = rows(db, `PRAGMA table_info(${table})`);
+    if (actual.map((column) => column.name).join(",") !== expected.join(",") || actual.some((column) => column.type !== "TEXT") || actual.some((column) => column.name !== "responsibility" && column.name !== "reply_to_message_id" && column.name !== "source_id" && column.name !== "idempotency_key" && column.notnull !== 1)) {
+      throw new Error(`Invalid project room schema: table '${table}' has incompatible columns`);
+    }
+    const uniqueIndexes = rows(db, `PRAGMA index_list(${table})`).filter((index) => index.unique === 1);
+    const signatures = uniqueIndexes.map((index) => rows(db, `PRAGMA index_info(${String(index.name)})`).map((column) => column.name).join(","));
+    if (uniqueConstraints[table].some((constraint) => !signatures.includes(constraint.join(",")))) {
+      throw new Error(`Invalid project room schema: table '${table}' is missing required uniqueness`);
+    }
+    const definition = rows(db, `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = '${table}'`)[0]?.sql;
+    const checks = typeof definition === "string" ? extractCheckExpressions(definition).map(normalizeSql) : [];
+    const missingCheck = checkConstraints[table].find((constraint) => !checks.includes(normalizeSql(constraint.fragment)));
+    if (missingCheck) {
+      throw new Error(`Invalid project room schema: table '${table}' is missing required CHECK constraint '${missingCheck.name}'`);
+    }
+  }
+  for (const [name, expected] of Object.entries(indexes)) {
+    const listed = rows(db, `PRAGMA index_list(${expected.table})`).find((index) => index.name === name);
+    const columns5 = rows(db, `PRAGMA index_info(${name})`).map((column) => column.name);
+    const definition = rows(db, `SELECT sql FROM sqlite_master WHERE type = 'index' AND name = '${name}'`)[0]?.sql;
+    const normalized = typeof definition === "string" ? definition.toLowerCase().replace(/\s+/g, " ") : "";
+    if (!listed || listed.unique !== Number(expected.unique) || listed.partial !== Number(expected.partial) || columns5.join(",") !== expected.columns.join(",") || expected.sql?.some((fragment) => !normalized.includes(fragment))) {
+      throw new Error(`Invalid project room schema: index '${name}' is incompatible`);
+    }
+  }
+}
+function ensureProjectRoomSchema(db) {
+  const marked = db;
+  if (marked[schemaMarker]) return;
+  const raw = db.getRawDb();
+  const hasMigrationTable = rows(db, "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lattice_schema_migrations'").length > 0;
+  const applied = hasMigrationTable ? rows(db, `SELECT name, version FROM lattice_schema_migrations WHERE store_name = 'project_room' AND name = '${migrationName}'`)[0] : void 0;
+  if (applied) {
+    if (applied.version !== 1) throw new Error(`Invalid project room schema migration version: ${String(applied.version)}`);
+    validateProjectRoomSchema(db);
+    marked[schemaMarker] = true;
+    return;
+  }
+  raw.exec("BEGIN IMMEDIATE");
+  try {
+    raw.exec(migrationTableDdl);
+    raw.exec(ddl);
+    validateProjectRoomSchema(db);
+    raw.run("INSERT INTO lattice_schema_migrations (store_name, name, version, applied_at) VALUES (?, ?, ?, ?)", ["project_room", migrationName, 1, (/* @__PURE__ */ new Date()).toISOString()]);
+    raw.exec("COMMIT");
+  } catch (error) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+  db.save();
+  marked[schemaMarker] = true;
+}
+function transaction(db, work) {
+  if (activeTransactions.has(db)) throw new Error("Nested local store transactions are not supported");
+  activeTransactions.add(db);
+  let began = false;
+  try {
+    db.exec("BEGIN IMMEDIATE");
+    began = true;
+    const result = work();
+    db.exec("COMMIT");
+    db.save();
+    return result;
+  } catch (error) {
+    if (began) {
+      try {
+        db.exec("ROLLBACK");
+      } catch {
+      }
+      db.save();
+    }
+    throw error;
+  } finally {
+    activeTransactions.delete(db);
+  }
+}
+function write(db, sql, params) {
+  const raw = db.getRawDb();
+  raw.run(sql, params);
+  return raw.getRowsModified();
+}
+function timestamp(previous) {
+  const previousTime = previous === void 0 ? Number.NaN : Date.parse(previous);
+  const now = Date.now();
+  return new Date(Math.max(now, Number.isFinite(previousTime) ? previousTime + 1 : now)).toISOString();
+}
+function validDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+function isUniqueError(error) {
+  return error instanceof Error && error.message.includes("UNIQUE constraint failed");
+}
+
+// src/stores/LocalProjectRoomStore.ts
+var columns = "id, tenant_id, workspace_id, project_id, type, name, created_at, updated_at";
+function mapRow(row) {
+  const createdAt = typeof row.created_at === "string" ? new Date(row.created_at) : void 0;
+  const updatedAt = typeof row.updated_at === "string" ? new Date(row.updated_at) : void 0;
+  if (typeof row.id !== "string" || typeof row.tenant_id !== "string" || typeof row.workspace_id !== "string" || typeof row.project_id !== "string" || row.type !== "main" || typeof row.name !== "string" || !validDate(createdAt) || !validDate(updatedAt)) throw new Error("Invalid project room row");
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id,
+    projectId: row.project_id,
+    type: "main",
+    name: row.name,
+    createdAt,
+    updatedAt
+  };
+}
+var LocalProjectRoomStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureProjectRoomSchema(db);
+  }
+  async ensureMainRoom(input) {
+    return transaction(this.db, () => {
+      const existing = this.getRow(input.tenantId, input.projectId);
+      if (existing) return mapRow(existing);
+      const now = timestamp();
+      write(this.db, "INSERT INTO lt_project_rooms (id, tenant_id, workspace_id, project_id, type, name, created_at, updated_at) VALUES (?, ?, ?, ?, 'main', ?, ?, ?)", [input.id, input.tenantId, input.workspaceId, input.projectId, input.name, now, now]);
+      return mapRow(this.getRow(input.tenantId, input.projectId));
+    });
+  }
+  async getMainRoom(tenantId, projectId) {
+    const row = this.getRow(tenantId, projectId);
+    return row ? mapRow(row) : null;
+  }
+  getRow(tenantId, projectId) {
+    return this.db.prepare(`SELECT ${columns} FROM lt_project_rooms WHERE tenant_id = ? AND project_id = ? AND type = 'main'`).get(tenantId, projectId);
+  }
+};
+
+// src/stores/LocalProjectMembershipStore.ts
+var columns2 = "id, tenant_id, project_id, user_id, role, status, joined_at, updated_at";
+var DuplicateProjectMembershipError = class extends Error {
+  constructor() {
+    super("Project membership already exists for tenant, project, and user");
+    this.name = "DuplicateProjectMembershipError";
+  }
+};
+var ProjectMembershipIdConflictError = class extends Error {
+  constructor() {
+    super("Project membership ID already exists for tenant");
+    this.name = "ProjectMembershipIdConflictError";
+  }
+};
+function role(value) {
+  return value === "owner" || value === "admin" || value === "member" || value === "viewer";
+}
+function mapRow2(row) {
+  const joinedAt = typeof row.joined_at === "string" ? new Date(row.joined_at) : void 0;
+  const updatedAt = typeof row.updated_at === "string" ? new Date(row.updated_at) : void 0;
+  if (typeof row.id !== "string" || typeof row.tenant_id !== "string" || typeof row.project_id !== "string" || typeof row.user_id !== "string" || !role(row.role) || row.status !== "active" && row.status !== "removed" || !validDate(joinedAt) || !validDate(updatedAt)) throw new Error("Invalid project membership row");
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    projectId: row.project_id,
+    userId: row.user_id,
+    role: row.role,
+    status: row.status,
+    joinedAt,
+    updatedAt
+  };
+}
+var LocalProjectMembershipStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureProjectRoomSchema(db);
+  }
+  async list(tenantId, projectId) {
+    return this.db.prepare(`SELECT ${columns2} FROM lt_project_memberships WHERE tenant_id = ? AND project_id = ? ORDER BY joined_at ASC, id ASC`).all(tenantId, projectId).map(mapRow2);
+  }
+  async findByUser(tenantId, projectId, userId) {
+    const row = this.db.prepare(`SELECT ${columns2} FROM lt_project_memberships WHERE tenant_id = ? AND project_id = ? AND user_id = ?`).get(tenantId, projectId, userId);
+    return row ? mapRow2(row) : null;
+  }
+  async create(input) {
+    return transaction(this.db, () => {
+      if (this.byId(input.tenantId, input.id)) throw new ProjectMembershipIdConflictError();
+      const now = timestamp();
+      try {
+        write(this.db, "INSERT INTO lt_project_memberships (id, tenant_id, project_id, user_id, role, status, joined_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [input.id, input.tenantId, input.projectId, input.userId, input.role, input.status, now, now]);
+      } catch (error) {
+        if (isUniqueError(error)) throw this.classifyUnique(input.tenantId, input.id, input.projectId, input.userId);
+        throw error;
+      }
+      return mapRow2(this.byId(input.tenantId, input.id));
+    });
+  }
+  async createInitialOwner(input) {
+    return transaction(this.db, () => {
+      const rows2 = this.db.prepare(`SELECT ${columns2} FROM lt_project_memberships WHERE tenant_id = ? AND project_id = ?`).all(input.tenantId, input.projectId);
+      if (rows2.length > 0) {
+        const existing = rows2.map(mapRow2).find((item) => item.userId === input.userId && item.role === "owner" && item.status === "active");
+        return existing ? { kind: "existing", membership: existing } : { kind: "already_initialized" };
+      }
+      if (this.byId(input.tenantId, input.id)) throw new ProjectMembershipIdConflictError();
+      const now = timestamp();
+      try {
+        write(this.db, "INSERT INTO lt_project_memberships (id, tenant_id, project_id, user_id, role, status, joined_at, updated_at) VALUES (?, ?, ?, ?, 'owner', 'active', ?, ?)", [input.id, input.tenantId, input.projectId, input.userId, now, now]);
+      } catch (error) {
+        if (isUniqueError(error)) throw this.classifyUnique(input.tenantId, input.id, input.projectId, input.userId);
+        throw error;
+      }
+      return { kind: "created", membership: mapRow2(this.byId(input.tenantId, input.id)) };
+    });
+  }
+  async updateRole(input) {
+    return this.mutate(input.tenantId, input.id, input.expectedUpdatedAt, input.role, false);
+  }
+  async remove(input) {
+    return this.mutate(input.tenantId, input.id, input.expectedUpdatedAt, void 0, true);
+  }
+  mutate(tenantId, id, expected, nextRole, remove) {
+    return transaction(this.db, () => {
+      const row = this.byId(tenantId, id);
+      if (!row) return { kind: "not_found" };
+      const current = mapRow2(row);
+      if (!validDate(expected) || current.updatedAt.getTime() !== expected.getTime()) return { kind: "conflict" };
+      if (current.role === "owner" && current.status === "active" && (remove || nextRole !== "owner")) {
+        const other = this.db.prepare("SELECT 1 FROM lt_project_memberships WHERE tenant_id = ? AND project_id = ? AND id <> ? AND role = 'owner' AND status = 'active'").get(tenantId, current.projectId, id);
+        if (!other) return { kind: "last_owner" };
+      }
+      const updatedAt = timestamp(row.updated_at);
+      const changes = remove ? write(this.db, "UPDATE lt_project_memberships SET status = 'removed', updated_at = ? WHERE tenant_id = ? AND id = ? AND updated_at = ?", [updatedAt, tenantId, id, row.updated_at]) : write(this.db, "UPDATE lt_project_memberships SET role = ?, updated_at = ? WHERE tenant_id = ? AND id = ? AND updated_at = ?", [nextRole, updatedAt, tenantId, id, row.updated_at]);
+      if (changes === 0) return { kind: "conflict" };
+      return { kind: remove ? "removed" : "updated", membership: mapRow2(this.byId(tenantId, id)) };
+    });
+  }
+  byId(tenantId, id) {
+    return this.db.prepare(`SELECT ${columns2} FROM lt_project_memberships WHERE tenant_id = ? AND id = ?`).get(tenantId, id);
+  }
+  classifyUnique(tenantId, id, projectId, userId) {
+    if (this.byId(tenantId, id)) return new ProjectMembershipIdConflictError();
+    if (this.db.prepare("SELECT 1 FROM lt_project_memberships WHERE tenant_id = ? AND project_id = ? AND user_id = ?").get(tenantId, projectId, userId)) return new DuplicateProjectMembershipError();
+    return new Error("Unclassified project membership uniqueness conflict");
+  }
+};
+
+// src/stores/LocalProjectBotMembershipStore.ts
+var columns3 = "id, tenant_id, workspace_id, project_id, room_id, assistant_id, role, title, responsibility, mention_name, status, room_thread_id, joined_at, updated_at";
+var ProjectBotMembershipIdConflictError = class extends Error {
+  constructor(tenantId, id) {
+    super(`Project bot membership ID '${id}' already exists in tenant '${tenantId}'`);
+    this.name = "ProjectBotMembershipIdConflictError";
+  }
+};
+function isRole(value) {
+  return value === "coordinator" || value === "specialist";
+}
+function isStatus(value) {
+  return value === "active" || value === "paused" || value === "removed";
+}
+function mapRow3(row) {
+  const joinedAt = typeof row.joined_at === "string" ? new Date(row.joined_at) : void 0;
+  const updatedAt = typeof row.updated_at === "string" ? new Date(row.updated_at) : void 0;
+  if (typeof row.id !== "string" || typeof row.tenant_id !== "string" || typeof row.workspace_id !== "string" || typeof row.project_id !== "string" || typeof row.room_id !== "string" || typeof row.assistant_id !== "string" || !isRole(row.role) || typeof row.title !== "string" || row.responsibility !== null && typeof row.responsibility !== "string" || typeof row.mention_name !== "string" || !isStatus(row.status) || typeof row.room_thread_id !== "string" || !validDate(joinedAt) || !validDate(updatedAt)) throw new Error("Invalid project bot membership row");
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id,
+    projectId: row.project_id,
+    roomId: row.room_id,
+    assistantId: row.assistant_id,
+    role: row.role,
+    title: row.title,
+    ...row.responsibility === null ? {} : { responsibility: row.responsibility },
+    mentionName: row.mention_name,
+    status: row.status,
+    roomThreadId: row.room_thread_id,
+    joinedAt,
+    updatedAt
+  };
+}
+var LocalProjectBotMembershipStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureProjectRoomSchema(db);
+  }
+  async list(tenantId, projectId) {
+    return this.db.prepare(`SELECT ${columns3} FROM lt_project_bot_memberships WHERE tenant_id = ? AND project_id = ? ORDER BY joined_at ASC, id ASC`).all(tenantId, projectId).map(mapRow3);
+  }
+  async findById(tenantId, id) {
+    const row = this.byId(tenantId, id);
+    return row ? mapRow3(row) : null;
+  }
+  async findByAssistant(tenantId, projectId, assistantId) {
+    const row = this.db.prepare(`SELECT ${columns3} FROM lt_project_bot_memberships WHERE tenant_id = ? AND project_id = ? AND assistant_id = ?`).get(tenantId, projectId, assistantId);
+    return row ? mapRow3(row) : null;
+  }
+  async save(input) {
+    try {
+      return transaction(this.db, () => {
+        const existing = this.db.prepare(`SELECT ${columns3} FROM lt_project_bot_memberships WHERE tenant_id = ? AND project_id = ? AND assistant_id = ?`).get(input.tenantId, input.projectId, input.assistantId);
+        if (existing) return this.reactivate(existing, input);
+        if (this.byId(input.tenantId, input.id)) throw new ProjectBotMembershipIdConflictError(input.tenantId, input.id);
+        const conflict = this.preflight(input.tenantId, input.projectId, input.roomId, input.role, input.mentionName, input.status, input.id);
+        if (conflict) return { kind: conflict };
+        const now = timestamp();
+        try {
+          write(this.db, "INSERT INTO lt_project_bot_memberships (id, tenant_id, workspace_id, project_id, room_id, assistant_id, role, title, responsibility, mention_name, status, room_thread_id, joined_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [input.id, input.tenantId, input.workspaceId, input.projectId, input.roomId, input.assistantId, input.role, input.title, input.responsibility ?? null, input.mentionName, input.status, input.roomThreadId, now, now]);
+        } catch (error) {
+          if (!isUniqueError(error)) throw error;
+          if (this.byId(input.tenantId, input.id)) throw new ProjectBotMembershipIdConflictError(input.tenantId, input.id);
+          const raced = this.byAssistant(input.tenantId, input.projectId, input.assistantId);
+          if (raced) return this.reactivate(raced, input);
+          const racedConflict = this.preflight(input.tenantId, input.projectId, input.roomId, input.role, input.mentionName, input.status, input.id);
+          if (racedConflict) return { kind: racedConflict };
+          throw new Error("Unclassified project bot membership uniqueness conflict");
+        }
+        return { kind: "created", membership: mapRow3(this.byId(input.tenantId, input.id)) };
+      });
+    } catch (error) {
+      const conflict = this.conflict(error);
+      if (conflict) return { kind: conflict };
+      throw error;
+    }
+  }
+  async update(input) {
+    try {
+      return transaction(this.db, () => {
+        const row = this.byId(input.tenantId, input.id);
+        if (!row) return { kind: "not_found" };
+        const existing = mapRow3(row);
+        if (!validDate(input.expectedUpdatedAt) || existing.updatedAt.getTime() !== input.expectedUpdatedAt.getTime()) return { kind: "conflict" };
+        const candidate = { ...existing, ...input.patch };
+        const conflict = this.preflight(candidate.tenantId, candidate.projectId, candidate.roomId, candidate.role, candidate.mentionName, candidate.status, candidate.id);
+        if (conflict) return { kind: conflict };
+        let changes;
+        try {
+          changes = write(this.db, "UPDATE lt_project_bot_memberships SET role = ?, title = ?, responsibility = ?, mention_name = ?, status = ?, updated_at = ? WHERE tenant_id = ? AND id = ? AND updated_at = ?", [candidate.role, candidate.title, candidate.responsibility ?? null, candidate.mentionName, candidate.status, timestamp(row.updated_at), input.tenantId, input.id, row.updated_at]);
+        } catch (error) {
+          if (!isUniqueError(error)) throw error;
+          const racedConflict = this.preflight(candidate.tenantId, candidate.projectId, candidate.roomId, candidate.role, candidate.mentionName, candidate.status, candidate.id);
+          if (racedConflict) return { kind: racedConflict };
+          throw new Error("Unclassified project bot membership uniqueness conflict");
+        }
+        if (changes === 0) return { kind: "conflict" };
+        return { kind: "updated", membership: mapRow3(this.byId(input.tenantId, input.id)) };
+      });
+    } catch (error) {
+      const conflict = this.conflict(error);
+      if (conflict) return { kind: conflict };
+      throw error;
+    }
+  }
+  byId(tenantId, id) {
+    return this.db.prepare(`SELECT ${columns3} FROM lt_project_bot_memberships WHERE tenant_id = ? AND id = ?`).get(tenantId, id);
+  }
+  byAssistant(tenantId, projectId, assistantId) {
+    return this.db.prepare(`SELECT ${columns3} FROM lt_project_bot_memberships WHERE tenant_id = ? AND project_id = ? AND assistant_id = ?`).get(tenantId, projectId, assistantId);
+  }
+  reactivate(existing, input) {
+    const persisted = mapRow3(existing);
+    const wasRemoved = persisted.status === "removed";
+    const conflict = this.preflight(input.tenantId, input.projectId, persisted.roomId, input.role, input.mentionName, "active", persisted.id);
+    if (conflict) return { kind: conflict };
+    try {
+      write(this.db, "UPDATE lt_project_bot_memberships SET role = ?, title = ?, responsibility = ?, mention_name = ?, status = 'active', updated_at = ? WHERE tenant_id = ? AND id = ?", [input.role, input.title, input.responsibility ?? null, input.mentionName, timestamp(existing.updated_at), input.tenantId, persisted.id]);
+    } catch (error) {
+      if (!isUniqueError(error)) throw error;
+      const racedConflict = this.preflight(input.tenantId, input.projectId, persisted.roomId, input.role, input.mentionName, "active", persisted.id);
+      if (racedConflict) return { kind: racedConflict };
+      throw new Error("Unclassified project bot membership uniqueness conflict");
+    }
+    return { kind: wasRemoved ? "reactivated" : "updated", membership: mapRow3(this.byId(input.tenantId, persisted.id)) };
+  }
+  preflight(tenantId, projectId, roomId, role2, mentionName, status, excludeId) {
+    if (status === "removed") return void 0;
+    if (role2 === "coordinator" && this.db.prepare("SELECT 1 FROM lt_project_bot_memberships WHERE tenant_id = ? AND project_id = ? AND id <> ? AND role = 'coordinator' AND status IN ('active', 'paused')").get(tenantId, projectId, excludeId)) return "coordinator_conflict";
+    if (this.db.prepare("SELECT 1 FROM lt_project_bot_memberships WHERE tenant_id = ? AND room_id = ? AND mention_name = ? AND id <> ? AND status IN ('active', 'paused')").get(tenantId, roomId, mentionName, excludeId)) return "mention_conflict";
+    return void 0;
+  }
+  conflict(error) {
+    if (!isUniqueError(error) || !(error instanceof Error)) return void 0;
+    if (error.message.includes("tenant_id, lt_project_bot_memberships.project_id")) return "coordinator_conflict";
+    if (error.message.includes("room_id") && error.message.includes("mention_name")) return "mention_conflict";
+    return void 0;
+  }
+};
+
+// src/stores/LocalProjectRoomMessageStore.ts
+var columns4 = "id, tenant_id, workspace_id, project_id, room_id, author, content, mentions, reply_to_message_id, source, source_id, idempotency_key, created_at";
+var ProjectRoomMessageIdConflictError = class extends Error {
+  constructor(tenantId, id) {
+    super(`Project room message ID '${id}' already exists in tenant '${tenantId}'`);
+    this.name = "ProjectRoomMessageIdConflictError";
+  }
+};
+var DuplicateProjectRoomMessageIdempotencyKeyError = class extends Error {
+  constructor(tenantId, roomId, key) {
+    super(`Project room message idempotency key '${key}' already exists in tenant '${tenantId}' room '${roomId}'`);
+    this.name = "DuplicateProjectRoomMessageIdempotencyKeyError";
+  }
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function only(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key));
+}
+function parseJson(value) {
+  if (typeof value !== "string") return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function author(value) {
+  if (!record(value)) return void 0;
+  if (value.type === "human" && only(value, ["type", "userId"]) && typeof value.userId === "string") return { type: "human", userId: value.userId };
+  if (value.type === "bot" && only(value, ["type", "membershipId", "assistantId"]) && typeof value.membershipId === "string" && typeof value.assistantId === "string") return { type: "bot", membershipId: value.membershipId, assistantId: value.assistantId };
+  if (value.type === "system" && only(value, ["type"])) return { type: "system" };
+  return void 0;
+}
+function mention(value) {
+  if (!record(value)) return void 0;
+  if (value.type === "bot" && only(value, ["type", "membershipId"]) && typeof value.membershipId === "string") return { type: "bot", membershipId: value.membershipId };
+  if (value.type === "team" && only(value, ["type"])) return { type: "team" };
+  return void 0;
+}
+function source(value) {
+  return value === "user" || value === "agent" || value === "task" || value === "routine" || value === "system";
+}
+function mapRow4(row) {
+  const mappedAuthor = author(parseJson(row.author));
+  const content = parseJson(row.content);
+  const rawMentions = parseJson(row.mentions);
+  const mappedMentions = Array.isArray(rawMentions) ? rawMentions.map(mention) : void 0;
+  const createdAt = typeof row.created_at === "string" ? new Date(row.created_at) : void 0;
+  if (typeof row.id !== "string" || typeof row.tenant_id !== "string" || typeof row.workspace_id !== "string" || typeof row.project_id !== "string" || typeof row.room_id !== "string" || !mappedAuthor || !record(content) || content.type !== "text" || typeof content.text !== "string" || !only(content, ["type", "text"]) || !mappedMentions || mappedMentions.some((item) => item === void 0) || row.reply_to_message_id !== null && typeof row.reply_to_message_id !== "string" || !source(row.source) || row.source_id !== null && typeof row.source_id !== "string" || row.idempotency_key !== null && typeof row.idempotency_key !== "string" || !validDate(createdAt)) throw new Error("Invalid project room message row");
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    workspaceId: row.workspace_id,
+    projectId: row.project_id,
+    roomId: row.room_id,
+    author: mappedAuthor,
+    content: { type: "text", text: content.text },
+    mentions: mappedMentions,
+    ...row.reply_to_message_id === null ? {} : { replyToMessageId: row.reply_to_message_id },
+    source: row.source,
+    ...row.source_id === null ? {} : { sourceId: row.source_id },
+    ...row.idempotency_key === null ? {} : { idempotencyKey: row.idempotency_key },
+    createdAt
+  };
+}
+var LocalProjectRoomMessageStore = class {
+  constructor(db) {
+    this.db = db;
+    ensureProjectRoomSchema(db);
+  }
+  async create(input) {
+    return this.insert(input, false);
+  }
+  async createIdempotent(input) {
+    return this.insert(input, true);
+  }
+  async list(input) {
+    if (input.before && !validDate(input.before.createdAt)) throw new RangeError("Project room message cursor date is invalid");
+    const limit = Math.min(100, Math.max(1, Math.trunc(Number.isFinite(input.limit) ? input.limit : 1)));
+    const rows2 = input.before ? this.db.prepare(`SELECT ${columns4} FROM lt_project_room_messages WHERE tenant_id = ? AND room_id = ? AND (created_at < ? OR (created_at = ? AND id < ?)) ORDER BY created_at DESC, id DESC LIMIT ?`).all(input.tenantId, input.roomId, input.before.createdAt.toISOString(), input.before.createdAt.toISOString(), input.before.id, limit) : this.db.prepare(`SELECT ${columns4} FROM lt_project_room_messages WHERE tenant_id = ? AND room_id = ? ORDER BY created_at DESC, id DESC LIMIT ?`).all(input.tenantId, input.roomId, limit);
+    return rows2.map(mapRow4);
+  }
+  async findById(tenantId, id) {
+    const row = this.byId(tenantId, id);
+    return row ? mapRow4(row) : null;
+  }
+  insert(input, idempotent) {
+    return transaction(this.db, () => {
+      if (idempotent && input.idempotencyKey) {
+        const canonical = this.byKey(input.tenantId, input.roomId, input.idempotencyKey);
+        if (canonical) return mapRow4(canonical);
+      }
+      if (this.byId(input.tenantId, input.id)) throw new ProjectRoomMessageIdConflictError(input.tenantId, input.id);
+      try {
+        write(this.db, "INSERT INTO lt_project_room_messages (id, tenant_id, workspace_id, project_id, room_id, author, content, mentions, reply_to_message_id, source, source_id, idempotency_key, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [input.id, input.tenantId, input.workspaceId, input.projectId, input.roomId, JSON.stringify(input.author), JSON.stringify(input.content), JSON.stringify(input.mentions), input.replyToMessageId ?? null, input.source, input.sourceId ?? null, input.idempotencyKey ?? null, timestamp()]);
+      } catch (error) {
+        if (!isUniqueError(error)) throw error;
+        if (this.byId(input.tenantId, input.id)) throw new ProjectRoomMessageIdConflictError(input.tenantId, input.id);
+        if (input.idempotencyKey) {
+          const canonical = this.byKey(input.tenantId, input.roomId, input.idempotencyKey);
+          if (canonical && idempotent) return mapRow4(canonical);
+          if (canonical) throw new DuplicateProjectRoomMessageIdempotencyKeyError(input.tenantId, input.roomId, input.idempotencyKey);
+        }
+        throw new Error("Unclassified project room message uniqueness conflict");
+      }
+      return mapRow4(this.byId(input.tenantId, input.id));
+    });
+  }
+  byId(tenantId, id) {
+    return this.db.prepare(`SELECT ${columns4} FROM lt_project_room_messages WHERE tenant_id = ? AND id = ?`).get(tenantId, id);
+  }
+  byKey(tenantId, roomId, key) {
+    return this.db.prepare(`SELECT ${columns4} FROM lt_project_room_messages WHERE tenant_id = ? AND room_id = ? AND idempotency_key = ?`).get(tenantId, roomId, key);
+  }
+};
+
 // src/stores/LocalUserStore.ts
 var DDL5 = `
 CREATE TABLE IF NOT EXISTS lt_users (
@@ -779,10 +1416,10 @@ var LocalUserStore = class {
     ensureTable(db, DDL5);
   }
   async getAllUsers() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_users ORDER BY created_at DESC`
     ).all();
-    return rows.map(mapRowToUser);
+    return rows2.map(mapRowToUser);
   }
   async getUserById(id) {
     const row = this.db.prepare(
@@ -886,10 +1523,10 @@ var LocalTenantStore = class {
     ensureTable(db, DDL6);
   }
   async getAllTenants() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_tenants ORDER BY created_at DESC`
     ).all();
-    return rows.map(mapRowToTenant);
+    return rows2.map(mapRowToTenant);
   }
   async getTenantById(id) {
     const row = this.db.prepare(
@@ -988,16 +1625,16 @@ var LocalUserTenantLinkStore = class {
     ensureTable(db, DDL7);
   }
   async getTenantsByUser(userId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_user_tenant_links WHERE user_id = ? ORDER BY joined_at DESC`
     ).all(userId);
-    return rows.map(mapRowToLink);
+    return rows2.map(mapRowToLink);
   }
   async getUsersByTenant(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_user_tenant_links WHERE tenant_id = ? ORDER BY joined_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToLink);
+    return rows2.map(mapRowToLink);
   }
   async getLink(userId, tenantId) {
     const row = this.db.prepare(
@@ -1007,7 +1644,7 @@ var LocalUserTenantLinkStore = class {
   }
   async createLink(data) {
     const now = nowISO();
-    const role = data.role || "member";
+    const role2 = 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)
@@ -1015,11 +1652,11 @@ var LocalUserTenantLinkStore = class {
        ON CONFLICT(user_id, tenant_id) DO UPDATE SET
          role = excluded.role,
          metadata = excluded.metadata`
-    ).run(data.userId, data.tenantId, role, now, metadata);
+    ).run(data.userId, data.tenantId, role2, now, metadata);
     return {
       userId: data.userId,
       tenantId: data.tenantId,
-      role,
+      role: role2,
       joinedAt: parseISO(now),
       metadata: data.metadata
     };
@@ -1089,16 +1726,16 @@ var LocalDatabaseConfigStore = class {
     ensureTable(db, DDL8);
   }
   async getAllConfigs(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_database_configs WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map((r) => mapRowToEntry(r));
+    return rows2.map((r) => mapRowToEntry(r));
   }
   async getAllConfigsWithoutTenant() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_database_configs ORDER BY created_at DESC`
     ).all();
-    return rows.map((r) => mapRowToEntry(r));
+    return rows2.map((r) => mapRowToEntry(r));
   }
   async getConfigById(tenantId, id) {
     const row = this.db.prepare(
@@ -1230,16 +1867,16 @@ var LocalConnectionStore = class {
     ensureTable(db, DDL9);
   }
   async listByTenant(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM connection_configs WHERE tenant_id = ? ORDER BY created_at`
     ).all(tenantId);
-    return rows.map((r) => this.mapRow(r));
+    return rows2.map((r) => this.mapRow(r));
   }
   async listByType(tenantId, type) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM connection_configs WHERE tenant_id = ? AND type = ? ORDER BY created_at`
     ).all(tenantId, type);
-    return rows.map((r) => this.mapRow(r));
+    return rows2.map((r) => this.mapRow(r));
   }
   async getByKey(tenantId, type, key) {
     const row = this.db.prepare(
@@ -1325,16 +1962,16 @@ var LocalMetricsServerConfigStore = class {
     ensureTable(db, DDL10);
   }
   async getAllConfigs(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_metrics_configs WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToEntry2);
+    return rows2.map(mapRowToEntry2);
   }
   async getAllConfigsWithoutTenant() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_metrics_configs ORDER BY created_at DESC`
     ).all();
-    return rows.map(mapRowToEntry2);
+    return rows2.map(mapRowToEntry2);
   }
   async getConfigById(tenantId, id) {
     const row = this.db.prepare(
@@ -1453,16 +2090,16 @@ var LocalMcpServerConfigStore = class {
     ensureTable(db, DDL11);
   }
   async getAllConfigs(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_mcp_configs WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToEntry3);
+    return rows2.map(mapRowToEntry3);
   }
   async getAllConfigsWithoutTenant() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_mcp_configs ORDER BY created_at DESC`
     ).all();
-    return rows.map(mapRowToEntry3);
+    return rows2.map(mapRowToEntry3);
   }
   async getConfigById(tenantId, id) {
     const row = this.db.prepare(
@@ -1744,22 +2381,22 @@ var LocalWorkflowTrackingStore = class {
     this.db.prepare(`DELETE FROM lt_workflow_runs WHERE id = ?`).run(runId);
   }
   async getWorkflowRunsByThreadId(tenantId, threadId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToRun);
   }
   async getWorkflowRunsByAssistantId(tenantId, assistantId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToRun);
   }
   async getWorkflowRunsByTenantId(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_workflow_runs WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToRun);
+    return rows2.map(mapRowToRun);
   }
   async queryWorkflowRuns(tenantId, options = {}) {
     const conditions = ["tenant_id = ?"];
@@ -1788,8 +2425,8 @@ var LocalWorkflowTrackingStore = class {
       sql += " OFFSET ?";
       selectParams.push(options.offset);
     }
-    const rows = this.db.prepare(sql).all(...selectParams);
-    return { records: rows.map(mapRowToRun), total: countRow.count };
+    const rows2 = this.db.prepare(sql).all(...selectParams);
+    return { records: rows2.map(mapRowToRun), total: countRow.count };
   }
   async createRunStep(request) {
     const now = nowISO();
@@ -1881,22 +2518,22 @@ var LocalWorkflowTrackingStore = class {
     return this.getStepById(runId, stepId);
   }
   async getRunSteps(runId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_workflow_steps WHERE run_id = ? ORDER BY created_at ASC`
     ).all(runId);
-    return rows.map(mapRowToStep);
+    return rows2.map(mapRowToStep);
   }
   async getRunStepsByType(runId, stepType) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToStep);
   }
   async getInterruptedSteps(runId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToStep);
   }
   getStepById(runId, id) {
     const row = this.db.prepare(
@@ -2041,7 +2678,7 @@ CREATE TABLE IF NOT EXISTS lt_eval_run_results (
   PRIMARY KEY (run_id, id)
 );
 `;
-function parseJson(val, fallback) {
+function parseJson2(val, fallback) {
   if (val == null) return fallback;
   if (typeof val === "string") {
     try {
@@ -2133,20 +2770,20 @@ var LocalEvalStore = class {
     `);
   }
   /** Add a column if it does not exist (SQLite version compatible). */
-  ensureColumn(table, column, ddl) {
+  ensureColumn(table, column, ddl2) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === column)) {
-      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl2}`);
     }
   }
   // -------------------------------------------------------------------------
   // Projects
   // -------------------------------------------------------------------------
   async getProjectsByTenant(tenantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_eval_projects WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(this.mapRowToProject);
+    return rows2.map(this.mapRowToProject);
   }
   async getProjectById(tenantId, id) {
     const row = this.db.prepare(
@@ -2249,11 +2886,11 @@ var LocalEvalStore = class {
   // Suites
   // -------------------------------------------------------------------------
   async getSuitesByProject(tenantId, projectId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(this.mapRowToSuite);
   }
   async getSuiteById(tenantId, id) {
     const row = this.db.prepare(
@@ -2294,10 +2931,10 @@ var LocalEvalStore = class {
   // Cases
   // -------------------------------------------------------------------------
   async getCasesBySuite(tenantId, suiteId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(this.mapRowToCase);
   }
   async getCaseById(tenantId, id) {
     const row = this.db.prepare(
@@ -2386,8 +3023,8 @@ var LocalEvalStore = class {
       vals.push(opts.status);
     }
     query += ` ORDER BY created_at DESC`;
-    const rows = this.db.prepare(query).all(...vals);
-    return rows.map(this.mapRowToRun);
+    const rows2 = this.db.prepare(query).all(...vals);
+    return rows2.map(this.mapRowToRun);
   }
   async getRunById(tenantId, id) {
     const row = this.db.prepare(
@@ -2450,12 +3087,12 @@ var LocalEvalStore = class {
   // Run Results
   // -------------------------------------------------------------------------
   async getResultsByRun(tenantId, runId) {
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(this.mapRowToRunResult);
   }
   async getRunResultById(tenantId, id) {
     const row = this.db.prepare(
@@ -2573,8 +3210,8 @@ var LocalEvalStore = class {
       name: row.name,
       description: row.description,
       version: row.version,
-      judgeModelConfig: parseJson(row.judge_model_config, {}),
-      targetServerConfig: parseJson(row.target_server_config, {}),
+      judgeModelConfig: parseJson2(row.judge_model_config, {}),
+      targetServerConfig: parseJson2(row.target_server_config, {}),
       concurrency: row.concurrency ?? 3,
       reportConfig: parseOptionalJson(row.report_config),
       createdAt: parseISO(row.created_at),
@@ -2599,7 +3236,7 @@ var LocalEvalStore = class {
       suiteId: row.suite_id,
       inputMessage: row.input_message,
       inputFiles: parseOptionalJson(row.input_files),
-      steps: parseJson(row.steps, []),
+      steps: parseJson2(row.steps, []),
       outputType: row.output_type || "message_content",
       contentAssertion: row.content_assertion || "",
       rubrics: parseOptionalJson(row.rubrics),
@@ -2651,7 +3288,54 @@ var LocalEvalStore = class {
 };
 
 // src/stores/LocalChannelBindingStore.ts
+import {
+  DuplicateChannelBindingSubjectError
+} from "@axiom-lattice/protocols";
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/stores/room-channel-binding-index.ts
+import {
+  ChannelBindingMigrationConflictError
+} from "@axiom-lattice/protocols";
+var UNIQUE_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS idx_lt_cb_subject_unique
+  ON lt_channel_bindings(channel, channel_installation_id, tenant_id, sender_id)`;
+var LOOKUP_INDEX_SQL = `CREATE INDEX IF NOT EXISTS idx_lt_cb_resolve
+  ON lt_channel_bindings(channel, sender_id, channel_installation_id, tenant_id)`;
+function ensureChannelBindingSubjectIndex(db) {
+  db.exec("BEGIN");
+  try {
+    const conflicts = db.prepare(`SELECT tenant_id, channel, channel_installation_id, sender_id, COUNT(*) AS count
+      FROM lt_channel_bindings
+      GROUP BY channel, channel_installation_id, tenant_id, sender_id
+      HAVING COUNT(*) > 1
+      ORDER BY tenant_id, channel, channel_installation_id, sender_id`).all();
+    if (conflicts.length > 0) {
+      throw new ChannelBindingMigrationConflictError(conflicts.map(mapConflict));
+    }
+    db.exec("DROP INDEX IF EXISTS idx_lt_cb_room_subject");
+    db.exec(UNIQUE_INDEX_SQL);
+    db.exec(LOOKUP_INDEX_SQL);
+    db.exec("COMMIT");
+  } catch (error) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+  db.save();
+}
+function mapConflict(row) {
+  return {
+    tenantId: row.tenant_id,
+    channel: row.channel,
+    channelInstallationId: row.channel_installation_id,
+    senderId: row.sender_id,
+    count: row.count
+  };
+}
+
+// src/stores/LocalChannelBindingStore.ts
 var DDL14 = `
 CREATE TABLE IF NOT EXISTS lt_channel_bindings (
   id TEXT PRIMARY KEY,
@@ -2670,12 +3354,23 @@ CREATE TABLE IF NOT EXISTS lt_channel_bindings (
   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, DDL14);
+    ensureChannelBindingSubjectIndex(db);
+  }
+  async findById(tenantId, id) {
+    const row = this.db.prepare(
+      "SELECT * FROM lt_channel_bindings WHERE id = ? AND tenant_id = ?"
+    ).get(id, tenantId);
+    return row ? mapRowToBinding(row) : null;
+  }
+  async findBySubject(params) {
+    const row = this.db.prepare(`SELECT * FROM lt_channel_bindings
+      WHERE tenant_id = ? AND channel = ? AND channel_installation_id = ? AND sender_id = ? LIMIT 1`).get(params.tenantId, params.channel, params.channelInstallationId, params.senderId);
+    return row ? mapRowToBinding(row) : null;
   }
   async resolve(params) {
     const row = this.db.prepare(
@@ -2688,35 +3383,41 @@ var LocalChannelBindingStore = class {
   async create(input) {
     const id = randomUUID2();
     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
-    );
+    try {
+      this.db.prepare(
+        `INSERT INTO lt_channel_bindings
+        (id, channel, channel_installation_id, tenant_id, sender_id, agent_id,
+           thread_id, thread_mode, sender_display_name, sender_metadata, workspace_id, project_id, enabled, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        input.channel,
+        input.channelInstallationId,
+        input.tenantId,
+        input.senderId,
+        input.agentId,
+        input.threadId || null,
+        input.threadMode || "fixed",
+        input.senderDisplayName || null,
+        input.senderMetadata ? JSON.stringify(input.senderMetadata) : null,
+        input.workspaceId || null,
+        input.projectId || null,
+        input.enabled ?? true ? 1 : 0,
+        now,
+        now
+      );
+    } catch (error) {
+      if (error instanceof Error && /UNIQUE constraint failed/.test(error.message)) {
+        throw new DuplicateChannelBindingSubjectError();
+      }
+      throw error;
+    }
     return await this.getById(id);
   }
-  async update(id, patch) {
-    const existing = await this.getById(id);
+  async update(tenantId, id, patch) {
+    const existing = await this.findById(tenantId, 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,
@@ -2729,14 +3430,10 @@ var LocalChannelBindingStore = class {
     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 = ?,
+         agent_id = ?, thread_id = ?, workspace_id = ?, project_id = ?, thread_mode = ?,
          sender_display_name = ?, sender_metadata = ?, enabled = ?, updated_at = ?
-       WHERE id = ?`
+       WHERE id = ? AND tenant_id = ?`
     ).run(
-      updated.channel,
-      updated.channelInstallationId,
-      updated.senderId,
       updated.agentId,
       updated.threadId || null,
       updated.workspaceId || null,
@@ -2746,12 +3443,13 @@ var LocalChannelBindingStore = class {
       updated.senderMetadata ? JSON.stringify(updated.senderMetadata) : null,
       updated.enabled ? 1 : 0,
       now,
-      id
+      id,
+      tenantId
     );
-    return await this.getById(id);
+    return await this.findById(tenantId, id);
   }
-  async delete(id) {
-    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ?`).run(id);
+  async delete(tenantId, id) {
+    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ? AND tenant_id = ?`).run(id, tenantId);
   }
   async list(params) {
     const conditions = ["tenant_id = ?"];
@@ -2768,18 +3466,35 @@ var LocalChannelBindingStore = class {
       conditions.push("channel_installation_id = ?");
       values.push(params.channelInstallationId);
     }
+    if (params.excludeChannels?.length) {
+      conditions.push(`channel NOT IN (${params.excludeChannels.map(() => "?").join(", ")})`);
+      values.push(...params.excludeChannels);
+    }
+    for (const prefix of params.excludeInstallationIdPrefixes ?? []) {
+      conditions.push("substr(channel_installation_id, 1, length(?)) <> ?");
+      values.push(prefix, prefix);
+    }
     const limit = params.limit ?? 50;
     const offset = params.offset ?? 0;
     values.push(limit, offset);
-    const rows = this.db.prepare(
+    const rows2 = 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);
+    return rows2.map(mapRowToBinding);
   }
-  async import(bindings) {
+  async import(tenantId, bindings) {
+    if (bindings.some((binding) => binding.channel === "room")) {
+      throw new Error("Room bindings cannot be imported through the public store API");
+    }
+    if (bindings.some((binding) => binding.channelInstallationId.startsWith("room-internal:"))) {
+      throw new Error("Internal bindings cannot be imported through the public store API");
+    }
+    if (bindings.some((binding) => binding.tenantId !== tenantId)) {
+      throw new Error("Binding import tenant mismatch");
+    }
     const result = [];
     for (const input of bindings) {
       result.push(await this.create(input));
@@ -2787,7 +3502,13 @@ var LocalChannelBindingStore = class {
     return result;
   }
   async export(params) {
-    return this.list({ tenantId: params.tenantId, limit: 1e4, offset: 0 });
+    return this.list({
+      tenantId: params.tenantId,
+      excludeChannels: ["room"],
+      excludeInstallationIdPrefixes: ["room-internal:"],
+      limit: 1e4,
+      offset: 0
+    });
   }
   async getById(id) {
     const row = this.db.prepare(
@@ -2841,33 +3562,33 @@ var LocalChannelInstallationStore = class {
     const row = this.db.prepare(
       `SELECT * FROM lt_channel_installations WHERE id = ?`
     ).get(installationId);
-    return row ? mapRow(row) : null;
+    return row ? mapRow5(row) : null;
   }
   async getInstallationsByTenant(tenantId, channel) {
-    let rows;
+    let rows2;
     if (channel) {
-      rows = this.db.prepare(
+      rows2 = 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(
+      rows2 = this.db.prepare(
         `SELECT * FROM lt_channel_installations WHERE tenant_id = ? ORDER BY created_at DESC`
       ).all(tenantId);
     }
-    return rows.map(mapRow);
+    return rows2.map(mapRow5);
   }
   async getAllInstallations(channel) {
-    let rows;
+    let rows2;
     if (channel) {
-      rows = this.db.prepare(
+      rows2 = this.db.prepare(
         `SELECT * FROM lt_channel_installations WHERE channel = ? ORDER BY created_at DESC`
       ).all(channel);
     } else {
-      rows = this.db.prepare(
+      rows2 = this.db.prepare(
         `SELECT * FROM lt_channel_installations ORDER BY created_at DESC`
       ).all();
     }
-    return rows.map(mapRow);
+    return rows2.map(mapRow5);
   }
   async createInstallation(tenantId, installationId, data) {
     const now = nowISO();
@@ -2892,7 +3613,7 @@ var LocalChannelInstallationStore = class {
       tenantId,
       channel: data.channel,
       name: data.name,
-      config: data.config,
+      config: { ...data.config },
       enabled: data.enabled !== false,
       fallbackAgentId: data.fallbackAgentId,
       rejectWhenNoBinding: data.rejectWhenNoBinding ?? false,
@@ -2902,7 +3623,7 @@ var LocalChannelInstallationStore = class {
   }
   async updateInstallation(tenantId, installationId, updates) {
     const existing = await this.getInstallationById(installationId);
-    if (!existing) return null;
+    if (!existing || existing.tenantId !== tenantId) return null;
     const setClauses = [];
     const values = [];
     if (updates.name !== void 0) {
@@ -2929,9 +3650,10 @@ var LocalChannelInstallationStore = class {
     const now = nowISO();
     setClauses.push("updated_at = ?");
     values.push(now);
+    values.push(tenantId);
     values.push(installationId);
     this.db.prepare(
-      `UPDATE lt_channel_installations SET ${setClauses.join(", ")} WHERE id = ?`
+      `UPDATE lt_channel_installations SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ?`
     ).run(...values);
     return this.getInstallationById(installationId);
   }
@@ -2942,7 +3664,7 @@ var LocalChannelInstallationStore = class {
     return result.changes > 0;
   }
 };
-function mapRow(row) {
+function mapRow5(row) {
   return {
     id: row.id,
     tenantId: row.tenant_id,
@@ -2993,18 +3715,18 @@ var LocalA2AApiKeyStore = class {
     this.repairManagementIds();
   }
   /** Add a column if it does not exist (SQLite version compatible). */
-  ensureColumn(table, column, ddl) {
+  ensureColumn(table, column, ddl2) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === column)) {
-      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl2}`);
     }
   }
   repairManagementIds() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT rowid, id FROM lt_a2a_api_keys`
     ).all();
     const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    for (const row of rows) {
+    for (const row of rows2) {
       if (!row.id || !uuidPattern.test(row.id)) {
         this.db.prepare(
           `UPDATE lt_a2a_api_keys SET id = ? WHERE rowid = ?`
@@ -3013,10 +3735,10 @@ var LocalA2AApiKeyStore = class {
     }
   }
   async findByKey(key) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_a2a_api_keys WHERE enabled = 1`
     ).all();
-    for (const row of rows) {
+    for (const row of rows2) {
       try {
         if (decrypt3(row.key_value) === key) return mapRowToRecord(row);
       } catch {
@@ -3033,17 +3755,17 @@ var LocalA2AApiKeyStore = class {
   async list(params) {
     const limit = params.limit || 100;
     const offset = params.offset || 0;
-    let rows;
+    let rows2;
     if (params.tenantId) {
-      rows = this.db.prepare(
+      rows2 = 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(
+      rows2 = this.db.prepare(
         `SELECT * FROM lt_a2a_api_keys ORDER BY created_at DESC LIMIT ? OFFSET ?`
       ).all(limit, offset);
     }
-    return rows.map(mapRowToRecord);
+    return rows2.map(mapRowToRecord);
   }
   async create(input) {
     const id = randomUUID3();
@@ -3053,7 +3775,7 @@ var LocalA2AApiKeyStore = class {
       `INSERT INTO lt_a2a_api_keys (id, key_value, tenant_id, project_id, assistant_ids, label, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(id, encrypt3(key), input.tenantId, input.projectId, input.assistantIds ? JSON.stringify(input.assistantIds) : null, input.label || null, now, now);
-    const record = {
+    const record2 = {
       id,
       key,
       tenantId: input.tenantId,
@@ -3064,7 +3786,7 @@ var LocalA2AApiKeyStore = class {
       createdAt: parseISO(now),
       updatedAt: parseISO(now)
     };
-    return record;
+    return record2;
   }
   async disable(id) {
     const now = nowISO();
@@ -3092,19 +3814,19 @@ var LocalA2AApiKeyStore = class {
     ).run(encrypt3(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;
+    const record2 = mapRowToRecord(row);
+    record2.key = key;
+    return record2;
   }
   async delete(id) {
     this.db.prepare(`DELETE FROM lt_a2a_api_keys WHERE id = ?`).run(id);
   }
   async loadIntoMap() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_a2a_api_keys WHERE enabled = 1`
     ).all();
     const map2 = /* @__PURE__ */ new Map();
-    for (const row of rows) {
+    for (const row of rows2) {
       try {
         const key = decrypt3(row.key_value);
         map2.set(key, {
@@ -3140,6 +3862,10 @@ function mapRowToRecord(row) {
 }
 
 // src/stores/LocalThreadMessageQueueStore.ts
+import {
+  parseQueuedExecutionMode,
+  parseTrustedRunContext
+} from "@axiom-lattice/protocols";
 import { randomUUID as randomUUID4 } from "crypto";
 var DDL17 = `
 CREATE TABLE IF NOT EXISTS lt_thread_message_queue (
@@ -3156,6 +3882,8 @@ CREATE TABLE IF NOT EXISTS lt_thread_message_queue (
   status TEXT NOT NULL DEFAULT 'pending',
   command TEXT,
   custom_run_config TEXT,
+  trusted_run_context TEXT,
+  execution_mode TEXT CHECK (execution_mode IS NULL OR execution_mode = 'followup'),
   created_at TEXT NOT NULL
 );
 CREATE INDEX IF NOT EXISTS idx_lt_tmq_thread ON lt_thread_message_queue(thread_id, status);
@@ -3166,8 +3894,17 @@ var LocalThreadMessageQueueStore = class {
     this.capacityTail = Promise.resolve();
     this.db = db;
     ensureTable(db, DDL17);
+    const columns5 = db.prepare("PRAGMA table_info(lt_thread_message_queue)").all();
+    const names = new Set(columns5.map(({ name }) => name));
+    if (!names.has("trusted_run_context")) {
+      db.run("ALTER TABLE lt_thread_message_queue ADD COLUMN trusted_run_context TEXT");
+    }
+    if (!names.has("execution_mode")) {
+      db.run("ALTER TABLE lt_thread_message_queue ADD COLUMN execution_mode TEXT CHECK (execution_mode IS NULL OR execution_mode = 'followup')");
+    }
   }
   async addMessage(params) {
+    const trusted = validateQueueTrust(params);
     const now = nowISO();
     const id = params.id || randomUUID4();
     const seqRow = this.db.prepare(
@@ -3175,8 +3912,8 @@ var LocalThreadMessageQueueStore = class {
     ).get(params.threadId);
     const nextSeq = seqRow.next_seq;
     this.db.prepare(
-      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, trusted_run_context, execution_mode, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(
       id,
       params.threadId,
@@ -3190,11 +3927,14 @@ var LocalThreadMessageQueueStore = class {
       params.priority ?? 0,
       params.command ? JSON.stringify(params.command) : null,
       params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      trusted.trustedRunContext ? JSON.stringify(trusted.trustedRunContext) : null,
+      trusted.executionMode ?? null,
       now
     );
     return this.getById(id);
   }
   async addMessageIfCapacity(params, maxSize) {
+    const trusted = validateQueueTrust(params);
     let release;
     const previous = this.capacityTail;
     this.capacityTail = new Promise((resolve) => {
@@ -3212,10 +3952,11 @@ var LocalThreadMessageQueueStore = class {
       const id = params.id || randomUUID4();
       const limit = maxSize === Infinity ? -1 : maxSize;
       const result = this.db.prepare(
-        `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
+        `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, trusted_run_context, execution_mode, created_at)
          SELECT ?, ?, ?, ?, ?, ?, ?, ?,
            (SELECT COALESCE(MAX(sequence_order), 0) + 1 FROM lt_thread_message_queue WHERE thread_id = ?),
-           ?, ?, ?, ?
+           ?, ?, ?, ?, ?,
+           ?
          WHERE ? = -1 OR (SELECT COUNT(*) FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql}) < ?`
       ).run(
         id,
@@ -3230,6 +3971,8 @@ var LocalThreadMessageQueueStore = class {
         params.priority ?? 0,
         params.command ? JSON.stringify(params.command) : null,
         params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+        trusted.trustedRunContext ? JSON.stringify(trusted.trustedRunContext) : null,
+        trusted.executionMode ?? null,
         nowISO(),
         limit,
         params.threadId,
@@ -3242,14 +3985,15 @@ var LocalThreadMessageQueueStore = class {
     }
   }
   async addMessageAtHead(params) {
+    const trusted = validateQueueTrust(params);
     const now = nowISO();
     const id = params.id || randomUUID4();
     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, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`
+      `INSERT INTO lt_thread_message_queue (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config, trusted_run_context, execution_mode, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?, ?, ?)`
     ).run(
       id,
       params.threadId,
@@ -3262,23 +4006,25 @@ var LocalThreadMessageQueueStore = class {
       seqRow.next_seq,
       params.command ? JSON.stringify(params.command) : null,
       params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+      trusted.trustedRunContext ? JSON.stringify(trusted.trustedRunContext) : null,
+      trusted.executionMode ?? null,
       now
     );
     return this.getById(id);
   }
   async getPendingMessages(threadId, scope) {
     const filter = scopeClause(scope);
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql} ORDER BY priority DESC, sequence_order ASC`
     ).all(threadId, ...filter.params);
-    return rows.map(rowToMessage);
+    return rows2.map(rowToMessage);
   }
   async getProcessingMessages(threadId, scope) {
     const filter = scopeClause(scope);
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'processing'${filter.sql} ORDER BY priority DESC, sequence_order ASC`
     ).all(threadId, ...filter.params);
-    return rows.map(rowToMessage);
+    return rows2.map(rowToMessage);
   }
   async getQueueSize(threadId, scope) {
     const filter = scopeClause(scope);
@@ -3288,10 +4034,10 @@ var LocalThreadMessageQueueStore = class {
     return row.count;
   }
   async getThreadsWithPendingMessages() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT tenant_id, assistant_id, thread_id, workspace_id, project_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') GROUP BY tenant_id, assistant_id, thread_id, workspace_id, project_id ORDER BY thread_id`
     ).all();
-    return rows.map((r) => ({
+    return rows2.map((r) => ({
       tenantId: r.tenant_id,
       assistantId: r.assistant_id,
       threadId: r.thread_id,
@@ -3330,6 +4076,12 @@ var LocalThreadMessageQueueStore = class {
     return rowToMessage(row);
   }
 };
+function validateQueueTrust(params) {
+  return {
+    trustedRunContext: params.trusted_run_context === void 0 ? void 0 : parseTrustedRunContext(params.trusted_run_context),
+    executionMode: params.execution_mode === void 0 ? void 0 : parseQueuedExecutionMode(params.execution_mode)
+  };
+}
 function scopeClause(scope) {
   if (!scope) return { sql: "", params: [] };
   const entries = ["tenantId", "assistantId", "workspaceId", "projectId"].map((key) => [key, scope[key]]);
@@ -3347,7 +4099,9 @@ function rowToMessage(row) {
     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
+    custom_run_config: row.custom_run_config ? JSON.parse(row.custom_run_config) : void 0,
+    trusted_run_context: row.trusted_run_context ? parseTrustedRunContext(JSON.parse(row.trusted_run_context)) : void 0,
+    execution_mode: row.execution_mode == null ? void 0 : parseQueuedExecutionMode(row.execution_mode)
   };
 }
 
@@ -3374,10 +4128,10 @@ var LocalSkillStore = class {
     ensureTable(db, DDL18);
   }
   async getAllSkills(tenantId, _context) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_skills WHERE tenant_id = ? ORDER BY created_at DESC`
     ).all(tenantId);
-    return rows.map(mapRowToSkill);
+    return rows2.map(mapRowToSkill);
   }
   async getSkillById(tenantId, id, _context) {
     const row = this.db.prepare(
@@ -3482,16 +4236,16 @@ var LocalSkillStore = class {
     return all.filter((s) => s.metadata?.[metadataKey] === metadataValue);
   }
   async filterByCompatibility(tenantId, compatibility, _context) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_skills WHERE tenant_id = ? AND compatibility = ? ORDER BY created_at DESC`
     ).all(tenantId, compatibility);
-    return rows.map(mapRowToSkill);
+    return rows2.map(mapRowToSkill);
   }
   async filterByLicense(tenantId, license, _context) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_skills WHERE tenant_id = ? AND license = ? ORDER BY created_at DESC`
     ).all(tenantId, license);
-    return rows.map(mapRowToSkill);
+    return rows2.map(mapRowToSkill);
   }
   async getSubSkills(tenantId, parentSkillName, _context) {
     const all = await this.getAllSkills(tenantId);
@@ -3703,40 +4457,40 @@ var LocalScheduleStorage = class {
     this.db.prepare(`DELETE FROM lt_scheduled_tasks WHERE task_id = ?`).run(taskId);
   }
   async getActiveTasks() {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE status IN ('pending', 'paused') ORDER BY created_at ASC`
     ).all();
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getTasksByType(taskType) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE task_type = ? ORDER BY created_at DESC`
     ).all(taskType);
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getTasksByStatus(status) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE status = ? ORDER BY created_at DESC`
     ).all(status);
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getTasksByExecutionType(executionType) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE execution_type = ? ORDER BY created_at DESC`
     ).all(executionType);
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getTasksByAssistantId(assistantId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE assistant_id = ? ORDER BY created_at DESC`
     ).all(assistantId);
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getTasksByThreadId(threadId) {
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_scheduled_tasks WHERE thread_id = ? ORDER BY created_at DESC`
     ).all(threadId);
-    return rows.map(mapRowToTask);
+    return rows2.map(mapRowToTask);
   }
   async getAllTasks(filters) {
     const conditions = [];
@@ -3776,8 +4530,8 @@ var LocalScheduleStorage = class {
       query += ` OFFSET ?`;
       values.push(filters.offset);
     }
-    const rows = this.db.prepare(query).all(...values);
-    return rows.map(mapRowToTask);
+    const rows2 = this.db.prepare(query).all(...values);
+    return rows2.map(mapRowToTask);
   }
   async countTasks(filters) {
     const conditions = [];
@@ -3850,6 +4604,15 @@ function mapRowToTask(row) {
 // src/stores/LocalTaskStore.ts
 import { randomUUID as randomUUID5 } from "crypto";
 var MAX_CANONICAL_TASK_TIME = "9999-12-31T23:59:59.999Z";
+var TASK_STATUSES = /* @__PURE__ */ new Set([
+  "pending",
+  "in_progress",
+  "review",
+  "failed",
+  "interrupted",
+  "completed",
+  "cancelled"
+]);
 var NEXT_UPDATED_AT_SQL = `updated_at = CASE
   WHEN strftime('%Y-%m-%dT%H:%M:%fZ', updated_at) = updated_at AND updated_at >= ?
     THEN strftime('%Y-%m-%dT%H:%M:%fZ', updated_at, '+0.001 seconds')
@@ -3922,6 +4685,9 @@ function nextISO(previous) {
   const previousMs = new Date(previous).getTime();
   return new Date(Math.max(Date.now(), previousMs + 1)).toISOString();
 }
+function assertPage(limit, offset = 0) {
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(offset) || offset < 0) throw new RangeError("Invalid task page");
+}
 var LocalTaskStore = class {
   constructor(db) {
     this.db = db;
@@ -3935,10 +4701,10 @@ var LocalTaskStore = class {
     this.ensureColumn("lt_tasks", "files", "files TEXT");
   }
   /** Add a column if it does not exist (SQLite version compatible). */
-  ensureColumn(table, column, ddl) {
+  ensureColumn(table, column, ddl2) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === column)) {
-      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl2}`);
     }
   }
   async create(params) {
@@ -4004,7 +4770,8 @@ var LocalTaskStore = class {
       conditions.push("workspace_id = ?");
       params.push(filter.workspaceId);
     }
-    if (filter.projectId) {
+    if (filter.projectId === null) conditions.push("(project_id IS NULL OR project_id = '' OR project_id = 'default')");
+    else if (filter.projectId !== void 0) {
       conditions.push("project_id = ?");
       params.push(filter.projectId);
     }
@@ -4034,10 +4801,44 @@ var LocalTaskStore = class {
     const where = conditions.join(" AND ");
     const limit = filter.limit || 100;
     const offset = filter.offset || 0;
-    const rows = this.db.prepare(
-      `SELECT * FROM lt_tasks WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+    const rows2 = this.db.prepare(
+      `SELECT * FROM lt_tasks WHERE ${where} ORDER BY created_at DESC, id DESC LIMIT ? OFFSET ?`
     ).all(...params, limit, offset);
-    return rows.map(mapRowToTask2);
+    return rows2.map(mapRowToTask2);
+  }
+  /** Lists exact project tasks containing a string dependency. */
+  async listDependents(query) {
+    assertPage(query.limit, query.offset);
+    if (query.statuses.length === 0 || query.statuses.some((status) => !TASK_STATUSES.has(status))) {
+      throw new RangeError("Invalid task statuses");
+    }
+    const rows2 = this.db.prepare(
+      `SELECT task.* FROM lt_tasks AS task
+       WHERE task.tenant_id = ? AND task.workspace_id = ? AND task.project_id = ?
+         AND task.status IN (${query.statuses.map(() => "?").join(", ")})
+         AND task.dependencies IS NOT NULL
+         AND json_valid(task.dependencies) = 1
+         AND json_type(CASE WHEN json_valid(task.dependencies)=1
+                            THEN task.dependencies ELSE '[]' END) = 'array'
+         AND EXISTS (
+           SELECT 1 FROM json_each(
+             CASE WHEN json_valid(task.dependencies)=1 THEN
+               CASE WHEN json_type(task.dependencies)='array' THEN task.dependencies ELSE '[]' END
+             ELSE '[]' END
+           ) AS dependency
+           WHERE dependency.type = 'text' AND dependency.value = ?
+         )
+       ORDER BY task.created_at DESC, task.id DESC LIMIT ? OFFSET ?`
+    ).all(
+      query.tenantId,
+      query.workspaceId,
+      query.projectId,
+      ...query.statuses,
+      query.dependencyTaskId,
+      query.limit,
+      query.offset
+    );
+    return rows2.map(mapRowToTask2);
   }
   async update(tenantId, id, updates) {
     const existing = await this.getById(tenantId, id);
@@ -4389,6 +5190,54 @@ var LocalTaskStore = class {
     if (result.changes === 0) return null;
     return this.getById(tenantId, id);
   }
+  /** Atomically update only while status, timestamp, owner, and Project scope match. */
+  async updateIfSnapshot(tenantId, id, updates, snapshot) {
+    const expectedIso = new Date(snapshot.updatedAt).toISOString();
+    if (expectedIso === MAX_CANONICAL_TASK_TIME) return null;
+    const setClauses = ["updated_at = ?"];
+    const values = [nextISO(expectedIso)];
+    const fields = [
+      ["title", "title"],
+      ["description", "description"],
+      ["status", "status"],
+      ["priority", "priority"],
+      ["dueDate", "due_date"],
+      ["metadata", "metadata", true],
+      ["parentId", "parent_id"],
+      ["sourceId", "source_id"],
+      ["context", "context", true],
+      ["ownerType", "owner_type"],
+      ["ownerId", "owner_id"],
+      ["requireReview", "require_review"],
+      ["dependencies", "dependencies", true],
+      ["result", "result"],
+      ["failureReason", "failure_reason"],
+      ["workspaceId", "workspace_id"],
+      ["projectId", "project_id"],
+      ["files", "files", true]
+    ];
+    for (const [field, column, json] of fields) {
+      const value = updates[field];
+      if (value === void 0) continue;
+      setClauses.push(`${column} = ?`);
+      values.push(json && value !== null ? JSON.stringify(value) : field === "requireReview" ? value ? 1 : 0 : value);
+    }
+    values.push(
+      tenantId,
+      id,
+      snapshot.status,
+      expectedIso,
+      snapshot.ownerType,
+      snapshot.ownerId,
+      snapshot.workspaceId,
+      snapshot.projectId
+    );
+    const result = this.db.prepare(
+      `UPDATE lt_tasks SET ${setClauses.join(", ")} WHERE tenant_id = ? AND id = ? AND status = ?
+        AND updated_at = ? AND owner_type = ? AND owner_id = ? AND workspace_id IS ? AND project_id IS ?`
+    ).run(...values);
+    return result.changes === 0 ? null : this.getById(tenantId, id);
+  }
   /** Atomically update a child only when both child and parent snapshots match. */
   async updateIfStatusUpdatedAtAndParentUpdatedAt(tenantId, id, updates, expectedStatuses, expectedUpdatedAt, parentId, expectedParentUpdatedAt) {
     if (expectedStatuses.length === 0) return null;
@@ -4489,11 +5338,36 @@ var LocalTaskStore = class {
     ).run(tenantId, id);
     return result.changes > 0;
   }
+  /** Atomically delete only while status, timestamp, owner, and Project scope match. */
+  async deleteIfSnapshot(tenantId, id, snapshot) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_tasks WHERE tenant_id = ? AND id = ? AND status = ? AND updated_at = ?
+        AND owner_type = ? AND owner_id = ? AND workspace_id IS ? AND project_id IS ?`
+    ).run(
+      tenantId,
+      id,
+      snapshot.status,
+      new Date(snapshot.updatedAt).toISOString(),
+      snapshot.ownerType,
+      snapshot.ownerId,
+      snapshot.workspaceId,
+      snapshot.projectId
+    );
+    return result.changes > 0;
+  }
 };
 
 // src/stores/LocalTaskWorkItemStore.ts
 import { MAX_PENDING_EXECUTION_RESULTS_LIMIT } from "@axiom-lattice/protocols";
 import { v4 as uuid2 } from "uuid";
+var PROJECT_LIFECYCLE_ACTIONS = /* @__PURE__ */ new Set([
+  "in_progress",
+  "interrupted",
+  "failed",
+  "completed",
+  "cancelled",
+  "reassigned"
+]);
 var DDL21 = `
 CREATE TABLE IF NOT EXISTS lt_task_work_items (
   id TEXT NOT NULL,
@@ -4511,6 +5385,15 @@ CREATE TABLE IF NOT EXISTS lt_task_work_items (
   PRIMARY KEY (tenant_id, id)
 );
 `;
+function parseDetail(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function mapRowToWorkItem(row) {
   return {
     id: row.id,
@@ -4520,7 +5403,7 @@ function mapRowToWorkItem(row) {
     actor: row.actor,
     threadId: row.thread_id ?? void 0,
     summary: row.summary ?? void 0,
-    detail: row.detail ? JSON.parse(row.detail) : void 0,
+    detail: parseDetail(row.detail),
     attempt: row.attempt ?? void 0,
     workspaceId: row.workspace_id ?? void 0,
     projectId: row.project_id ?? void 0,
@@ -4528,6 +5411,34 @@ function mapRowToWorkItem(row) {
     createdAt: parseISO(row.created_at)
   };
 }
+function assertAndCloneProjectLifecycleEvent(item) {
+  let milliseconds;
+  try {
+    milliseconds = Date.prototype.getTime.call(item.createdAt);
+  } catch {
+    throw new Error("Invalid project lifecycle event row");
+  }
+  if (!Number.isFinite(milliseconds) || typeof item.id !== "string" || item.id.length === 0 || typeof item.eventKey !== "string" || item.eventKey.length === 0) {
+    throw new Error("Invalid project lifecycle event row");
+  }
+  return { ...item, createdAt: new Date(milliseconds) };
+}
+function assertLifecyclePage(query) {
+  if (!Number.isSafeInteger(query.limit) || query.limit < 1 || query.limit > 100 || query.actions.length === 0 || query.actions.some((action) => !PROJECT_LIFECYCLE_ACTIONS.has(action))) {
+    throw new RangeError("Invalid project lifecycle event page");
+  }
+  if (!query.before) return null;
+  let milliseconds;
+  try {
+    milliseconds = Date.prototype.getTime.call(query.before.createdAt);
+  } catch {
+    throw new RangeError("Invalid project lifecycle event cursor");
+  }
+  if (!Number.isFinite(milliseconds) || typeof query.before.id !== "string" || query.before.id.length === 0) {
+    throw new RangeError("Invalid project lifecycle event cursor");
+  }
+  return milliseconds;
+}
 var LocalTaskWorkItemStore = class {
   constructor(db) {
     this.db = db;
@@ -4542,12 +5453,15 @@ var LocalTaskWorkItemStore = class {
     this.db.exec(`CREATE INDEX IF NOT EXISTS idx_task_work_items_reconciled_result
       ON lt_task_work_items (tenant_id, task_id, json_extract(detail, '$.executionResultId'))
       WHERE action = 'execution_reconciled';`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_task_work_items_project_lifecycle
+      ON lt_task_work_items (tenant_id, workspace_id, project_id, created_at DESC, id DESC)
+      WHERE event_key IS NOT NULL;`);
   }
   /** Add a column if it does not exist (SQLite version compatible). */
-  ensureColumn(table, column, ddl) {
+  ensureColumn(table, column, ddl2) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === column)) {
-      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl}`);
+      this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl2}`);
     }
   }
   async create(params) {
@@ -4575,6 +5489,41 @@ var LocalTaskWorkItemStore = class {
     ).get(params.tenantId, id);
     return mapRowToWorkItem(row);
   }
+  /** Atomically inserts a work item by selecting one exact task snapshot. */
+  async createIfTaskSnapshot(params, snapshot) {
+    const id = uuid2();
+    const result = this.db.prepare(
+      `INSERT INTO lt_task_work_items
+        (id, tenant_id, task_id, action, actor, thread_id, summary, detail, attempt, workspace_id, project_id, created_at)
+       SELECT ?, task.tenant_id, task.id, ?, ?, ?, ?, ?, ?, task.workspace_id, task.project_id, ?
+       FROM lt_tasks AS task
+       WHERE task.tenant_id = ? AND task.id = ? AND task.status = ? AND task.updated_at = ?
+          AND task.owner_type = ? AND task.owner_id = ? AND task.workspace_id IS ? AND task.project_id IS ?
+          AND ? IS task.workspace_id AND ? IS task.project_id`
+    ).run(
+      id,
+      params.action,
+      params.actor,
+      params.threadId || null,
+      params.summary || null,
+      params.detail ? JSON.stringify(params.detail) : null,
+      params.attempt ?? null,
+      nowISO(),
+      params.tenantId,
+      params.taskId,
+      snapshot.status,
+      new Date(snapshot.updatedAt).toISOString(),
+      snapshot.ownerType,
+      snapshot.ownerId,
+      snapshot.workspaceId,
+      snapshot.projectId,
+      params.workspaceId,
+      params.projectId
+    );
+    if (result.changes === 0) return null;
+    const row = this.db.prepare(`SELECT * FROM lt_task_work_items WHERE tenant_id = ? AND id = ?`).get(params.tenantId, id);
+    return row ? mapRowToWorkItem(row) : null;
+  }
   /** Find an event by its tenant- and task-scoped key without pagination. */
   async findByEventKey(tenantId, taskId, eventKey) {
     const row = this.db.prepare(
@@ -4627,10 +5576,10 @@ var LocalTaskWorkItemStore = class {
     const limit = filter.limit || 100;
     const offset = filter.offset || 0;
     const order = filter.order === "asc" ? "ASC" : "DESC";
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT * FROM lt_task_work_items WHERE ${where} ORDER BY created_at ${order}, id ${order} LIMIT ? OFFSET ?`
     ).all(...params, limit, offset);
-    return rows.map(mapRowToWorkItem);
+    return rows2.map(mapRowToWorkItem);
   }
   /** List pending execution results using one bounded SQLite anti-join query. */
   async listPendingExecutionResults(params) {
@@ -4640,7 +5589,7 @@ var LocalTaskWorkItemStore = class {
       throw error;
     }
     if (params.limit === 0) return [];
-    const rows = this.db.prepare(
+    const rows2 = this.db.prepare(
       `SELECT result.*
        FROM lt_task_work_items AS result
        WHERE result.tenant_id = ?
@@ -4660,7 +5609,31 @@ var LocalTaskWorkItemStore = class {
        ORDER BY result.created_at DESC, result.id DESC
        LIMIT ?`
     ).all(params.tenantId, params.taskId, params.limit);
-    return rows.map(mapRowToWorkItem);
+    return rows2.map(mapRowToWorkItem);
+  }
+  /** Lists canonical project lifecycle events with an exclusive cursor. */
+  async listProjectLifecycleEvents(query) {
+    const cursorMilliseconds = assertLifecyclePage(query);
+    const cursor = cursorMilliseconds === null ? null : new Date(cursorMilliseconds).toISOString();
+    const rows2 = this.db.prepare(
+      `SELECT * FROM lt_task_work_items
+       WHERE tenant_id = ? AND workspace_id = ? AND project_id = ?
+         AND action IN (${query.actions.map(() => "?").join(", ")})
+         AND event_key IS NOT NULL AND event_key <> ''
+         AND (? IS NULL OR created_at < ? OR (created_at = ? AND id < ?))
+       ORDER BY created_at DESC, id DESC LIMIT ?`
+    ).all(
+      query.tenantId,
+      query.workspaceId,
+      query.projectId,
+      ...query.actions,
+      cursor,
+      cursor,
+      cursor,
+      query.before?.id ?? null,
+      query.limit
+    );
+    return rows2.map(mapRowToWorkItem).map(assertAndCloneProjectLifecycleEvent);
   }
 };
 
@@ -4769,6 +5742,10 @@ async function createLocalStoreConfig(options = {}) {
     assistant: new LocalAssistantStore(db),
     workspace: new LocalWorkspaceStore(db),
     project: new LocalProjectStore(db),
+    projectRoom: new LocalProjectRoomStore(db),
+    projectMembership: new LocalProjectMembershipStore(db),
+    projectBotMembership: new LocalProjectBotMembershipStore(db),
+    projectRoomMessage: new LocalProjectRoomMessageStore(db),
     user: new LocalUserStore(db),
     tenant: new LocalTenantStore(db),
     userTenantLink: new LocalUserTenantLinkStore(db),
@@ -4802,7 +5779,7 @@ var InMemoryConversationStore = class {
   }
   async createConversation(input) {
     const now = isoNow();
-    const record = {
+    const record2 = {
       conversationId: input.conversationId,
       tenantId: input.tenantId,
       taskIds: [],
@@ -4811,17 +5788,17 @@ var InMemoryConversationStore = class {
       createdAt: now,
       updatedAt: now
     };
-    this.store.set(input.conversationId, record);
-    return record;
+    this.store.set(input.conversationId, record2);
+    return record2;
   }
   async addTaskToConversation(conversationId, taskId) {
-    const record = this.store.get(conversationId);
-    if (!record) {
+    const record2 = this.store.get(conversationId);
+    if (!record2) {
       throw new Error(`Conversation not found: ${conversationId}`);
     }
-    record.taskIds.push(taskId);
-    record.updatedAt = isoNow();
-    return record;
+    record2.taskIds.push(taskId);
+    record2.updatedAt = isoNow();
+    return record2;
   }
   async deleteConversation(conversationId) {
     this.store.delete(conversationId);
@@ -4829,6 +5806,8 @@ var InMemoryConversationStore = class {
 };
 export {
   DatabaseWrapper,
+  DuplicateProjectMembershipError,
+  DuplicateProjectRoomMessageIdempotencyKeyError,
   InMemoryConversationStore,
   LocalA2AApiKeyStore,
   LocalAssistantStore,
@@ -4840,6 +5819,10 @@ export {
   LocalEvalStore,
   LocalMcpServerConfigStore,
   LocalMetricsServerConfigStore,
+  LocalProjectBotMembershipStore,
+  LocalProjectMembershipStore,
+  LocalProjectRoomMessageStore,
+  LocalProjectRoomStore,
   LocalProjectStore,
   LocalScheduleStorage,
   LocalSkillStore,
@@ -4853,6 +5836,9 @@ export {
   LocalWorkflowTrackingStore,
   LocalWorkspaceStore,
   MigrationManager,
+  ProjectBotMembershipIdConflictError,
+  ProjectMembershipIdConflictError,
+  ProjectRoomMessageIdConflictError,
   RunResult,
   StatementWrapper,
   closeDatabase,