@axiom-lattice/local-stores 3.1.0 → 3.1.2

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(),
@@ -212,4 +240,175 @@ describe("LocalTaskWorkItemStore", () => {
       unlinkSync(dbPath);
     }
   });
+
+  it("queries bounded newest pending execution results with scope and reconciliation filtering", async () => {
+    const dbPath = path.join(
+      tmpdir(),
+      `lt-task-work-item-pending-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`,
+    );
+    try {
+      const db = await initDatabase({ dbPath });
+      const store = new LocalTaskWorkItemStore(db);
+      const pending = await Promise.all(["a", "b", "c"].map((suffix) => store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-1", eventKey: `execution-result:${suffix}`,
+        action: "execution_result", actor: "agent:worker",
+      })));
+      await store.create({
+        tenantId: "tenant-1", taskId: "task-1", action: "execution_result", actor: "agent:worker",
+      });
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-1", eventKey: "   ",
+        action: "execution_result", actor: "agent:worker",
+      });
+      for (const eventKey of [
+        "\t", "\n", "wrong-prefix:value", "execution-result:",
+        " execution-result:value", "execution-result: value", "execution-result:value\t",
+        "execution-result:non-breaking\u00a0space", "execution-result:next-line\u0085",
+        "execution-result:em-space\u2003", "execution-result:invalid/punctuation",
+      ]) {
+        await store.createIfAbsentByEventKey({
+          tenantId: "tenant-1", taskId: "task-1", eventKey,
+          action: "execution_result", actor: "agent:worker",
+        });
+      }
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-2", eventKey: "execution-result:other-task",
+        action: "execution_result", actor: "agent:worker",
+      });
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-2", taskId: "task-1", eventKey: "execution-result:other-tenant",
+        action: "execution_result", actor: "agent:worker",
+      });
+      await store.createIfAbsentByEventKey({
+        tenantId: "tenant-1", taskId: "task-1",
+        eventKey: "execution-reconciled:execution-result:b", action: "execution_reconciled",
+        actor: "agent:owner", detail: { executionResultId: "execution-result:b" },
+      });
+      db.prepare("UPDATE lt_task_work_items SET created_at = ? WHERE action = ?")
+        .run("2026-01-01T00:00:00.000Z", "execution_result");
+
+      const result = await store.listPendingExecutionResults({
+        tenantId: "tenant-1", taskId: "task-1", limit: 2,
+      });
+      const expectedIds = pending
+        .filter((item) => item.eventKey !== "execution-result:b")
+        .map((item) => item.id)
+        .sort((left, right) => right.localeCompare(left))
+        .slice(0, 2);
+
+      expect(result.map((item) => item.id)).toEqual(expectedIds);
+    } finally {
+      closeDatabase();
+      unlinkSync(dbPath);
+    }
+  });
+
+  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) => {
+      const db = {
+        exec: jest.fn(), prepare: jest.fn().mockReturnValue({ all: jest.fn().mockReturnValue([]) }),
+      } as unknown as DatabaseWrapper;
+      const store = new LocalTaskWorkItemStore(db);
+      (db.prepare as jest.Mock).mockClear();
+
+      await expect(store.listPendingExecutionResults({
+        tenantId: "tenant-1", taskId: "task-1", limit,
+      })).rejects.toMatchObject({ name: "RangeError", code: "INVALID_LIMIT" });
+      expect(db.prepare).not.toHaveBeenCalled();
+    },
+  );
+
+  it("returns no pending execution results for limit zero without querying", async () => {
+    const db = {
+      exec: jest.fn(), prepare: jest.fn().mockReturnValue({ all: jest.fn().mockReturnValue([]) }),
+    } as unknown as DatabaseWrapper;
+    const store = new LocalTaskWorkItemStore(db);
+    (db.prepare as jest.Mock).mockClear();
+
+    await expect(store.listPendingExecutionResults({
+      tenantId: "tenant-1", taskId: "task-1", limit: 0,
+    })).resolves.toEqual([]);
+    expect(db.prepare).not.toHaveBeenCalled();
+  });
+
+  it("creates indexes supporting ordered pending and reconciliation lookups", () => {
+    const exec = jest.fn();
+    const db = {
+      exec, prepare: jest.fn().mockReturnValue({ all: jest.fn().mockReturnValue([]) }),
+    } as unknown as DatabaseWrapper;
+
+    new LocalTaskWorkItemStore(db);
+
+    expect(exec).toHaveBeenCalledWith(expect.stringContaining(
+      "(tenant_id, task_id, action, created_at DESC, id DESC)",
+    ));
+    expect(exec).toHaveBeenCalledWith(expect.stringMatching(
+      /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

@@ -0,0 +1,201 @@
+import { afterEach, beforeEach, describe, expect, it } from "@jest/globals";
+import path from "path";
+import { tmpdir } from "os";
+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 () => {
+    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());
+
+  it("keeps projectless reads and mutations isolated from a project sharing the thread", async () => {
+    const base = { threadId: "shared", tenantId: "tenant", assistantId: "assistant", workspaceId: "workspace" };
+    const projectless = await store.addMessage({ ...base, content: "projectless" });
+    const projected = await store.addMessage({ ...base, projectId: "project", content: "project" });
+    const scope = { tenantId: "tenant", assistantId: "assistant", workspaceId: "workspace", projectId: undefined };
+
+    expect((await store.getPendingMessages("shared", scope)).map((message) => message.id)).toEqual([projectless.id]);
+    expect(await store.getQueueSize("shared", scope)).toBe(1);
+    await store.markProcessing(projectless.id, undefined, scope);
+    expect((await store.getProcessingMessages("shared", scope)).map((message) => message.id)).toEqual([projectless.id]);
+    expect(await store.resetProcessingToPending("shared", scope)).toBe(1);
+    expect(await store.removeMessage(projected.id, scope)).toBe(false);
+    await store.clearMessages("shared", scope);
+    expect((await store.getPendingMessages("shared")).map((message) => message.id)).toEqual([projected.id]);
+  });
+
+  it("preserves nullable scope identity when discovering persisted unscoped rows", async () => {
+    const message = await store.addMessage({
+      threadId: "legacy",
+      tenantId: "tenant",
+      assistantId: "assistant",
+      content: "legacy",
+    });
+
+    const scope = { tenantId: "tenant", assistantId: "assistant", workspaceId: null, projectId: null };
+    expect(await store.getThreadsWithPendingMessages()).toEqual([{
+      tenantId: "tenant",
+      assistantId: "assistant",
+      threadId: "legacy",
+      workspaceId: null,
+      projectId: null,
+    }]);
+    expect(await store.getPendingMessages("legacy", scope)).toHaveLength(1);
+    await store.markProcessing(message.id, undefined, scope);
+    expect(await store.getProcessingMessages("legacy", scope)).toHaveLength(1);
+    expect(await store.removeMessage(message.id, scope)).toBe(true);
+    expect(await store.getProcessingMessages("legacy", scope)).toHaveLength(0);
+  });
+
+  it("atomically accepts no more than the bounded number of messages", async () => {
+    const params = {
+      threadId: "bounded",
+      tenantId: "tenant",
+      assistantId: "assistant",
+      workspaceId: null,
+      projectId: null,
+      content: "message",
+    };
+
+    const accepted = await Promise.all(
+      Array.from({ length: 5 }, (_, index) => store.addMessageIfCapacity({ ...params, id: `msg-${index}` }, 2)),
+    );
+
+    expect(accepted.filter(Boolean)).toHaveLength(2);
+    expect(await store.getQueueSize("bounded", {
+      tenantId: "tenant",
+      assistantId: "assistant",
+      workspaceId: null,
+      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";
@@ -37,6 +41,7 @@ import { LocalSkillStore } from "./stores/LocalSkillStore";
 import { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
 import { LocalTaskStore } from "./stores/LocalTaskStore";
 import { LocalTaskWorkItemStore } from "./stores/LocalTaskWorkItemStore";
+import { LocalCapabilityBundleStore } from "./stores/LocalCapabilityBundleStore";
 
 export interface LocalStoreConfigOptions {
   /**
@@ -65,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),
@@ -82,6 +91,7 @@ export async function createLocalStoreConfig(options: LocalStoreConfigOptions =
     schedule: new LocalScheduleStorage(db),
     task: new LocalTaskStore(db),
     taskWorkItem: new LocalTaskWorkItemStore(db),
+    capabilityBundle: new LocalCapabilityBundleStore(db),
     checkpoint: SqliteSaver.fromConnString(dbPath),
   };
 }

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";
@@ -48,4 +52,5 @@ export { LocalSkillStore } from "./stores/LocalSkillStore";
 export { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
 export { LocalTaskStore } from "./stores/LocalTaskStore";
 export { LocalTaskWorkItemStore } from "./stores/LocalTaskWorkItemStore";
+export { LocalCapabilityBundleStore } from "./stores/LocalCapabilityBundleStore";
 export { InMemoryConversationStore } from "./stores/InMemoryConversationStore";

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/LocalCapabilityBundleStore.ts

@@ -0,0 +1,53 @@
+import { randomUUID } from "crypto";
+import type { CapabilityBundle, CapabilityBundleDeleteResult, CapabilityBundleStore, InternalCreateCapabilityBundleInput, InternalUpdateCapabilityBundleInput } from "@axiom-lattice/protocols";
+import { DatabaseWrapper, ensureTable, nowISO, parseISO } from "../database";
+
+const DDL = `CREATE TABLE IF NOT EXISTS lt_capability_bundles (id TEXT NOT NULL, tenant_id TEXT NOT NULL, bundle_key TEXT NOT NULL, name TEXT NOT NULL, description TEXT, capabilities TEXT NOT NULL DEFAULT '[]', created_at TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY (tenant_id, id), UNIQUE (tenant_id, bundle_key)); CREATE INDEX IF NOT EXISTS idx_lt_capability_bundles_tenant ON lt_capability_bundles(tenant_id);`;
+type Row = { id: string; tenant_id: string; bundle_key: string; name: string; description: string | null; capabilities: string; created_at: string; updated_at: string };
+const duplicateMessage = "Capability bundle key already exists for tenant";
+function map(row: Row): CapabilityBundle { return { id: row.id, tenantId: row.tenant_id, key: row.bundle_key, name: row.name, description: row.description ?? undefined, capabilities: JSON.parse(row.capabilities), createdAt: parseISO(row.created_at).toISOString(), updatedAt: parseISO(row.updated_at).toISOString() }; }
+function isConstraint(error: unknown): boolean { return error instanceof Error && /UNIQUE constraint failed/.test(error.message); }
+function nextTimestamp(previous?: string): string { const now = Date.now(); const previousTime = previous ? Date.parse(previous) : Number.NaN; return new Date(Math.max(now, Number.isFinite(previousTime) ? previousTime + 1 : now)).toISOString(); }
+
+/**
+ * Persists tenant-scoped capability bundles in a shared local sql.js database.
+ *
+ * The constructor creates the required table and index idempotently. Database
+ * lifecycle remains owned by the caller through `initDatabase` and
+ * `closeDatabase`.
+ *
+ * @example
+ * ```ts
+ * const db = await initDatabase({ dbPath: "./lattice.db" });
+ * const store = new LocalCapabilityBundleStore(db);
+ * const bundles = await store.listByTenant("tenant-1");
+ * ```
+ */
+export class LocalCapabilityBundleStore implements CapabilityBundleStore {
+  /**
+   * Creates a capability bundle store over an initialized sql.js database.
+   *
+   * @param db - Shared local database wrapper used for persistence.
+   */
+  constructor(private readonly db: DatabaseWrapper) { ensureTable(db, DDL); }
+  async listByTenant(tenantId: string): Promise<CapabilityBundle[]> { return (this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? ORDER BY created_at").all(tenantId) as unknown as Row[]).map(map); }
+  async getById(tenantId: string, id: string): Promise<CapabilityBundle | null> { const row = this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? AND id = ?").get(tenantId, id) as unknown as Row | undefined; return row ? map(row) : null; }
+  async getManyByIds(tenantId: string, ids: string[]): Promise<CapabilityBundle[]> { return ids.flatMap((id) => { const row = this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? AND id = ?").get(tenantId, id) as unknown as Row | undefined; return row ? [map(row)] : []; }); }
+  async create(tenantId: string, input: InternalCreateCapabilityBundleInput): Promise<CapabilityBundle> { const now = nextTimestamp(); const id = randomUUID(); try { this.db.prepare("INSERT INTO lt_capability_bundles (id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(id, tenantId, input.key, input.name, input.description ?? null, JSON.stringify(input.capabilities), now, now); } catch (error) { if (isConstraint(error)) throw new Error(duplicateMessage); throw error; } return (await this.getById(tenantId, id)) as CapabilityBundle; }
+  async update(tenantId: string, id: string, input: InternalUpdateCapabilityBundleInput): Promise<CapabilityBundle | { status: "conflict" } | null> { const existing = await this.getById(tenantId, id); if (!existing) return null; if (input.expectedUpdatedAt !== undefined && input.expectedUpdatedAt !== existing.updatedAt) return { status: "conflict" }; const fields: string[] = []; const values: unknown[] = []; const add = (field: string, value: unknown): void => { fields.push(`${field} = ?`); values.push(value); }; if (input.name !== undefined) add("name", input.name); if (Object.prototype.hasOwnProperty.call(input, "description")) add("description", input.description ?? null); if (input.capabilities !== undefined) add("capabilities", JSON.stringify(input.capabilities)); if (!fields.length) return existing; const now = nextTimestamp(existing.updatedAt); fields.push("updated_at = ?"); values.push(now, tenantId, id); try { if (input.expectedUpdatedAt !== undefined) { const result = this.db.prepare(`UPDATE lt_capability_bundles SET ${fields.join(", ")} WHERE tenant_id = ? AND id = ? AND updated_at = ?`).run(...values, input.expectedUpdatedAt); if (result.changes === 0) return { status: "conflict" }; } else { this.db.prepare(`UPDATE lt_capability_bundles SET ${fields.join(", ")} WHERE tenant_id = ? AND id = ?`).run(...values); } } catch (error) { if (isConstraint(error)) throw new Error(duplicateMessage); throw error; } return this.getById(tenantId, id); }
+  async deleteIfUnreferenced(tenantId: string, id: string): Promise<CapabilityBundleDeleteResult> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_capability_bundles
+       WHERE tenant_id = ? AND id = ?
+       AND NOT EXISTS (
+         SELECT 1 FROM lt_projects
+         WHERE tenant_id = ?
+         AND json_type(config, '$.capabilityBundleIds') = 'array'
+         AND EXISTS (SELECT 1 FROM json_each(config, '$.capabilityBundleIds') WHERE value = ?)
+       )`,
+    ).run(tenantId, id, tenantId, id);
+    if (result.changes > 0) return "deleted";
+    if (await this.getById(tenantId, id)) return "in_use";
+    return "not_found";
+  }
+}