@axiom-lattice/pg-stores 3.1.0 → 3.1.2

package/src/__tests__/ThreadMessageQueueStore.test.ts

@@ -5,6 +5,7 @@
  */
 
 import { ThreadMessageQueueStore } from '../stores/ThreadMessageQueueStore';
+import type { AddMessageParams } from '@axiom-lattice/core';
 
 // Mock pg Pool
 const mockQuery = jest.fn();
@@ -23,6 +24,13 @@ describe('ThreadMessageQueueStore', () => {
   const mockThreadId = 'test-thread';
   const mockTenantId = 'test-tenant';
   const mockAssistantId = 'test-assistant';
+  const trusted = {
+    projectRoom: {
+      tenantId: mockTenantId, workspaceId: 'workspace', projectId: 'project', roomId: 'room',
+      sourceRoomMessageId: 'room-message', membershipId: 'membership', assistantId: mockAssistantId,
+      inputMessageId: 'input-1', role: 'coordinator' as const, title: 'Coordinator',
+    },
+  };
 
   beforeEach(() => {
     store = new ThreadMessageQueueStore({
@@ -34,6 +42,102 @@ describe('ThreadMessageQueueStore', () => {
   });
 
   describe('addMessage', () => {
+    it.each(['addMessage', 'addMessageIfCapacity', 'addMessageAtHead'] as const)(
+      'persists trusted metadata through %s',
+      async (method) => {
+        const row = {
+          id: 'input-1', message_content: JSON.stringify('message'), message_type: 'human',
+          sequence_order: 1, created_at: new Date(), trusted_run_context: trusted,
+          execution_mode: 'followup',
+        };
+        const params = {
+          threadId: mockThreadId, tenantId: mockTenantId, assistantId: mockAssistantId,
+          workspaceId: 'workspace', projectId: 'project', id: 'input-1', content: 'message',
+          trusted_run_context: trusted, execution_mode: 'followup' as const,
+        };
+
+        if (method === 'addMessageIfCapacity') {
+          const client = {
+            query: jest.fn()
+              .mockResolvedValueOnce({}).mockResolvedValueOnce({})
+              .mockResolvedValueOnce({ rows: [{ count: '0' }] })
+              .mockResolvedValueOnce({ rows: [{ next_seq: 1 }] })
+              .mockResolvedValueOnce({ rows: [row] }).mockResolvedValueOnce({}),
+            release: jest.fn(),
+          };
+          mockConnect.mockResolvedValueOnce(client);
+          await store.addMessageIfCapacity(params, 10);
+          expect(client.query.mock.calls[4][0]).toEqual(expect.stringContaining('trusted_run_context'));
+          expect(client.query.mock.calls[4][1]).toEqual(expect.arrayContaining([JSON.stringify(trusted), 'followup']));
+          return;
+        }
+
+        mockQuery.mockResolvedValueOnce({ rows: [{ next_seq: 1 }] }).mockResolvedValueOnce({ rows: [row] });
+        await store[method](params);
+        expect(mockQuery).toHaveBeenNthCalledWith(2, expect.stringContaining('trusted_run_context'),
+          expect.arrayContaining([JSON.stringify(trusted), 'followup']));
+      },
+    );
+    it.each(['addMessage', 'addMessageIfCapacity', 'addMessageAtHead'] as const)(
+      'rejects malformed trusted context before querying through %s',
+      async (method) => {
+        const params = {
+          threadId: mockThreadId, tenantId: mockTenantId, assistantId: mockAssistantId, content: 'message',
+          trusted_run_context: { projectRoom: { tenantId: mockTenantId } },
+        } as unknown as AddMessageParams;
+
+        const operation = method === 'addMessageIfCapacity'
+          ? store.addMessageIfCapacity(params, 10)
+          : store[method](params);
+        await expect(operation).rejects.toThrow('Invalid trusted agent run context');
+        expect(mockQuery).not.toHaveBeenCalled();
+        expect(mockConnect).not.toHaveBeenCalled();
+      },
+    );
+
+    it.each(['addMessage', 'addMessageIfCapacity', 'addMessageAtHead'] as const)(
+      'rejects invalid execution mode before querying through %s',
+      async (method) => {
+        const params: AddMessageParams = {
+          threadId: mockThreadId, tenantId: mockTenantId, assistantId: mockAssistantId, content: 'message',
+          execution_mode: 'steer' as unknown as AddMessageParams['execution_mode'],
+        };
+
+        const operation = method === 'addMessageIfCapacity'
+          ? store.addMessageIfCapacity(params, 10)
+          : store[method](params);
+        await expect(operation).rejects.toThrow('Invalid queued execution mode');
+        expect(mockQuery).not.toHaveBeenCalled();
+        expect(mockConnect).not.toHaveBeenCalled();
+      },
+    );
+    it('atomically rejects enqueue after the scoped pending capacity is reached', async () => {
+      const client = {
+        query: jest.fn()
+          .mockResolvedValueOnce({})
+          .mockResolvedValueOnce({})
+          .mockResolvedValueOnce({ rows: [{ count: '2' }] })
+          .mockResolvedValueOnce({}),
+        release: jest.fn(),
+      };
+      mockConnect.mockResolvedValueOnce(client);
+
+      await expect(store.addMessageIfCapacity({
+        threadId: mockThreadId,
+        tenantId: mockTenantId,
+        assistantId: mockAssistantId,
+        workspaceId: null,
+        projectId: null,
+        content: 'full',
+      }, 2)).resolves.toBe(false);
+
+      expect(client.query).toHaveBeenCalledWith(
+        'SELECT pg_advisory_xact_lock(hashtext($1))',
+        [`${mockTenantId}:${mockAssistantId}:${mockThreadId}::`],
+      );
+      expect(client.release).toHaveBeenCalled();
+    });
+
     it('should add message to queue', async () => {
       const mockMessage = {
         id: 'msg-1',
@@ -131,7 +235,6 @@ describe('ThreadMessageQueueStore', () => {
     it('should insert message with high priority', async () => {
       // Mock thread info query
       mockQuery
-        .mockResolvedValueOnce({ rows: [{ tenant_id: mockTenantId, assistant_id: mockAssistantId }] }) // Get thread info
         .mockResolvedValueOnce({ rows: [{ next_seq: 1 }] }) // Get next sequence
         .mockResolvedValueOnce({ 
           rows: [{ 
@@ -158,7 +261,6 @@ describe('ThreadMessageQueueStore', () => {
 
     it('should use default tenant/assistant when no existing messages', async () => {
       mockQuery
-        .mockResolvedValueOnce({ rows: [] }) // No existing messages
         .mockResolvedValueOnce({ rows: [{ next_seq: 0 }] }) // Get next sequence
         .mockResolvedValueOnce({ 
           rows: [{ 
@@ -259,6 +361,79 @@ describe('ThreadMessageQueueStore', () => {
       expect(result[0].custom_run_config).toEqual(customRunConfig);
       expect((result[0].content as { command?: unknown }).command).toBeUndefined();
     });
+
+    it('hydrates trusted metadata for pending and processing rows', async () => {
+      const row = {
+        id: 'input-1', message_content: JSON.stringify('message'), message_type: 'human',
+        sequence_order: 1, created_at: new Date(), trusted_run_context: JSON.stringify(trusted),
+        execution_mode: 'followup',
+      };
+      mockQuery.mockResolvedValueOnce({ rows: [row] }).mockResolvedValueOnce({ rows: [row] });
+
+      expect((await store.getPendingMessages(mockThreadId))[0]).toMatchObject({
+        trusted_run_context: trusted, execution_mode: 'followup',
+      });
+      expect((await store.getProcessingMessages(mockThreadId))[0]).toMatchObject({
+        trusted_run_context: trusted, execution_mode: 'followup',
+      });
+    });
+
+    it('rejects hostile trusted JSON read from PostgreSQL', async () => {
+      mockQuery.mockResolvedValueOnce({ rows: [{
+        id: 'hostile', message_content: JSON.stringify('message'), message_type: 'human',
+        sequence_order: 1, created_at: new Date(),
+        trusted_run_context: { projectRoom: { tenantId: mockTenantId } }, execution_mode: 'followup',
+      }] });
+
+      await expect(store.getPendingMessages(mockThreadId)).rejects.toThrow('Invalid trusted agent run context');
+    });
+
+    it('matches nullish dimensions as NULL when a scope is supplied', async () => {
+      mockQuery.mockResolvedValueOnce({ rows: [] });
+
+      await store.getPendingMessages(mockThreadId, {
+        tenantId: mockTenantId,
+        assistantId: mockAssistantId,
+        workspaceId: undefined,
+        projectId: undefined,
+      });
+
+      expect(mockQuery).toHaveBeenCalledWith(
+        expect.stringMatching(/tenant_id = \$2.*assistant_id = \$3.*workspace_id IS NULL.*project_id IS NULL/s),
+        [mockThreadId, mockTenantId, mockAssistantId],
+      );
+    });
+
+    it('applies null-sensitive full scope predicates to every scoped operation', async () => {
+      const scope = {
+        tenantId: mockTenantId,
+        assistantId: mockAssistantId,
+        workspaceId: undefined,
+        projectId: undefined,
+      };
+      mockQuery
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({ rows: [{ count: '0' }] })
+        .mockResolvedValueOnce({ rowCount: 0 })
+        .mockResolvedValueOnce({ rowCount: 0 })
+        .mockResolvedValueOnce({ rowCount: 0 })
+        .mockResolvedValueOnce({ rowCount: 0 });
+
+      await store.getProcessingMessages(mockThreadId, scope);
+      await store.getPendingMessages(mockThreadId, scope);
+      await store.getQueueSize(mockThreadId, scope);
+      await store.markProcessing('msg-1', undefined, scope);
+      await store.resetProcessingToPending(mockThreadId, scope);
+      await store.removeMessage('msg-1', scope);
+      await store.clearMessages(mockThreadId, scope);
+
+      expect(mockQuery).toHaveBeenCalledTimes(7);
+      for (const [sql, params] of mockQuery.mock.calls as Array<[string, unknown[]]>) {
+        expect(sql).toMatch(/tenant_id = \$2.*assistant_id = \$3.*workspace_id IS NULL.*project_id IS NULL/s);
+        expect(params).toEqual(expect.arrayContaining([mockTenantId, mockAssistantId]));
+      }
+    });
   });
 
   describe('getQueueSize', () => {
@@ -296,6 +471,26 @@ describe('ThreadMessageQueueStore', () => {
       expect(result[1].threadId).toBe('thread-2');
       expect(result[2].threadId).toBe('thread-3');
     });
+
+    it('preserves NULL workspace and project identity for legacy rows', async () => {
+      mockQuery.mockResolvedValueOnce({
+        rows: [{
+          tenant_id: mockTenantId,
+          assistant_id: mockAssistantId,
+          thread_id: mockThreadId,
+          workspace_id: null,
+          project_id: null,
+        }],
+      });
+
+      await expect(store.getThreadsWithPendingMessages()).resolves.toEqual([{
+        tenantId: mockTenantId,
+        assistantId: mockAssistantId,
+        threadId: mockThreadId,
+        workspaceId: null,
+        projectId: null,
+      }]);
+    });
   });
 
   describe('removeMessage', () => {
@@ -323,10 +518,20 @@ describe('ThreadMessageQueueStore', () => {
       await store.markProcessing('msg-1');
 
       expect(mockQuery).toHaveBeenCalledWith(
-        expect.stringContaining("UPDATE thread_message_queue"),
+        expect.stringContaining("UPDATE lattice_thread_message_queue"),
         ['msg-1']
       );
     });
+
+    it('updates only status and custom config, preserving trusted columns', async () => {
+      mockQuery.mockResolvedValueOnce({ rowCount: 1 });
+      await store.markProcessing('input-1', { model: 'updated' });
+
+      const sql = mockQuery.mock.calls[0][0] as string;
+      expect(sql).toContain("status = 'processing', custom_run_config = $2");
+      expect(sql).not.toContain('trusted_run_context =');
+      expect(sql).not.toContain('execution_mode =');
+    });
   });
 
   describe('clearMessages', () => {
@@ -336,7 +541,7 @@ describe('ThreadMessageQueueStore', () => {
       await store.clearMessages(mockThreadId);
 
       expect(mockQuery).toHaveBeenCalledWith(
-        expect.stringContaining("DELETE FROM thread_message_queue"),
+        expect.stringContaining("DELETE FROM lattice_thread_message_queue"),
         [mockThreadId]
       );
     });

package/src/__tests__/add_workspace_project_to_queue.test.ts

@@ -0,0 +1,15 @@
+import type { PoolClient } from "pg";
+import { addWorkspaceProjectToQueue } from "../migrations/add_workspace_project_to_queue";
+
+describe("addWorkspaceProjectToQueue", () => {
+  it("adds nullable scope columns so legacy rows retain NULL identity", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [] });
+
+    await addWorkspaceProjectToQueue.up({ query } as unknown as PoolClient);
+
+    const sql = query.mock.calls.map(([statement]) => statement as string).join("\n");
+    expect(sql).toContain("ADD COLUMN IF NOT EXISTS workspace_id VARCHAR(255)");
+    expect(sql).toContain("ADD COLUMN IF NOT EXISTS project_id VARCHAR(255)");
+    expect(sql).not.toMatch(/SET\s+DEFAULT|NOT\s+NULL|UPDATE\s+lattice_thread_message_queue/i);
+  });
+});

package/src/__tests__/migration-name-version-compatibility.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import type { Pool, PoolClient } from "pg";
+import { addTrustedRunContextColumn } from "../migrations/add_trusted_run_context_column";
+import { MigrationManager, type Migration } from "../migrations/migration";
+import { createProjectRoomTables } from "../migrations/project_room_migration";
+import { addTaskDependenciesGinIndex } from "../migrations/task_migration";
+import {
+  addProjectLifecycleEventIndex,
+  addTaskWorkItemPendingIndexesMigration,
+} from "../migrations/task_work_items_migration";
+
+describe("migration name and version compatibility", () => {
+  it("skips renumbered feature migrations already applied under their stable names", async () => {
+    const previouslyApplied = [
+      { name: "create_project_room_tables", version: 171, applied_at: new Date() },
+      { name: "add_thread_queue_trusted_run_context", version: 172, applied_at: new Date() },
+      { name: "add_task_dependencies_gin_index", version: 173, applied_at: new Date() },
+      { name: "add_project_lifecycle_event_index", version: 174, applied_at: new Date() },
+    ];
+    const executedUpNames: string[] = [];
+    const insertedNames: string[] = [];
+    const release = jest.fn();
+    const query = jest.fn(async (sql: string, params?: unknown[]) => {
+      if (sql.includes("information_schema.tables")) return { rows: [{ exists: true }] };
+      if (sql.includes("pg_index")) {
+        return { rows: [{ column_name: "name", constraint_name: "lattice_schema_migrations_pkey" }] };
+      }
+      if (sql === "SELECT name, version, applied_at FROM lattice_schema_migrations ORDER BY version") {
+        return { rows: previouslyApplied };
+      }
+      if (sql.includes("INSERT INTO lattice_schema_migrations")) {
+        insertedNames.push(params?.[0] as string);
+      }
+      return { rows: [] };
+    });
+    const client = { query, release } as unknown as PoolClient;
+    const pool = { connect: jest.fn(async () => client) } as unknown as Pool;
+    const manager = new MigrationManager(pool);
+    const migrations = [
+      addTaskWorkItemPendingIndexesMigration,
+      createProjectRoomTables,
+      addTrustedRunContextColumn,
+      addTaskDependenciesGinIndex,
+      addProjectLifecycleEventIndex,
+    ];
+    for (const migration of migrations) {
+      const wrapped: Migration = {
+        ...migration,
+        up: async (migrationClient) => {
+          executedUpNames.push(migration.name);
+          await migration.up(migrationClient);
+        },
+      };
+      manager.register(wrapped);
+    }
+
+    await manager.migrate();
+
+    expect(migrations.map(({ version }) => version).every(
+      (version, index, versions) => index === 0 || version > versions[index - 1],
+    )).toBe(true);
+    expect(executedUpNames).toEqual(["add_task_work_item_pending_indexes"]);
+    expect(insertedNames).toEqual(["add_task_work_item_pending_indexes"]);
+    expect(insertedNames).not.toEqual(expect.arrayContaining(previouslyApplied.map(({ name }) => name)));
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/task-files.test.ts

@@ -13,9 +13,10 @@ describe("add_files_to_tasks migration", () => {
     expect(taskMigrations.map((m) => m.name)).toContain("add_files_to_tasks");
   });
 
-  it("has a version greater than all existing task migrations", () => {
-    const versions = taskMigrations.map((m) => m.version);
-    expect(addFilesToTasks.version).toBe(Math.max(...versions));
+  it("has a version greater than the task migrations registered before it", () => {
+    const migrationIndex = taskMigrations.indexOf(addFilesToTasks);
+    const precedingVersions = taskMigrations.slice(0, migrationIndex).map((m) => m.version);
+    expect(addFilesToTasks.version).toBeGreaterThan(Math.max(...precedingVersions));
   });
 
   it("emits ADD COLUMN files JSONB in up()", async () => {

package/src/createPgStoreConfig.ts

@@ -62,6 +62,7 @@ import { addPriorityAndCommandColumns } from "./migrations/add_priority_command_
 import { addCustomRunConfigColumn } from "./migrations/add_custom_run_config_column";
 import { alterMessageQueueIdColumn } from "./migrations/alter_message_queue_id_column";
 import { addWorkspaceProjectToQueue } from "./migrations/add_workspace_project_to_queue";
+import { addTrustedRunContextColumn } from "./migrations/add_trusted_run_context_column";
 import { createWorkflowTrackingTables, addStepThreadId, addWorkflowRunsTenantStatusUpdatedIndex } from "./migrations/workflow_tracking_migrations";
 import { evalMigrations } from "./migrations/eval_migrations";
 import { createA2AApiKeysTable } from "./migrations/a2a_api_key_migration";
@@ -71,8 +72,21 @@ import { createMenuItemsTable } from "./migrations/menu_items_migration";
 import { addFileContentType } from "./migrations/menu_items_add_file_type";
 import { createSharedResourcesTable } from "./migrations/shared_resources_migration";
 import { createCollectionsTable } from "./migrations/collection_migrations";
-import { createTaskWorkItemsMigration, addWorkItemProjectFieldsMigration, addTaskWorkItemEventKeyMigration } from "./migrations/task_work_items_migration";
+import {
+  createTaskWorkItemsMigration,
+  addWorkItemProjectFieldsMigration,
+  addTaskWorkItemEventKeyMigration,
+  addTaskWorkItemPendingIndexesMigration,
+  addProjectLifecycleEventIndex,
+} from "./migrations/task_work_items_migration";
 import { createAgentWebAppsTable } from "./migrations/agent_web_apps_migration";
+import { createCapabilityBundlesTable } from "./migrations/capability_bundle_migration";
+import { createProjectRoomTables } from "./migrations/project_room_migration";
+import { PostgreSQLCapabilityBundleStore } from "./stores/PostgreSQLCapabilityBundleStore";
+import { PostgreSQLProjectRoomStore } from "./stores/PostgreSQLProjectRoomStore";
+import { PostgreSQLProjectMembershipStore } from "./stores/PostgreSQLProjectMembershipStore";
+import { PostgreSQLProjectBotMembershipStore } from "./stores/PostgreSQLProjectBotMembershipStore";
+import { PostgreSQLProjectRoomMessageStore } from "./stores/PostgreSQLProjectRoomMessageStore";
 
 export async function createPgStoreConfig(connectionString: string) {
   const pool = new Pool({ connectionString });
@@ -134,6 +148,11 @@ export async function createPgStoreConfig(connectionString: string) {
   mm.register(addA2AKeyAssistantIds);         // v167
   mm.register(addTaskWorkItemEventKeyMigration); // v168
   mm.register(createAgentWebAppsTable);        // v169
+  mm.register(createCapabilityBundlesTable);   // v170
+  mm.register(addTaskWorkItemPendingIndexesMigration); // v171
+  mm.register(createProjectRoomTables);        // v172
+  mm.register(addTrustedRunContextColumn);      // v173
+  mm.register(addProjectLifecycleEventIndex);   // v175
 
   await mm.migrate();
 
@@ -167,10 +186,15 @@ export async function createPgStoreConfig(connectionString: string) {
     taskWorkItem: taskWorkItemStore,
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
     agentWebApp: new PostgreSQLAgentWebAppStore(opts),
+    capabilityBundle: new PostgreSQLCapabilityBundleStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),
     sharedResource: new PostgresSharedResourceStore(opts),
     collection: new PostgreSQLCollectionStore(opts),
+    projectRoom: new PostgreSQLProjectRoomStore(opts),
+    projectMembership: new PostgreSQLProjectMembershipStore(opts),
+    projectBotMembership: new PostgreSQLProjectBotMembershipStore(opts),
+    projectRoomMessage: new PostgreSQLProjectRoomMessageStore(opts),
     vectorStoreProvider: new PGVectorStoreProvider(pool, connectionString),
     checkpoint,
   };

package/src/index.ts

@@ -58,6 +58,9 @@ export * from "./stores/ChannelIdentityMappingStore";
 export * from "./stores/PostgreSQLChannelInstallationStore";
 export * from "./stores/PostgreSQLA2AApiKeyStore";
 export * from "./stores/PostgreSQLAgentWebAppStore";
+export * from "./stores/PostgreSQLTaskWorkItemStore";
+export * from "./stores/PostgreSQLCapabilityBundleStore";
+export * from "./migrations/capability_bundle_migration";
 export * from "./stores/PostgreSQLWorkflowTrackingStore";
 export * from "./stores/PostgreSQLEvalStore";
 export * from "./migrations/eval_migrations";
@@ -68,6 +71,11 @@ export * from "./stores/MenuStore";
 export * from "./stores/SharedResourceStore";
 export * from "./stores/PostgresSharedResourceStore";
 export * from "./stores/PostgreSQLCollectionStore";
+export * from "./stores/PostgreSQLProjectRoomStore";
+export * from "./stores/PostgreSQLProjectMembershipStore";
+export * from "./stores/PostgreSQLProjectBotMembershipStore";
+export * from "./stores/PostgreSQLProjectRoomMessageStore";
+export * from "./migrations/project_room_migration";
 
 export * from "./PGVectorStoreProvider";
 
@@ -125,6 +133,7 @@ export type {
   CreateMenuItemInput,
   ChannelInstallationStore,
   ChannelInstallation,
+  CreateChannelInstallationInput,
   CreateChannelInstallationRequest,
   UpdateChannelInstallationRequest,
   LarkChannelInstallationConfig,
@@ -191,4 +200,8 @@ export type {
   AgentWebAppAppearance,
   CreateAgentWebAppInput,
   UpdateAgentWebAppInput,
+  CapabilityBundleStore,
+  CapabilityBundle,
+  CreateCapabilityBundleInput,
+  UpdateCapabilityBundleInput,
 } from "@axiom-lattice/protocols";

package/src/migrations/add_trusted_run_context_column.ts

@@ -0,0 +1,18 @@
+import type { Migration } from "./migration";
+
+/** Adds durable privileged context and execution mode to queued thread messages. */
+export const addTrustedRunContextColumn: Migration = {
+  version: 173,
+  name: "add_thread_queue_trusted_run_context",
+  up: async (client): Promise<void> => {
+    await client.query(`ALTER TABLE lattice_thread_message_queue
+      ADD COLUMN IF NOT EXISTS trusted_run_context JSONB,
+      ADD COLUMN IF NOT EXISTS execution_mode VARCHAR(20)
+        CHECK (execution_mode IS NULL OR execution_mode = 'followup')`);
+  },
+  down: async (client): Promise<void> => {
+    await client.query(`ALTER TABLE lattice_thread_message_queue
+      DROP COLUMN IF EXISTS execution_mode,
+      DROP COLUMN IF EXISTS trusted_run_context`);
+  },
+};

package/src/migrations/capability_bundle_migration.ts

@@ -0,0 +1,20 @@
+import type { Migration } from "./migration";
+
+/** Creates the tenant-scoped capability bundle table. */
+export const createCapabilityBundlesTable: Migration = {
+  version: 170,
+  name: "create_capability_bundles_table",
+  up: async (client) => {
+    await client.query(`CREATE TABLE IF NOT EXISTS lattice_capability_bundles (
+      id UUID PRIMARY KEY, tenant_id VARCHAR(255) NOT NULL, bundle_key VARCHAR(255) NOT NULL,
+      name VARCHAR(255) NOT NULL, description TEXT, capabilities JSONB NOT NULL DEFAULT '[]'::jsonb,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      UNIQUE (tenant_id, bundle_key)
+    )`);
+    await client.query("CREATE INDEX IF NOT EXISTS idx_lattice_capability_bundles_tenant ON lattice_capability_bundles(tenant_id)");
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_capability_bundles_tenant");
+    await client.query("DROP TABLE IF EXISTS lattice_capability_bundles");
+  },
+};

package/src/migrations/migration.ts

@@ -83,7 +83,8 @@ export class MigrationManager {
     const tableExists = await client.query(`
       SELECT EXISTS (
         SELECT FROM information_schema.tables
-        WHERE table_name = 'lattice_schema_migrations'
+        WHERE table_schema = current_schema()
+          AND table_name = 'lattice_schema_migrations'
       )
     `);
 

package/src/migrations/project_room_migration.ts

@@ -0,0 +1,128 @@
+import type { Migration } from "./migration";
+
+/** Creates the tenant-scoped project room, roster, and message tables. */
+export const createProjectRoomTables: Migration = {
+  version: 172,
+  name: "create_project_room_tables",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_project_rooms (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        workspace_id VARCHAR(255) NOT NULL,
+        project_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        type VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_rooms_type
+          CHECK (type IN ('main')),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id),
+        UNIQUE (tenant_id, project_id, type)
+      )
+    `);
+
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_project_memberships (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        project_id VARCHAR(255) NOT NULL,
+        user_id VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_memberships_role
+          CHECK (role IN ('owner', 'admin', 'member', 'viewer')),
+        status VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_memberships_status
+          CHECK (status IN ('active', 'removed')),
+        joined_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id),
+        UNIQUE (tenant_id, project_id, user_id)
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_project_memberships_project
+      ON lattice_project_memberships (tenant_id, project_id)
+    `);
+
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_project_bot_memberships (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        workspace_id VARCHAR(255) NOT NULL,
+        project_id VARCHAR(255) NOT NULL,
+        room_id VARCHAR(255) NOT NULL,
+        assistant_id VARCHAR(255) NOT NULL,
+        role VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_bot_memberships_role
+          CHECK (role IN ('coordinator', 'specialist')),
+        title VARCHAR(255) NOT NULL,
+        responsibility TEXT,
+        mention_name VARCHAR(255) NOT NULL,
+        status VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_bot_memberships_status
+          CHECK (status IN ('active', 'paused', 'removed')),
+        room_thread_id VARCHAR(255) NOT NULL,
+        joined_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id),
+        UNIQUE (tenant_id, project_id, assistant_id)
+      )
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_project_bot_memberships_coordinator
+      ON lattice_project_bot_memberships (tenant_id, project_id)
+      WHERE role = 'coordinator' AND status IN ('active', 'paused')
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_project_bot_memberships_mention
+      ON lattice_project_bot_memberships (tenant_id, room_id, mention_name)
+      WHERE status IN ('active', 'paused')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_project_bot_memberships_project
+      ON lattice_project_bot_memberships (tenant_id, project_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_project_bot_memberships_room
+      ON lattice_project_bot_memberships (tenant_id, room_id)
+    `);
+
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_project_room_messages (
+        id VARCHAR(255) NOT NULL,
+        tenant_id VARCHAR(255) NOT NULL,
+        workspace_id VARCHAR(255) NOT NULL,
+        project_id VARCHAR(255) NOT NULL,
+        room_id VARCHAR(255) NOT NULL,
+        author JSONB NOT NULL,
+        content JSONB NOT NULL,
+        mentions JSONB NOT NULL DEFAULT '[]'::jsonb,
+        reply_to_message_id VARCHAR(255),
+        source VARCHAR(32) NOT NULL CONSTRAINT chk_lattice_project_room_messages_source
+          CHECK (source IN ('user', 'agent', 'task', 'routine', 'system')),
+        source_id VARCHAR(255),
+        idempotency_key VARCHAR(255),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id)
+      )
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_lattice_project_room_messages_idempotency
+      ON lattice_project_room_messages (tenant_id, room_id, idempotency_key)
+      WHERE idempotency_key IS NOT NULL
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_project_room_messages_room_created
+      ON lattice_project_room_messages (tenant_id, room_id, created_at DESC, id DESC)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_project_room_messages_room_created");
+    await client.query("DROP INDEX IF EXISTS uq_lattice_project_room_messages_idempotency");
+    await client.query("DROP TABLE IF EXISTS lattice_project_room_messages");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_project_bot_memberships_room");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_project_bot_memberships_project");
+    await client.query("DROP INDEX IF EXISTS uq_lattice_project_bot_memberships_mention");
+    await client.query("DROP INDEX IF EXISTS uq_lattice_project_bot_memberships_coordinator");
+    await client.query("DROP TABLE IF EXISTS lattice_project_bot_memberships");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_project_memberships_project");
+    await client.query("DROP TABLE IF EXISTS lattice_project_memberships");
+    await client.query("DROP TABLE IF EXISTS lattice_project_rooms");
+  },
+};