@axiom-lattice/local-stores 3.1.1 → 3.1.2

package/src/__tests__/LocalTaskStore.test.ts

@@ -153,6 +153,34 @@ describe("LocalTaskStore metadata filter", () => {
     expect(await store.getById("t1", "a2a-task-1")).not.toBeNull();
   });
 
+  it("lists guarded JSON dependents and nonproject rows in deterministic order", async () => {
+    const base = { tenantId: "t1", ownerType: "agent", ownerId: "a1", workspaceId: "workspace-1", projectId: "project-1" } as const;
+    for (const [id, status, dependencies] of [
+      ["dependent-a", "pending", ["dependency-1"]],
+      ["dependent-b", "interrupted", ["dependency-1", "dependency-1"]],
+      ["dependent-c", "pending", ["dependency-1"]],
+    ] as const) await store.create({ ...base, id, title: id, status, dependencies });
+    db.prepare("UPDATE lt_tasks SET created_at = ? WHERE tenant_id = ?").run("2026-01-01T00:00:00.000Z", "t1");
+    for (const [id, raw] of [["null-json", null], ["empty-json", ""], ["malformed-json", "{"], ["object-json", "{}"]] as const) {
+      await store.create({ ...base, id, title: id, status: "pending" });
+      db.prepare("UPDATE lt_tasks SET dependencies = ? WHERE tenant_id = ? AND id = ?").run(raw, "t1", id);
+    }
+    await store.create({ ...base, id: "wrong-project", title: "wrong", status: "pending", dependencies: ["dependency-1"], projectId: "project-2" });
+    const query = { tenantId: "t1", workspaceId: "workspace-1", projectId: "project-1", dependencyTaskId: "dependency-1", statuses: ["pending", "interrupted"], limit: 2, offset: 0 } as const;
+
+    expect((await store.listDependents(query)).map(({ id }) => id)).toEqual(["dependent-c", "dependent-b"]);
+    await expect(store.listDependents({ ...query, statuses: [] })).rejects.toThrow(RangeError);
+    await expect(store.listDependents({ ...query, statuses: ["unknown"] as never })).rejects.toThrow(RangeError);
+    await expect(store.listDependents({ ...query, limit: 101 })).rejects.toThrow(RangeError);
+
+    for (const [id, projectId] of [["nonproject-d", undefined], ["nonproject-c", ""], ["nonproject-b", "default"]] as const) {
+      await store.create({ id, tenantId: "t1", ownerType: "user", ownerId: "u1", title: id, projectId });
+    }
+    db.prepare("UPDATE lt_tasks SET created_at = ? WHERE id LIKE 'nonproject-%'").run("2026-01-02T00:00:00.000Z");
+    expect((await store.list({ tenantId: "t1", projectId: null, limit: 2, offset: 1 })).map(({ id }) => id))
+      .toEqual(["nonproject-c", "nonproject-b"]);
+  });
+
   it("conditionally updates through independent store instances", async () => {
     const secondStore = new LocalTaskStore(db);
     await store.create({
@@ -242,6 +270,36 @@ describe("LocalTaskStore metadata filter", () => {
     expect((await store.getById("t1", created.id))?.status).toBe("in_progress");
   });
 
+  it("conditionally updates and deletes only an exact owner and project snapshot", async () => {
+    const created = await store.create({
+      id: "task-exact-snapshot", tenantId: "t1", workspaceId: "workspace-1", projectId: "project-1",
+      ownerType: "agent", ownerId: "agent-1", title: "Working", status: "pending",
+    });
+    const snapshot = {
+      status: created.status, updatedAt: created.updatedAt, ownerType: created.ownerType,
+      ownerId: created.ownerId, workspaceId: "workspace-1", projectId: "project-1",
+    };
+
+    await expect(store.updateIfSnapshot(
+      "t1", created.id, { title: "Wrong" }, { ...snapshot, projectId: "project-2" },
+    )).resolves.toBeNull();
+    const updated = await store.updateIfSnapshot("t1", created.id, { title: "Updated" }, snapshot);
+    expect(updated?.title).toBe("Updated");
+    await expect(store.deleteIfSnapshot("t1", created.id, snapshot)).resolves.toBe(false);
+    await expect(store.deleteIfSnapshot("t1", created.id, {
+      ...snapshot, updatedAt: updated!.updatedAt,
+    })).resolves.toBe(true);
+  });
+
+  it("conditionally mutates an exact nonproject snapshot", async () => {
+    const created = await store.create({ id: "nonproject-cas", tenantId: "t1", ownerType: "user", ownerId: "user-1", title: "Personal" });
+    const snapshot = { status: created.status, updatedAt: created.updatedAt, ownerType: created.ownerType,
+      ownerId: created.ownerId, workspaceId: null, projectId: null };
+    const updated = await store.updateIfSnapshot("t1", created.id, { title: "Updated" }, snapshot);
+    expect(updated?.title).toBe("Updated");
+    await expect(store.deleteIfSnapshot("t1", created.id, { ...snapshot, updatedAt: updated!.updatedAt })).resolves.toBe(true);
+  });
+
   it("atomically matches both child and parent snapshots", async () => {
     const parent = await store.create({
       id: "parent-snapshot", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Parent",

package/src/__tests__/LocalTaskWorkItemStore.test.ts

@@ -3,6 +3,7 @@ import path from "path";
 import { unlinkSync } from "fs";
 import { closeDatabase, initDatabase, type DatabaseWrapper } from "../database";
 import { LocalTaskWorkItemStore } from "../stores/LocalTaskWorkItemStore";
+import { LocalTaskStore } from "../stores/LocalTaskStore";
 
 jest.mock("uuid", () => {
   let id = 0;
@@ -42,6 +43,33 @@ async function openTaskWorkItemStore(dbPath: string): Promise<LocalTaskWorkItemS
 }
 
 describe("LocalTaskWorkItemStore", () => {
+  it("atomically inserts activity only while the task snapshot matches", async () => {
+    const dbPath = path.join(tmpdir(), `lt-task-activity-snapshot-${Date.now()}.db`);
+    try {
+      const db = await initDatabase({ dbPath });
+      const tasks = new LocalTaskStore(db);
+      const store = new LocalTaskWorkItemStore(db);
+      const task = await tasks.create({
+        id: "task-1", tenantId: "tenant-1", workspaceId: "workspace-1", projectId: "project-1",
+        ownerType: "agent", ownerId: "agent-1", title: "Task", status: "in_progress",
+      });
+      const snapshot = {
+        status: task.status, updatedAt: task.updatedAt, ownerType: task.ownerType, ownerId: task.ownerId,
+        workspaceId: "workspace-1", projectId: "project-1",
+      };
+      await expect(store.createIfTaskSnapshot({
+        tenantId: "tenant-1", taskId: "task-1", action: "activity", actor: "agent:agent-1",
+        workspaceId: "workspace-1", projectId: "project-1",
+      }, { ...snapshot, status: "pending" })).resolves.toBeNull();
+      await expect(store.createIfTaskSnapshot({
+        tenantId: "tenant-1", taskId: "task-1", action: "activity", actor: "agent:agent-1",
+        workspaceId: "workspace-1", projectId: "project-1",
+      }, snapshot)).resolves.toMatchObject({ taskId: "task-1" });
+    } finally {
+      closeDatabase();
+      unlinkSync(dbPath);
+    }
+  });
   it("persists Markdown activity across store and database instances", async () => {
     const dbPath = path.join(
       tmpdir(),
@@ -275,6 +303,45 @@ describe("LocalTaskWorkItemStore", () => {
     }
   });
 
+  it("pages project lifecycle events and rejects malformed outer rows", async () => {
+    const dbPath = path.join(tmpdir(), `lt-task-work-item-project-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    try {
+      const store = await openTaskWorkItemStore(dbPath);
+      const db = await initDatabase({ dbPath });
+      for (const [taskId, action, eventKey] of [["task-a", "in_progress", "event:a"], ["task-b", "completed", "event:b"], ["task-c", "in_progress", "event:c"]] as const) {
+        await store.createIfAbsentByEventKey({ tenantId: "tenant-1", taskId, action, eventKey, actor: "agent:a", workspaceId: "workspace-1", projectId: "project-1" });
+      }
+      db.prepare("UPDATE lt_task_work_items SET id = CASE task_id WHEN 'task-a' THEN 'event-a' WHEN 'task-b' THEN 'event-b' ELSE 'event-c' END, created_at = CASE task_id WHEN 'task-a' THEN '2026-01-01T00:00:00.000Z' ELSE '2026-01-02T00:00:00.000Z' END").run();
+      await store.create({ tenantId: "tenant-1", taskId: "missing-key", action: "completed", actor: "agent:a", workspaceId: "workspace-1", projectId: "project-1" });
+      await store.createIfAbsentByEventKey({ tenantId: "tenant-2", taskId: "wrong-tenant", action: "completed", eventKey: "event:tenant", actor: "agent:a", workspaceId: "workspace-1", projectId: "project-1" });
+      await store.createIfAbsentByEventKey({ tenantId: "tenant-1", taskId: "wrong-workspace", action: "completed", eventKey: "event:workspace", actor: "agent:a", workspaceId: "workspace-2", projectId: "project-1" });
+      await store.createIfAbsentByEventKey({ tenantId: "tenant-1", taskId: "wrong-project", action: "completed", eventKey: "event:project", actor: "agent:a", workspaceId: "workspace-1", projectId: "project-2" });
+      await store.createIfAbsentByEventKey({ tenantId: "tenant-1", taskId: "wrong-action", action: "activity", eventKey: "event:action", actor: "agent:a", workspaceId: "workspace-1", projectId: "project-1" });
+      const query = { tenantId: "tenant-1", workspaceId: "workspace-1", projectId: "project-1", actions: ["in_progress", "completed"], limit: 2 } as const;
+
+      const page1 = await store.listProjectLifecycleEvents(query);
+      expect(page1.map(({ id }) => id)).toEqual(["event-c", "event-b"]);
+      expect((await store.listProjectLifecycleEvents({ ...query, before: { createdAt: page1[1].createdAt, id: page1[1].id } })).map(({ id }) => id)).toEqual(["event-a"]);
+      await expect(store.listProjectLifecycleEvents({ ...query, actions: [] })).rejects.toThrow(RangeError);
+      await expect(store.listProjectLifecycleEvents({ ...query, actions: ["unknown"] as never })).rejects.toThrow(RangeError);
+      await expect(store.listProjectLifecycleEvents({ ...query, limit: 101 })).rejects.toThrow(RangeError);
+
+      db.prepare("UPDATE lt_task_work_items SET detail = '{' WHERE task_id = 'task-a'").run();
+      const legacy = await store.listProjectLifecycleEvents({ ...query, limit: 10 });
+      expect(legacy.find(({ id }) => id === "event-a")?.detail).toBeUndefined();
+      for (const detail of ["[]", "null", '"legacy"', "1"]) {
+        db.prepare("UPDATE lt_task_work_items SET detail = ? WHERE task_id = 'task-a'").run(detail);
+        expect((await store.listProjectLifecycleEvents({ ...query, limit: 10 }))
+          .find(({ id }) => id === "event-a")?.detail).toBeUndefined();
+      }
+
+      db.prepare("UPDATE lt_task_work_items SET id = '' WHERE task_id = 'task-a'").run();
+      await expect(store.listProjectLifecycleEvents({ ...query, limit: 10 })).rejects.toThrow("Invalid project lifecycle event row");
+    } finally {
+      closeDatabase();
+      unlinkSync(dbPath);
+    }
+  });
   it.each([-1, 1.5, Number.NaN, Number.POSITIVE_INFINITY, Number.MAX_SAFE_INTEGER + 1, 1_001])(
     "rejects invalid pending execution result limit %s",
     async (limit) => {
@@ -319,4 +386,29 @@ describe("LocalTaskWorkItemStore", () => {
       /json_extract\(detail, '\$\.executionResultId'\)[\s\S]+WHERE action = 'execution_reconciled'/,
     ));
   });
+
+  it("serves immediate pending evidence and Project lifecycle history from one database", async () => {
+    const dbPath = path.join(tmpdir(), `lt-task-work-item-combined-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    try {
+      const store = await openTaskWorkItemStore(dbPath);
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-1", eventKey: "execution-result:ordinary-thread",
+        action: "execution_result", actor: "agent:worker", workspaceId: "workspace-1", projectId: "project-1",
+      });
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-1", eventKey: "project-completed:task-1",
+        action: "completed", actor: "agent:project-worker", workspaceId: "workspace-1", projectId: "project-1",
+      });
+
+      await expect(store.listPendingExecutionResults({ tenantId: "tenant-1", taskId: "task-1", limit: 10 }))
+        .resolves.toEqual([expect.objectContaining({ eventKey: "execution-result:ordinary-thread" })]);
+      await expect(store.listProjectLifecycleEvents({
+        tenantId: "tenant-1", workspaceId: "workspace-1", projectId: "project-1",
+        actions: ["completed"], limit: 10,
+      })).resolves.toEqual([expect.objectContaining({ eventKey: "project-completed:task-1" })]);
+    } finally {
+      closeDatabase();
+      unlinkSync(dbPath);
+    }
+  });
 });

package/src/__tests__/LocalThreadMessageQueueStore.test.ts

@@ -1,15 +1,30 @@
 import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
 import path from "path";
 import { tmpdir } from "os";
-import { closeDatabase, initDatabase } from "../database";
+import { closeDatabase, initDatabase, type DatabaseWrapper } from "../database";
 import { LocalThreadMessageQueueStore } from "../stores/LocalThreadMessageQueueStore";
+import type { AddMessageParams } from "@axiom-lattice/core";
 
 describe("LocalThreadMessageQueueStore scope isolation", () => {
   let store: LocalThreadMessageQueueStore;
+  let db: DatabaseWrapper;
+  let dbPath: string;
+
+  function trustedContext(inputMessageId: string) {
+    return {
+      projectRoom: {
+        tenantId: "tenant", workspaceId: "workspace", projectId: "project",
+        roomId: "room", sourceRoomMessageId: "room-message", membershipId: "membership",
+        assistantId: "assistant", inputMessageId, role: "coordinator" as const,
+        title: "Coordinator",
+      },
+    };
+  }
 
   beforeEach(async () => {
-    const dbPath = path.join(tmpdir(), `lt-queue-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
-    store = new LocalThreadMessageQueueStore(await initDatabase({ dbPath }));
+    dbPath = path.join(tmpdir(), `lt-queue-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    db = await initDatabase({ dbPath });
+    store = new LocalThreadMessageQueueStore(db);
   });
 
   afterEach(() => closeDatabase());
@@ -75,4 +90,112 @@ describe("LocalThreadMessageQueueStore scope isolation", () => {
       projectId: null,
     })).toBe(2);
   });
+
+  it.each([
+    ["addMessage", (params: Parameters<LocalThreadMessageQueueStore["addMessage"]>[0]) => store.addMessage(params)],
+    ["addMessageIfCapacity", (params: Parameters<LocalThreadMessageQueueStore["addMessage"]>[0]) => store.addMessageIfCapacity(params, 10)],
+    ["addMessageAtHead", (params: Parameters<LocalThreadMessageQueueStore["addMessage"]>[0]) => store.addMessageAtHead(params)],
+  ])("round-trips trusted metadata through %s and processing", async (_name, add) => {
+    const trusted = trustedContext("input-1");
+    await add({
+      threadId: "thread", tenantId: "tenant", assistantId: "assistant",
+      workspaceId: "workspace", projectId: "project", content: "message", id: "input-1",
+      trusted_run_context: trusted, execution_mode: "followup",
+    });
+
+    expect((await store.getPendingMessages("thread"))[0]).toMatchObject({
+      trusted_run_context: trusted,
+      execution_mode: "followup",
+    });
+    await store.markProcessing("input-1", { model: "updated" });
+    expect((await store.getProcessingMessages("thread"))[0]).toMatchObject({
+      custom_run_config: { model: "updated" },
+      trusted_run_context: trusted,
+      execution_mode: "followup",
+    });
+  });
+
+  it("inserts capacity-accepted metadata with a persisted timestamp", async () => {
+    const before = Date.now();
+    await expect(store.addMessageIfCapacity({
+      threadId: "capacity", tenantId: "tenant", assistantId: "assistant",
+      workspaceId: "workspace", projectId: "project", content: "message", id: "capacity-input",
+      trusted_run_context: trustedContext("capacity-input"), execution_mode: "followup",
+    }, 1)).resolves.toBe(true);
+
+    const message = (await store.getPendingMessages("capacity"))[0];
+    expect(message).toMatchObject({
+      id: "capacity-input", trusted_run_context: trustedContext("capacity-input"), execution_mode: "followup",
+    });
+    expect(message.createdAt).toBeInstanceOf(Date);
+    expect(message.createdAt.getTime()).toBeGreaterThanOrEqual(before);
+  });
+
+  it.each([
+    ["addMessage", (params: AddMessageParams) => store.addMessage(params)],
+    ["addMessageIfCapacity", (params: AddMessageParams) => store.addMessageIfCapacity(params, 10)],
+    ["addMessageAtHead", (params: AddMessageParams) => store.addMessageAtHead(params)],
+  ])("rejects malformed trusted context before writing through %s", async (_name, add) => {
+    const params = {
+      threadId: "invalid", tenantId: "tenant", assistantId: "assistant", content: "message",
+      trusted_run_context: { projectRoom: { tenantId: "tenant" } },
+    } as unknown as AddMessageParams;
+
+    await expect(add(params)).rejects.toThrow("Invalid trusted agent run context");
+    await expect(store.getPendingMessages("invalid")).resolves.toEqual([]);
+  });
+
+  it.each([
+    ["addMessage", (params: AddMessageParams) => store.addMessage(params)],
+    ["addMessageIfCapacity", (params: AddMessageParams) => store.addMessageIfCapacity(params, 10)],
+    ["addMessageAtHead", (params: AddMessageParams) => store.addMessageAtHead(params)],
+  ])("rejects invalid execution mode before writing through %s", async (_name, add) => {
+    const params: AddMessageParams = {
+      threadId: "invalid-mode", tenantId: "tenant", assistantId: "assistant", content: "message",
+      execution_mode: "steer" as unknown as AddMessageParams["execution_mode"],
+    };
+
+    await expect(add(params)).rejects.toThrow("Invalid queued execution mode");
+    await expect(store.getPendingMessages("invalid-mode")).resolves.toEqual([]);
+  });
+
+  it("upgrades and reopens an existing queue table", async () => {
+    closeDatabase();
+    dbPath = path.join(tmpdir(), `lt-queue-legacy-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    db = await initDatabase({ dbPath });
+    db.exec(`CREATE TABLE lt_thread_message_queue (
+      id TEXT PRIMARY KEY, thread_id TEXT NOT NULL, tenant_id TEXT NOT NULL,
+      assistant_id TEXT NOT NULL, workspace_id TEXT, project_id TEXT,
+      message_content TEXT NOT NULL, message_type TEXT NOT NULL DEFAULT 'human',
+      sequence_order INTEGER NOT NULL DEFAULT 0, priority INTEGER NOT NULL DEFAULT 0,
+      status TEXT NOT NULL DEFAULT 'pending', command TEXT, custom_run_config TEXT,
+      created_at TEXT NOT NULL
+    )`);
+    db.save();
+    closeDatabase();
+
+    db = await initDatabase({ dbPath });
+    store = new LocalThreadMessageQueueStore(db);
+    await store.addMessage({
+      threadId: "thread", tenantId: "tenant", assistantId: "assistant",
+      workspaceId: "workspace", projectId: "project", content: "message", id: "input-1",
+      trusted_run_context: trustedContext("input-1"), execution_mode: "followup",
+    });
+
+    const columns = db.prepare("PRAGMA table_info(lt_thread_message_queue)").all() as Array<{ name: string }>;
+    expect(columns.map(({ name }) => name)).toEqual(expect.arrayContaining(["trusted_run_context", "execution_mode"]));
+    expect((await store.getPendingMessages("thread"))[0].execution_mode).toBe("followup");
+    expect(() => db.prepare("UPDATE lt_thread_message_queue SET execution_mode = 'hostile'").run()).toThrow();
+  });
+
+  it("rejects hostile trusted JSON read from storage", async () => {
+    db.prepare(`INSERT INTO lt_thread_message_queue
+      (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order,
+       priority, status, trusted_run_context, execution_mode, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+      .run("hostile", "thread", "tenant", "assistant", JSON.stringify("message"), "human", 1,
+        0, "pending", JSON.stringify({ projectRoom: { tenantId: "tenant" } }), "followup", new Date().toISOString());
+
+    await expect(store.getPendingMessages("thread")).rejects.toThrow("Invalid trusted agent run context");
+  });
 });

package/src/createLocalStoreConfig.ts

@@ -20,6 +20,10 @@ import { LocalThreadStore } from "./stores/LocalThreadStore";
 import { LocalAssistantStore } from "./stores/LocalAssistantStore";
 import { LocalWorkspaceStore } from "./stores/LocalWorkspaceStore";
 import { LocalProjectStore } from "./stores/LocalProjectStore";
+import { LocalProjectRoomStore } from "./stores/LocalProjectRoomStore";
+import { LocalProjectMembershipStore } from "./stores/LocalProjectMembershipStore";
+import { LocalProjectBotMembershipStore } from "./stores/LocalProjectBotMembershipStore";
+import { LocalProjectRoomMessageStore } from "./stores/LocalProjectRoomMessageStore";
 import { LocalUserStore } from "./stores/LocalUserStore";
 import { LocalTenantStore } from "./stores/LocalTenantStore";
 import { LocalUserTenantLinkStore } from "./stores/LocalUserTenantLinkStore";
@@ -66,6 +70,10 @@ export async function createLocalStoreConfig(options: LocalStoreConfigOptions =
     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),

package/src/index.ts

@@ -31,6 +31,10 @@ export { LocalThreadStore } from "./stores/LocalThreadStore";
 export { LocalAssistantStore } from "./stores/LocalAssistantStore";
 export { LocalWorkspaceStore } from "./stores/LocalWorkspaceStore";
 export { LocalProjectStore } from "./stores/LocalProjectStore";
+export { LocalProjectRoomStore } from "./stores/LocalProjectRoomStore";
+export { LocalProjectMembershipStore, DuplicateProjectMembershipError, ProjectMembershipIdConflictError } from "./stores/LocalProjectMembershipStore";
+export { LocalProjectBotMembershipStore, ProjectBotMembershipIdConflictError } from "./stores/LocalProjectBotMembershipStore";
+export { LocalProjectRoomMessageStore, ProjectRoomMessageIdConflictError, DuplicateProjectRoomMessageIdempotencyKeyError } from "./stores/LocalProjectRoomMessageStore";
 export { LocalUserStore } from "./stores/LocalUserStore";
 export { LocalTenantStore } from "./stores/LocalTenantStore";
 export { LocalUserTenantLinkStore } from "./stores/LocalUserTenantLinkStore";

package/src/migrations/migration.ts

@@ -84,7 +84,7 @@ export class MigrationManager {
       this.db.run(
         `INSERT INTO lattice_schema_migrations (store_name, name, version, applied_at)
          VALUES (?, ?, ?, ?)`,
-        [this.storeName, m.name, m.version, new Date().toISOString()]
+        this.storeName, m.name, m.version, new Date().toISOString()
       );
     }
   }

package/src/stores/LocalChannelBindingStore.ts

@@ -3,13 +3,14 @@
  */
 
 import { DatabaseWrapper } from "../database";
-import type {
-  Binding,
-  BindingRegistry,
-  CreateBindingInput,
+import {
+  DuplicateChannelBindingSubjectError,
+  type Binding, type BindingListParams, type BindingMutablePatch,
+  type BindingRegistry, type CreateBindingInput,
 } from "@axiom-lattice/protocols";
 import { ensureTable, nowISO, parseISO } from "../database";
 import { randomUUID } from "crypto";
+import { ensureChannelBindingSubjectIndex } from "./room-channel-binding-index";
 
 const DDL = `
 CREATE TABLE IF NOT EXISTS lt_channel_bindings (
@@ -29,7 +30,6 @@ 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);
 `;
 
 interface BindingRow {
@@ -56,6 +56,23 @@ export class LocalChannelBindingStore implements BindingRegistry {
   constructor(db: DatabaseWrapper) {
     this.db = db;
     ensureTable(db, DDL);
+    ensureChannelBindingSubjectIndex(db);
+  }
+
+  async findById(tenantId: string, id: string): Promise<Binding | null> {
+    const row = this.db.prepare(
+      "SELECT * FROM lt_channel_bindings WHERE id = ? AND tenant_id = ?",
+    ).get(id, tenantId) as unknown as BindingRow | undefined;
+    return row ? mapRowToBinding(row) : null;
+  }
+
+  async findBySubject(params: {
+    tenantId: string; channel: string; channelInstallationId: string; senderId: string;
+  }): Promise<Binding | null> {
+    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) as unknown as BindingRow | undefined;
+    return row ? mapRowToBinding(row) : null;
   }
 
   async resolve(params: {
@@ -76,31 +93,34 @@ export class LocalChannelBindingStore implements BindingRegistry {
     const id = randomUUID();
     const now = nowISO();
 
-    this.db.prepare(
-      `INSERT INTO lt_channel_bindings
-       (id, channel, channel_installation_id, tenant_id, sender_id, agent_id,
-        thread_mode, sender_display_name, sender_metadata, workspace_id, project_id, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-    ).run(
-      id, input.channel, input.channelInstallationId, input.tenantId,
-      input.senderId, input.agentId, input.threadMode || "fixed",
-      input.senderDisplayName || null,
-      input.senderMetadata ? JSON.stringify(input.senderMetadata) : null,
-      input.workspaceId || null, input.projectId || null,
-      now, now,
-    );
+    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: string, patch: Partial<Binding>): Promise<Binding> {
-    const existing = await this.getById(id);
+  async update(tenantId: string, id: string, patch: BindingMutablePatch): Promise<Binding> {
+    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 !== undefined ? patch.threadId : existing.threadId,
       workspaceId: patch.workspaceId !== undefined ? patch.workspaceId : existing.workspaceId,
@@ -115,39 +135,38 @@ export class LocalChannelBindingStore implements BindingRegistry {
 
     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,
       updated.projectId || null, updated.threadMode, updated.senderDisplayName || null,
       updated.senderMetadata ? JSON.stringify(updated.senderMetadata) : null,
-      updated.enabled ? 1 : 0, now, id,
+      updated.enabled ? 1 : 0, now, id, tenantId,
     );
 
-    return (await this.getById(id))!;
+    return (await this.findById(tenantId, id))!;
   }
 
-  async delete(id: string): Promise<void> {
-    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ?`).run(id);
+  async delete(tenantId: string, id: string): Promise<void> {
+    this.db.prepare(`DELETE FROM lt_channel_bindings WHERE id = ? AND tenant_id = ?`).run(id, tenantId);
   }
 
-  async list(params: {
-    channel?: string;
-    agentId?: string;
-    tenantId: string;
-    channelInstallationId?: string;
-    limit?: number;
-    offset?: number;
-  }): Promise<Binding[]> {
+  async list(params: BindingListParams): Promise<Binding[]> {
     const conditions: string[] = ["tenant_id = ?"];
     const values: unknown[] = [params.tenantId];
 
     if (params.channel) { conditions.push("channel = ?"); values.push(params.channel); }
     if (params.agentId) { conditions.push("agent_id = ?"); values.push(params.agentId); }
     if (params.channelInstallationId) { conditions.push("channel_installation_id = ?"); values.push(params.channelInstallationId); }
+    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;
@@ -163,7 +182,16 @@ export class LocalChannelBindingStore implements BindingRegistry {
     return rows.map(mapRowToBinding);
   }
 
-  async import(bindings: CreateBindingInput[]): Promise<Binding[]> {
+  async import(tenantId: string, bindings: CreateBindingInput[]): Promise<Binding[]> {
+    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: Binding[] = [];
     for (const input of bindings) {
       result.push(await this.create(input));
@@ -172,7 +200,13 @@ export class LocalChannelBindingStore implements BindingRegistry {
   }
 
   async export(params: { tenantId: string }): Promise<Binding[]> {
-    return this.list({ tenantId: params.tenantId, limit: 10000, offset: 0 });
+    return this.list({
+      tenantId: params.tenantId,
+      excludeChannels: ["room"],
+      excludeInstallationIdPrefixes: ["room-internal:"],
+      limit: 10000,
+      offset: 0,
+    });
   }
 
   private async getById(id: string): Promise<Binding | null> {

package/src/stores/LocalChannelInstallationStore.ts

@@ -7,7 +7,7 @@ import type {
   ChannelInstallationStore,
   ChannelInstallation,
   ChannelInstallationType,
-  CreateChannelInstallationRequest,
+  CreateChannelInstallationInput,
   UpdateChannelInstallationRequest,
 } from "@axiom-lattice/protocols";
 import { ensureTable, nowISO, parseISO } from "../database";
@@ -92,7 +92,7 @@ export class LocalChannelInstallationStore implements ChannelInstallationStore {
   async createInstallation(
     tenantId: string,
     installationId: string,
-    data: CreateChannelInstallationRequest,
+    data: CreateChannelInstallationInput,
   ): Promise<ChannelInstallation> {
     const now = nowISO();
 
@@ -114,7 +114,7 @@ export class LocalChannelInstallationStore implements ChannelInstallationStore {
       tenantId,
       channel: data.channel,
       name: data.name,
-      config: data.config,
+      config: { ...data.config },
       enabled: data.enabled !== false,
       fallbackAgentId: data.fallbackAgentId,
       rejectWhenNoBinding: data.rejectWhenNoBinding ?? false,
@@ -129,7 +129,7 @@ export class LocalChannelInstallationStore implements ChannelInstallationStore {
     updates: UpdateChannelInstallationRequest,
   ): Promise<ChannelInstallation | null> {
     const existing = await this.getInstallationById(installationId);
-    if (!existing) return null;
+    if (!existing || existing.tenantId !== tenantId) return null;
 
     const setClauses: string[] = [];
     const values: unknown[] = [];
@@ -145,10 +145,11 @@ export class LocalChannelInstallationStore implements ChannelInstallationStore {
     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);