@axiom-lattice/pg-stores 3.1.1 → 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,75 @@ 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()
@@ -285,6 +362,32 @@ describe('ThreadMessageQueueStore', () => {
       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: [] });
 
@@ -419,6 +522,16 @@ describe('ThreadMessageQueueStore', () => {
         ['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', () => {

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";
@@ -76,10 +77,16 @@ import {
   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 });
@@ -143,6 +150,9 @@ export async function createPgStoreConfig(connectionString: string) {
   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();
 
@@ -181,6 +191,10 @@ export async function createPgStoreConfig(connectionString: string) {
     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,7 @@ 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";
@@ -70,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";
 
@@ -127,6 +133,7 @@ export type {
   CreateMenuItemInput,
   ChannelInstallationStore,
   ChannelInstallation,
+  CreateChannelInstallationInput,
   CreateChannelInstallationRequest,
   UpdateChannelInstallationRequest,
   LarkChannelInstallationConfig,

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

package/src/migrations/task_migration.ts

@@ -98,10 +98,25 @@ export const addFilesToTasks: Migration = {
   },
 };
 
+/** Add JSONB containment support for dependency recovery queries. */
+export const addTaskDependenciesGinIndex: Migration = {
+  version: 174,
+  name: "add_task_dependencies_gin_index",
+  up: async (client) => {
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_lattice_tasks_dependencies_gin
+      ON lattice_tasks USING GIN (dependencies jsonb_path_ops)
+      WHERE dependencies IS NOT NULL`);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_tasks_dependencies_gin");
+  },
+};
+
 /** All task migrations in version order */
 export const taskMigrations: Migration[] = [
   createTasksTable,
   addTaskFieldsMigration,
   addTaskProjectFieldsMigration,
   addFilesToTasks,
+  addTaskDependenciesGinIndex,
 ];

package/src/migrations/task_work_items_migration.ts

@@ -16,7 +16,7 @@ export const createTaskWorkItemsMigration: Migration = {
         summary TEXT,
         detail JSONB,
         attempt INTEGER,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', clock_timestamp()),
         PRIMARY KEY (tenant_id, id)
       )
     `);
@@ -80,3 +80,31 @@ export const addTaskWorkItemPendingIndexesMigration: Migration = {
     `);
   },
 };
+
+/** Add deterministic project lifecycle event scan support. */
+export const addProjectLifecycleEventIndex: Migration = {
+  version: 175,
+  name: "add_project_lifecycle_event_index",
+  up: async (client) => {
+    await client.query(`UPDATE lattice_task_work_items
+      SET created_at = date_trunc('milliseconds', created_at)
+      WHERE created_at <> date_trunc('milliseconds', created_at)`);
+    await client.query(`ALTER TABLE lattice_task_work_items
+      ALTER COLUMN created_at SET DEFAULT date_trunc('milliseconds', clock_timestamp())`);
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_task_work_items_project_lifecycle
+      ON lattice_task_work_items (tenant_id, workspace_id, project_id, created_at DESC, id DESC)
+      WHERE event_key IS NOT NULL`);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_task_work_items_project_lifecycle");
+  },
+};
+
+/** Complete standalone TaskWorkItem migration chain in dependency order. */
+export const taskWorkItemMigrations: Migration[] = [
+  createTaskWorkItemsMigration,
+  addWorkItemProjectFieldsMigration,
+  addTaskWorkItemEventKeyMigration,
+  addTaskWorkItemPendingIndexesMigration,
+  addProjectLifecycleEventIndex,
+];