@axiom-lattice/local-stores 3.1.0 → 3.1.2

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);
+  });
+});

package/src/__tests__/LocalProjectStore.test.ts

@@ -6,7 +6,7 @@
  * getProjectsByWorkspace supports an optional kind filter.
  */
 
-import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
+import { describe, expect, it, beforeEach, afterEach, jest } from "@jest/globals";
 import { tmpdir } from "os";
 import path from "path";
 import { initDatabase, closeDatabase } from "../database";
@@ -19,11 +19,12 @@ const nextDbPath = () =>
 
 describe("LocalProjectStore project kind", () => {
   let store: LocalProjectStore;
+  let db: Awaited<ReturnType<typeof initDatabase>>;
   const tenantId = "t1";
   const workspaceId = "ws1";
 
   beforeEach(async () => {
-    const db = await initDatabase({ dbPath: nextDbPath() });
+    db = await initDatabase({ dbPath: nextDbPath() });
     store = new LocalProjectStore(db);
   });
 
@@ -81,6 +82,42 @@ describe("LocalProjectStore project kind", () => {
     expect(all).toHaveLength(2);
   });
 
+  it("preserves capability bundle IDs during generic config replacement", async () => {
+    await store.createProject(tenantId, workspaceId, "reserved", { name: "Reserved", config: { keep: true } });
+    db.exec("UPDATE lt_projects SET config = '{\"keep\":true,\"capabilityBundleIds\":[\"bundle-1\"]}' WHERE tenant_id = 't1' AND id = 'reserved'");
+
+    const updated = await store.updateProject(tenantId, "reserved", { config: { replacement: true } });
+
+    expect(updated?.config).toEqual({ replacement: true, capabilityBundleIds: ["bundle-1"] });
+  });
+
+  it("preserves an assignment made between the generic read and write", async () => {
+    await store.createProject(tenantId, workspaceId, "interleaved", {
+      name: "Interleaved",
+      config: { keep: true },
+    });
+    const originalPrepare = db.prepare.bind(db);
+    let injected = false;
+    jest.spyOn(db, "prepare").mockImplementation((sql) => {
+      if (!injected && sql.startsWith("UPDATE lt_projects SET config =")) {
+        injected = true;
+        originalPrepare(
+          "UPDATE lt_projects SET config = json_set(COALESCE(config, '{}'), '$.capabilityBundleIds', json(?)) WHERE tenant_id = ? AND id = ?",
+        ).run('["bundle-latest"]', tenantId, "interleaved");
+      }
+      return originalPrepare(sql);
+    });
+
+    const updated = await store.updateProject(tenantId, "interleaved", {
+      config: { replacement: true },
+    });
+
+    expect(updated?.config).toEqual({
+      replacement: true,
+      capabilityBundleIds: ["bundle-latest"],
+    });
+  });
+
   describe("multiple training projects per tenant/workspace", () => {
     it("allows multiple training projects in the same tenant/workspace", async () => {
       await store.createProject(tenantId, workspaceId, "t1", {

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",