@axiom-lattice/local-stores 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/local-stores",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Local SQLite-based stores for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@types/sql.js": "^1.4.11",
     "sql.js": "^1.14.1",
     "uuid": "^14.0.1",
-    "@axiom-lattice/core": "4.2.1",
-    "@axiom-lattice/protocols": "4.1.1"
+    "@axiom-lattice/core": "4.2.2",
+    "@axiom-lattice/protocols": "4.1.2"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/LocalCapabilityBundleStore.test.ts

@@ -154,8 +154,7 @@ describe("LocalCapabilityBundleStore", () => {
   });
 
   it.each(["null", "[]", "true", "7", '"config"'])(
-    "treats valid non-object project config JSON %s as having no bundle reference",
-    async (config) => {
+    "treats valid non-object project config JSON %s as having no bundle reference", async (config) => {
       await projectStore.createProject("tenant-1", "workspace", "project", { name: "Project" });
       db.prepare("UPDATE lt_projects SET config = ? WHERE tenant_id = ? AND id = ?")
         .run(config, "tenant-1", "project");

package/src/__tests__/LocalChannelBindingStore.test.ts

@@ -0,0 +1,183 @@
+import path from "path";
+import { tmpdir } from "os";
+import {
+  ChannelBindingMigrationConflictError,
+  DuplicateChannelBindingSubjectError,
+  type BindingMutablePatch,
+} from "@axiom-lattice/protocols";
+import { closeDatabase, initDatabase, type DatabaseWrapper } from "../database";
+import { LocalChannelBindingStore } from "../stores/LocalChannelBindingStore";
+import { ensureChannelBindingSubjectIndex } from "../stores/room-channel-binding-index";
+
+const dbPath = (): string => path.join(tmpdir(), `binding-${Date.now()}-${Math.random()}.db`);
+const input = (overrides: Record<string, unknown> = {}) => ({
+  channel: "room", channelInstallationId: "install-1", tenantId: "tenant-a",
+  senderId: "sender-1", agentId: "agent-1", threadId: "thread-1", ...overrides,
+});
+
+describe("LocalChannelBindingStore protected bindings", () => {
+  let db: DatabaseWrapper;
+  afterEach(() => closeDatabase());
+
+  it("preserves legacy duplicates and fails startup before creating the index", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    db.exec(`CREATE TABLE lt_channel_bindings (
+      id TEXT PRIMARY KEY, channel TEXT NOT NULL, channel_installation_id TEXT NOT NULL,
+      tenant_id TEXT NOT NULL, sender_id TEXT NOT NULL, agent_id TEXT NOT NULL, thread_id TEXT,
+      workspace_id TEXT, project_id TEXT, thread_mode TEXT NOT NULL DEFAULT 'fixed',
+      sender_display_name TEXT, sender_metadata TEXT, enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL, updated_at TEXT NOT NULL)`);
+    db.exec(`INSERT INTO lt_channel_bindings
+      (id,channel,channel_installation_id,tenant_id,sender_id,agent_id,created_at,updated_at)
+      VALUES ('b','room','install-1','tenant-a','sender-1','agent-2','2026-01-02','2026-01-02'),
+             ('a','room','install-1','tenant-a','sender-1','agent-1','2026-01-01','2026-01-01')`);
+    let migrationError: unknown;
+    try {
+      new LocalChannelBindingStore(db);
+    } catch (error) {
+      migrationError = error;
+    }
+    expect(migrationError).toBeInstanceOf(ChannelBindingMigrationConflictError);
+    expect((migrationError as ChannelBindingMigrationConflictError).conflicts).toEqual([{
+      tenantId: "tenant-a", channel: "room", channelInstallationId: "install-1",
+      senderId: "sender-1", count: 2,
+    }]);
+    const duplicates = db.prepare("SELECT id FROM lt_channel_bindings ORDER BY id").all();
+    expect(duplicates).toEqual([{ id: "a" }, { id: "b" }]);
+    const indexes = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_lt_cb_subject_unique'",
+    ).all();
+    expect(indexes).toHaveLength(0);
+  });
+
+  it("persists a disabled initial binding", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    await ensureChannelBindingSubjectIndex(db);
+    await expect(store.create(input({ enabled: false }))).resolves.toMatchObject({ enabled: false });
+  });
+
+  it("supports safe lookup, exclusion, thread persistence, and atomic duplicate create", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    for (let index = 0; index < 60; index += 1) await store.create(input({ senderId: `room-${index}` }));
+    const first = await store.create(input({ channel: "lark", senderId: "public-1" }));
+    await store.create(input({ channel: "slack", senderId: "public-2" }));
+    await store.update("tenant-a", first.id, { enabled: false });
+
+    await expect(store.findById("tenant-b", first.id)).resolves.toBeNull();
+    await expect(store.findBySubject({ ...input({ channel: "lark", senderId: "public-1" }) }))
+      .resolves.toMatchObject({ enabled: false, threadId: "thread-1" });
+    await expect(store.list({ tenantId: "tenant-a", excludeChannels: ["room"], limit: 50 }))
+      .resolves.toHaveLength(2);
+    await expect(store.export({ tenantId: "tenant-a" })).resolves.toHaveLength(2);
+    const results = await Promise.allSettled([
+      store.create(input({ senderId: "duplicate" })), store.create(input({ senderId: "duplicate" })),
+    ]);
+    expect(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
+    expect((results.find((result) => result.status === "rejected") as PromiseRejectedResult).reason)
+      .toBeInstanceOf(DuplicateChannelBindingSubjectError);
+  });
+
+  it("excludes internal installation prefixes before SQLite pagination and export", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    for (let index = 0; index < 60; index += 1) {
+      await store.create(input({
+        channel: "lark", channelInstallationId: `room-internal:project-${index}`,
+        senderId: `mixed-${index}`,
+      }));
+    }
+    await store.create(input({ channel: "lark", channelInstallationId: "public-1", senderId: "public-1" }));
+    await store.create(input({ channel: "slack", channelInstallationId: "public-2", senderId: "public-2" }));
+    await expect(store.list({
+      tenantId: "tenant-a", excludeInstallationIdPrefixes: ["room-internal:"], limit: 50,
+    })).resolves.toHaveLength(2);
+    await expect(store.export({ tenantId: "tenant-a" })).resolves.toHaveLength(2);
+  });
+
+  it.each(["room", "lark"])("atomically enforces global %s subject uniqueness", async (channel) => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    const results = await Promise.allSettled([
+      store.create(input({ channel })), store.create(input({ channel })),
+    ]);
+    expect(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
+    expect((results.find((result) => result.status === "rejected") as PromiseRejectedResult).reason)
+      .toBeInstanceOf(DuplicateChannelBindingSubjectError);
+  });
+
+  it("scopes update and delete by tenant and ignores runtime immutable fields", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    const created = await store.create(input({ channel: "lark" }));
+    await expect(store.update("tenant-b", created.id, { agentId: "agent-2" })).rejects.toThrow(/not found/i);
+    await store.update("tenant-a", created.id, {
+      agentId: "agent-2", channel: "room", tenantId: "tenant-b",
+    } as unknown as BindingMutablePatch);
+    await expect(store.findById("tenant-a", created.id)).resolves.toMatchObject({
+      channel: "lark", tenantId: "tenant-a", agentId: "agent-2",
+    });
+    await store.delete("tenant-b", created.id);
+    await expect(store.findById("tenant-a", created.id)).resolves.not.toBeNull();
+    await store.delete("tenant-a", created.id);
+    await expect(store.findById("tenant-a", created.id)).resolves.toBeNull();
+  });
+
+  it("does not rollback after commit when persistence fails", () => {
+    const saveError = new Error("disk full");
+    const exec = jest.fn();
+    const wrapper = {
+      exec,
+      prepare: jest.fn().mockReturnValue({ all: jest.fn().mockReturnValue([]) }),
+      save: jest.fn(() => { throw saveError; }),
+    } as unknown as DatabaseWrapper;
+
+    expect(() => ensureChannelBindingSubjectIndex(wrapper)).toThrow(saveError);
+    expect(exec.mock.calls.map(([sql]) => sql)).toEqual([
+      "BEGIN", "DROP INDEX IF EXISTS idx_lt_cb_room_subject",
+      expect.stringContaining("CREATE UNIQUE INDEX"),
+      expect.stringContaining("CREATE INDEX"), "COMMIT",
+    ]);
+  });
+
+  it("rolls back an uncommitted index failure and preserves the original error", () => {
+    const createError = new Error("index failure");
+    const exec = jest.fn((sql: string) => {
+      if (sql.includes("CREATE UNIQUE INDEX")) throw createError;
+    });
+    const wrapper = {
+      exec,
+      prepare: jest.fn().mockReturnValue({ all: jest.fn().mockReturnValue([]) }),
+      save: jest.fn(),
+    } as unknown as DatabaseWrapper;
+
+    expect(() => ensureChannelBindingSubjectIndex(wrapper)).toThrow(createError);
+    expect(exec).toHaveBeenLastCalledWith("ROLLBACK");
+    expect(wrapper.save).not.toHaveBeenCalled();
+  });
+
+  it("rejects room imports before the first write", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    await expect(store.import("tenant-a", [input({ channel: "lark" }), input()])).rejects.toThrow(/room/i);
+    await expect(store.list({ tenantId: "tenant-a" })).resolves.toHaveLength(0);
+  });
+
+  it("rejects internal installation imports before the first write", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    await expect(store.import("tenant-a", [input({
+      channel: "lark", channelInstallationId: "room-internal:project-1",
+    })])).rejects.toThrow(/internal/i);
+    await expect(store.list({ tenantId: "tenant-a" })).resolves.toHaveLength(0);
+  });
+
+  it("rejects cross-tenant imports before the first write", async () => {
+    db = await initDatabase({ dbPath: dbPath() });
+    const store = new LocalChannelBindingStore(db);
+    await expect(store.import("tenant-a", [input({ channel: "lark", tenantId: "tenant-b" })]))
+      .rejects.toThrow(/tenant mismatch/i);
+    await expect(store.list({ tenantId: "tenant-b" })).resolves.toHaveLength(0);
+  });
+});

package/src/__tests__/LocalChannelInstallationStore.test.ts

@@ -19,6 +19,16 @@ describe("LocalChannelInstallationStore", () => {
     closeDatabase();
   });
 
+  it("persists room installations with a plain record config", async () => {
+    await expect(store.createInstallation("tenant-a", "room-install", {
+      channel: "room",
+      config: {},
+    })).resolves.toMatchObject({
+      channel: "room",
+      config: {},
+    });
+  });
+
   it("rejects a duplicate id without changing the original installation", async () => {
     const original = await store.createInstallation("tenant-a", "install-1", {
       channel: "lark",
@@ -35,4 +45,17 @@ describe("LocalChannelInstallationStore", () => {
     ).rejects.toThrow();
     await expect(store.getInstallationById("install-1")).resolves.toEqual(original);
   });
+
+  it("does not update an installation owned by another tenant", async () => {
+    const original = await store.createInstallation("tenant-a", "install-1", {
+      channel: "lark",
+      name: "Original",
+      config: { appId: "app-1", appSecret: "secret-1" },
+    });
+
+    await expect(store.updateInstallation("tenant-b", "install-1", {
+      name: "Cross-tenant update",
+    })).resolves.toBeNull();
+    await expect(store.getInstallationById("install-1")).resolves.toEqual(original);
+  });
 });

package/src/__tests__/LocalProjectRoomStores.test.ts

@@ -0,0 +1,356 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { existsSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import path from "path";
+import { closeDatabase, initDatabase } from "../database";
+import {
+  DuplicateProjectMembershipError,
+  ProjectMembershipIdConflictError,
+  LocalProjectMembershipStore,
+} from "../stores/LocalProjectMembershipStore";
+import {
+  LocalProjectBotMembershipStore,
+  ProjectBotMembershipIdConflictError,
+} from "../stores/LocalProjectBotMembershipStore";
+import {
+  DuplicateProjectRoomMessageIdempotencyKeyError,
+  LocalProjectRoomMessageStore,
+  ProjectRoomMessageIdConflictError,
+} from "../stores/LocalProjectRoomMessageStore";
+import { LocalProjectRoomStore } from "../stores/LocalProjectRoomStore";
+import type { DatabaseWrapper } from "../database";
+import { transaction, write } from "../stores/project-room-schema";
+
+const nextDbPath = (): string => path.join(tmpdir(), `lt-project-room-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+const storesFor = (db: DatabaseWrapper) => ({
+  rooms: new LocalProjectRoomStore(db),
+  memberships: new LocalProjectMembershipStore(db),
+  bots: new LocalProjectBotMembershipStore(db),
+  messages: new LocalProjectRoomMessageStore(db),
+});
+
+describe("local project room stores", () => {
+  let dbPath: string;
+
+  beforeEach(() => { dbPath = nextDbPath(); });
+  afterEach(() => {
+    closeDatabase();
+    if (existsSync(dbPath)) unlinkSync(dbPath);
+  });
+
+  it("shares one versioned schema and persists a canonical main room across reopen", async () => {
+    const db = await initDatabase({ dbPath });
+    const save = jest.spyOn(db, "save");
+    const { rooms } = storesFor(db);
+    expect(save).toHaveBeenCalledTimes(1);
+    const first = await rooms.ensureMainRoom({ id: "room-1", tenantId: "t1", workspaceId: "w1", projectId: "p1", name: "Main" });
+    const canonical = await rooms.ensureMainRoom({ id: "other", tenantId: "t1", workspaceId: "w2", projectId: "p1", name: "Ignored" });
+    expect(canonical).toEqual(first);
+    expect(db.prepare("SELECT COUNT(*) AS count FROM lattice_schema_migrations WHERE store_name = ?").get("project_room")).toEqual({ count: 1 });
+
+    closeDatabase();
+    const reopened = storesFor(await initDatabase({ dbPath }));
+    expect(await reopened.rooms.getMainRoom("t1", "p1")).toEqual(first);
+  });
+
+  it("rejects an incompatible preexisting table without recording or partially applying the migration", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec("CREATE TABLE lt_project_rooms (id TEXT NOT NULL)");
+
+    expect(() => new LocalProjectRoomStore(db)).toThrow(/Invalid project room schema.*lt_project_rooms/);
+    expect(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lt_project_memberships'").get()).toBeUndefined();
+    expect(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lattice_schema_migrations'").get()).toBeUndefined();
+    expect(db.prepare("PRAGMA table_info(lt_project_rooms)").all()).toHaveLength(1);
+  });
+
+  it("rejects a structurally valid project room table missing its required check", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec(`CREATE TABLE 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, "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")
+    )`);
+
+    expect(() => new LocalProjectRoomStore(db)).toThrow("Invalid project room schema: table 'lt_project_rooms' is missing required CHECK constraint 'type'");
+    expect(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lt_project_memberships'").get()).toBeUndefined();
+    expect(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'lattice_schema_migrations'").get()).toBeUndefined();
+    expect(db.prepare("PRAGMA table_info(lt_project_rooms)").all()).toHaveLength(8);
+  });
+
+  it("rejects a broadened project room type check", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec(`CREATE TABLE 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' OR type = 'other'),
+      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)
+    )`);
+
+    expect(() => new LocalProjectRoomStore(db)).toThrow("Invalid project room schema: table 'lt_project_rooms' is missing required CHECK constraint 'type'");
+  });
+
+  it("rejects a broadened project membership role check", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec(`CREATE TABLE 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') OR 1 = 1),
+      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)
+    )`);
+
+    expect(() => new LocalProjectMembershipStore(db)).toThrow("Invalid project room schema: table 'lt_project_memberships' is missing required CHECK constraint 'role'");
+  });
+
+  it("accepts valid checks with quoted identifiers and parenthesized formatting", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec(`CREATE TABLE 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"),
+      CHECK ('value) with ''quote' = 'value) with ''quote')
+    )`);
+
+    expect(() => new LocalProjectRoomStore(db)).not.toThrow();
+  });
+
+  it("validates an existing migration marker before accepting the schema", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec("CREATE TABLE 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)); CREATE TABLE lt_project_rooms (id TEXT NOT NULL)");
+    db.getRawDb().run("INSERT INTO lattice_schema_migrations VALUES (?, ?, ?, ?)", ["project_room", "create_project_room_tables", 1, new Date().toISOString()]);
+
+    expect(() => new LocalProjectRoomStore(db)).toThrow(/Invalid project room schema.*lt_project_rooms/);
+  });
+
+  it("rejects nested transactions without rolling back the outer transaction", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec("CREATE TABLE transaction_probe (value TEXT NOT NULL)");
+
+    transaction(db, () => {
+      expect(() => transaction(db, () => undefined)).toThrow("Nested local store transactions are not supported");
+      write(db, "INSERT INTO transaction_probe (value) VALUES (?)", ["committed"]);
+    });
+
+    expect(db.prepare("SELECT value FROM transaction_probe").all()).toEqual([{ value: "committed" }]);
+  });
+
+  it("rolls back the outer transaction when a nested transaction error escapes", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec("CREATE TABLE transaction_probe (value TEXT NOT NULL)");
+
+    expect(() => transaction(db, () => {
+      write(db, "INSERT INTO transaction_probe (value) VALUES (?)", ["rolled-back"]);
+      transaction(db, () => undefined);
+    })).toThrow("Nested local store transactions are not supported");
+
+    expect(db.prepare("SELECT value FROM transaction_probe").all()).toEqual([]);
+  });
+
+  it("clears the transaction guard when beginning a transaction fails", async () => {
+    const db = await initDatabase({ dbPath });
+    db.exec("CREATE TABLE transaction_probe (value TEXT NOT NULL)");
+    const originalExec = db.exec.bind(db);
+    jest.spyOn(db, "exec").mockImplementationOnce(() => { throw new Error("begin failed"); }).mockImplementation(originalExec);
+
+    expect(() => transaction(db, () => undefined)).toThrow("begin failed");
+    transaction(db, () => write(db, "INSERT INTO transaction_probe (value) VALUES (?)", ["recovered"]));
+
+    expect(db.prepare("SELECT value FROM transaction_probe").all()).toEqual([{ value: "recovered" }]);
+  });
+
+  it("enforces deterministic human membership errors, initial owner, final owner, and CAS", async () => {
+    const store = new LocalProjectMembershipStore(await initDatabase({ dbPath }));
+    const owner = await store.createInitialOwner({ id: "m1", tenantId: "t1", projectId: "p1", userId: "u1" });
+    expect(owner.kind).toBe("created");
+    expect((await store.createInitialOwner({ id: "ignored", tenantId: "t1", projectId: "p1", userId: "u1" })).kind).toBe("existing");
+    expect((await store.createInitialOwner({ id: "m2", tenantId: "t1", projectId: "p1", userId: "u2" })).kind).toBe("already_initialized");
+    const membership = owner.kind === "created" ? owner.membership : (() => { throw new Error("expected owner"); })();
+    expect(await store.remove({ tenantId: "t1", id: "m1", expectedUpdatedAt: membership.updatedAt })).toEqual({ kind: "last_owner" });
+
+    const second = await store.create({ id: "m2", tenantId: "t1", projectId: "p1", userId: "u2", role: "owner", status: "active" });
+    await expect(store.create({ id: "m3", tenantId: "t1", projectId: "p1", userId: "u2", role: "member", status: "active" })).rejects.toBeInstanceOf(DuplicateProjectMembershipError);
+    await expect(store.create({ id: "m2", tenantId: "t1", projectId: "p2", userId: "u3", role: "member", status: "active" })).rejects.toBeInstanceOf(ProjectMembershipIdConflictError);
+    expect(await store.updateRole({ tenantId: "t1", id: "m2", role: "admin", expectedUpdatedAt: new Date(0) })).toEqual({ kind: "conflict" });
+    expect(await store.remove({ tenantId: "t1", id: "m1", expectedUpdatedAt: membership.updatedAt })).toMatchObject({ kind: "removed", membership: { status: "removed" } });
+    expect((await store.findByUser("t1", "p1", "u1"))?.status).toBe("removed");
+    expect((await store.list("t1", "p1")).map((item) => item.id)).toEqual(["m1", "m2"]);
+    expect(second.updatedAt).toBeInstanceOf(Date);
+  });
+
+  it("classifies a human membership ID collision that occurs after preflight", async () => {
+    const db = await initDatabase({ dbPath });
+    const store = new LocalProjectMembershipStore(db);
+    const raw = db.getRawDb();
+    const originalRun = raw.run.bind(raw);
+    let injected = false;
+    jest.spyOn(raw, "run").mockImplementation((sql, params) => {
+      if (!injected && typeof sql === "string" && sql.startsWith("INSERT INTO lt_project_memberships")) {
+        injected = true;
+        originalRun("INSERT INTO lt_project_memberships VALUES (?, ?, ?, ?, ?, ?, ?, ?)", ["race-id", "t1", "other", "other-user", "member", "active", new Date().toISOString(), new Date().toISOString()]);
+      }
+      return originalRun(sql, params);
+    });
+
+    await expect(store.create({ id: "race-id", tenantId: "t1", projectId: "p1", userId: "u1", role: "member", status: "active" })).rejects.toBeInstanceOf(ProjectMembershipIdConflictError);
+  });
+
+  it("reactivates durable bot membership and preserves identity while enforcing active and paused uniqueness", async () => {
+    const store = new LocalProjectBotMembershipStore(await initDatabase({ dbPath }));
+    const base = { id: "b1", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", assistantId: "a1", role: "coordinator" as const, title: "Lead", mentionName: "lead", status: "active" as const, roomThreadId: "th1" };
+    const saved = await store.save(base);
+    expect(saved.kind).toBe("created");
+    if (saved.kind !== "created") throw new Error("expected saved membership");
+    expect((await store.save({ ...base, id: "b2", assistantId: "a2", mentionName: "other", roomThreadId: "th2" })).kind).toBe("coordinator_conflict");
+    const paused = await store.update({ tenantId: "t1", id: "b1", patch: { status: "paused" }, expectedUpdatedAt: saved.membership.updatedAt });
+    expect(paused.kind).toBe("updated");
+    expect((await store.save({ ...base, id: "b3", assistantId: "a3", role: "specialist", roomThreadId: "th3" })).kind).toBe("mention_conflict");
+    if (paused.kind !== "updated") throw new Error("expected update");
+    const removed = await store.update({ tenantId: "t1", id: "b1", patch: { status: "removed" }, expectedUpdatedAt: paused.membership.updatedAt });
+    if (removed.kind !== "updated") throw new Error("expected removal");
+    const reactivated = await store.save({ ...base, id: "replacement", roomThreadId: "replacement-thread", title: "Lead again" });
+    expect(reactivated.kind).toBe("reactivated");
+    if (reactivated.kind !== "reactivated") throw new Error("expected reactivation");
+    expect(reactivated.membership).toMatchObject({ id: "b1", roomThreadId: "th1", title: "Lead again", status: "active" });
+    expect(reactivated.membership.joinedAt).toEqual(saved.membership.joinedAt);
+    expect(reactivated.membership.updatedAt.getTime()).toBeGreaterThan(removed.membership.updatedAt.getTime());
+    await expect(store.save({ ...base, id: "b1", projectId: "p2", assistantId: "a9" })).rejects.toBeInstanceOf(ProjectBotMembershipIdConflictError);
+  });
+
+  it("persists a new bot's requested status and applies uniqueness only to active and paused rows", async () => {
+    const store = new LocalProjectBotMembershipStore(await initDatabase({ dbPath }));
+    const base = { tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", role: "coordinator" as const, title: "Lead", mentionName: "lead", roomThreadId: "thread" };
+    const paused = await store.save({ ...base, id: "paused", assistantId: "a1", status: "paused" });
+    expect(paused.kind).toBe("created");
+    if (paused.kind !== "created") throw new Error("expected paused membership");
+    expect(paused.membership.status).toBe("paused");
+    expect((await store.save({ ...base, id: "blocked", assistantId: "a2", mentionName: "other", status: "active" })).kind).toBe("coordinator_conflict");
+
+    const removed = await store.save({ ...base, id: "removed", projectId: "p2", assistantId: "a3", status: "removed" });
+    expect(removed.kind).toBe("created");
+    if (removed.kind !== "created") throw new Error("expected removed membership");
+    expect(removed.membership.status).toBe("removed");
+    expect((await store.save({ ...base, id: "available", projectId: "p2", roomId: "r2", assistantId: "a4", status: "active" })).kind).toBe("created");
+  });
+
+  it("returns coordinator conflict first when a bot candidate also conflicts on mention", async () => {
+    const store = new LocalProjectBotMembershipStore(await initDatabase({ dbPath }));
+    const base = { tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", title: "Bot", status: "active" as const };
+    await store.save({ ...base, id: "coordinator", assistantId: "a1", role: "coordinator", mentionName: "lead", roomThreadId: "th1" });
+    await store.save({ ...base, id: "mention", assistantId: "a2", role: "specialist", mentionName: "taken", roomThreadId: "th2" });
+
+    expect((await store.save({ ...base, id: "candidate", assistantId: "a3", role: "coordinator", mentionName: "taken", roomThreadId: "th3" })).kind).toBe("coordinator_conflict");
+    const removed = await store.save({ ...base, id: "reactivate", assistantId: "a4", role: "specialist", mentionName: "free", status: "removed", roomThreadId: "th4" });
+    if (removed.kind !== "created") throw new Error("expected removed membership");
+    expect((await store.save({ ...base, id: "ignored", assistantId: "a4", role: "coordinator", mentionName: "taken", roomThreadId: "ignored" })).kind).toBe("coordinator_conflict");
+    const updateCandidate = await store.save({ ...base, id: "update", assistantId: "a5", role: "specialist", mentionName: "update-free", status: "removed", roomThreadId: "th5" });
+    if (updateCandidate.kind !== "created") throw new Error("expected update candidate");
+    expect((await store.update({ tenantId: "t1", id: "update", patch: { role: "coordinator", mentionName: "taken", status: "active" }, expectedUpdatedAt: updateCandidate.membership.updatedAt })).kind).toBe("coordinator_conflict");
+  });
+
+  it("classifies a bot membership ID collision that occurs after preflight", async () => {
+    const db = await initDatabase({ dbPath });
+    const store = new LocalProjectBotMembershipStore(db);
+    const raw = db.getRawDb();
+    const originalRun = raw.run.bind(raw);
+    let injected = false;
+    jest.spyOn(raw, "run").mockImplementation((sql, params) => {
+      if (!injected && typeof sql === "string" && sql.startsWith("INSERT INTO lt_project_bot_memberships")) {
+        injected = true;
+        const now = new Date().toISOString();
+        originalRun("INSERT INTO lt_project_bot_memberships VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", ["race-id", "t1", "w1", "other", "other-room", "other-assistant", "specialist", "Other", null, "other", "removed", "other-thread", now, now]);
+      }
+      return originalRun(sql, params);
+    });
+
+    await expect(store.save({ id: "race-id", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", assistantId: "a1", role: "specialist", title: "Bot", mentionName: "bot", status: "active", roomThreadId: "thread" })).rejects.toBeInstanceOf(ProjectBotMembershipIdConflictError);
+  });
+
+  it("reopens human memberships with dates and preserves final-owner and CAS behavior", async () => {
+    const initial = storesFor(await initDatabase({ dbPath }));
+    const owner = await initial.memberships.createInitialOwner({ id: "owner", tenantId: "t1", projectId: "p1", userId: "u1" });
+    if (owner.kind !== "created") throw new Error("expected owner");
+    const admin = await initial.memberships.create({ id: "admin", tenantId: "t1", projectId: "p1", userId: "u2", role: "admin", status: "active" });
+    closeDatabase();
+
+    const reopened = storesFor(await initDatabase({ dbPath }));
+    const persisted = await reopened.memberships.list("t1", "p1");
+    const expected = [owner.membership, admin].sort((left, right) => left.joinedAt.getTime() - right.joinedAt.getTime() || left.id.localeCompare(right.id));
+    expect(persisted).toEqual(expected);
+    expect(persisted[0].joinedAt).toBeInstanceOf(Date);
+    expect(await reopened.memberships.remove({ tenantId: "t1", id: "owner", expectedUpdatedAt: new Date(0) })).toEqual({ kind: "conflict" });
+    expect(await reopened.memberships.remove({ tenantId: "t1", id: "owner", expectedUpdatedAt: owner.membership.updatedAt })).toEqual({ kind: "last_owner" });
+    expect(await reopened.memberships.updateRole({ tenantId: "t1", id: "admin", role: "owner", expectedUpdatedAt: admin.updatedAt })).toMatchObject({ kind: "updated", membership: { role: "owner" } });
+    expect(await reopened.memberships.remove({ tenantId: "t1", id: "owner", expectedUpdatedAt: owner.membership.updatedAt })).toMatchObject({ kind: "removed", membership: { status: "removed" } });
+  });
+
+  it("reopens bot roster state and reactivates while preserving durable identity", async () => {
+    const initial = storesFor(await initDatabase({ dbPath }));
+    const saved = await initial.bots.save({ id: "bot", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", assistantId: "a1", role: "specialist", title: "Research", responsibility: "Deep work", mentionName: "research", status: "removed", roomThreadId: "thread-1" });
+    if (saved.kind !== "created") throw new Error("expected saved bot");
+    closeDatabase();
+
+    const reopened = storesFor(await initDatabase({ dbPath }));
+    const persisted = await reopened.bots.findById("t1", "bot");
+    expect(persisted).toEqual(saved.membership);
+    expect(persisted?.joinedAt).toBeInstanceOf(Date);
+    const reactivated = await reopened.bots.save({ id: "replacement", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", assistantId: "a1", role: "specialist", title: "Research again", mentionName: "research", status: "paused", roomThreadId: "replacement-thread" });
+    expect(reactivated.kind).toBe("reactivated");
+    if (reactivated.kind !== "reactivated") throw new Error("expected reactivated bot");
+    expect(reactivated.membership).toMatchObject({ id: "bot", status: "active", roomThreadId: "thread-1", joinedAt: saved.membership.joinedAt });
+  });
+
+  it("reopens nested room messages with dates, cursor ordering, and canonical idempotency", async () => {
+    const initial = storesFor(await initDatabase({ dbPath }));
+    const first = await initial.messages.createIdempotent({ id: "m1", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", author: { type: "bot", membershipId: "bot", assistantId: "a1" }, content: { type: "text", text: "nested" }, mentions: [{ type: "bot", membershipId: "other" }, { type: "team" }], replyToMessageId: "parent", source: "task", sourceId: "task-1", idempotencyKey: "durable-key" });
+    const second = await initial.messages.create({ id: "m2", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", author: { type: "system" }, content: { type: "text", text: "second" }, mentions: [], source: "system" });
+    closeDatabase();
+
+    const reopened = storesFor(await initDatabase({ dbPath }));
+    expect(await reopened.messages.findById("t1", "m1")).toEqual(first);
+    expect((await reopened.messages.findById("t1", "m1"))?.createdAt).toBeInstanceOf(Date);
+    expect(await reopened.messages.createIdempotent({ id: "ignored", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", author: { type: "system" }, content: { type: "text", text: "ignored" }, mentions: [], source: "system", idempotencyKey: "durable-key" })).toEqual(first);
+    const page = await reopened.messages.list({ tenantId: "t1", roomId: "r1", limit: 2 });
+    expect(page).toEqual([second, first]);
+    expect(await reopened.messages.list({ tenantId: "t1", roomId: "r1", before: { createdAt: second.createdAt, id: second.id }, limit: 10 })).toEqual([first]);
+  });
+
+  it("round-trips cloned message JSON, maps uniqueness, idempotency, and exact descending cursors", async () => {
+    const store = new LocalProjectRoomMessageStore(await initDatabase({ dbPath }));
+    const message = { id: "m1", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", author: { type: "human" as const, userId: "u1" }, content: { type: "text" as const, text: "hello" }, mentions: [{ type: "team" as const }], source: "user" as const, idempotencyKey: "key-1" };
+    const first = await store.createIdempotent(message);
+    message.content.text = "mutated";
+    message.mentions.length = 0;
+    const canonical = await store.createIdempotent({ ...message, id: "m2" });
+    expect(canonical).toEqual(first);
+    expect(canonical.content.text).toBe("hello");
+    expect(canonical.mentions).toEqual([{ type: "team" }]);
+    await expect(store.create({ ...message, id: "m1", idempotencyKey: undefined })).rejects.toBeInstanceOf(ProjectRoomMessageIdConflictError);
+    await expect(store.create({ ...message, id: "m3", idempotencyKey: "key-1" })).rejects.toBeInstanceOf(DuplicateProjectRoomMessageIdempotencyKeyError);
+
+    await store.create({ ...message, id: "z", idempotencyKey: undefined });
+    await store.create({ ...message, id: "a", idempotencyKey: undefined });
+    const page = await store.list({ tenantId: "t1", roomId: "r1", limit: 1000 });
+    expect(page).toHaveLength(3);
+    expect(await store.list({ tenantId: "t1", roomId: "r1", before: { createdAt: page[1].createdAt, id: page[1].id }, limit: 0 })).toEqual([page[2]]);
+    await expect(store.list({ tenantId: "t1", roomId: "r1", before: { createdAt: new Date("invalid"), id: "x" }, limit: 1 })).rejects.toBeInstanceOf(RangeError);
+  });
+
+  it("classifies a room message ID collision that occurs after preflight", async () => {
+    const db = await initDatabase({ dbPath });
+    const store = new LocalProjectRoomMessageStore(db);
+    const raw = db.getRawDb();
+    const originalRun = raw.run.bind(raw);
+    let injected = false;
+    jest.spyOn(raw, "run").mockImplementation((sql, params) => {
+      if (!injected && typeof sql === "string" && sql.startsWith("INSERT INTO lt_project_room_messages")) {
+        injected = true;
+        originalRun("INSERT INTO lt_project_room_messages VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", ["race-id", "t1", "w1", "other", "other-room", '{"type":"system"}', '{"type":"text","text":"other"}', "[]", null, "system", null, null, new Date().toISOString()]);
+      }
+      return originalRun(sql, params);
+    });
+
+    await expect(store.create({ id: "race-id", tenantId: "t1", workspaceId: "w1", projectId: "p1", roomId: "r1", author: { type: "system" }, content: { type: "text", text: "message" }, mentions: [], source: "system" })).rejects.toBeInstanceOf(ProjectRoomMessageIdConflictError);
+  });
+});