@axiom-lattice/pg-stores 1.0.90 → 1.0.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/pg-stores",
-  "version": "1.0.90",
+  "version": "1.0.93",
   "description": "PG stores implementation for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@langchain/core": "1.1.30",
     "pg": "^8.16.3",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.99",
-    "@axiom-lattice/protocols": "2.1.51"
+    "@axiom-lattice/core": "2.1.102",
+    "@axiom-lattice/protocols": "2.1.53"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/PostgreSQLWorkflowTrackingStore.test.ts

@@ -220,7 +220,7 @@ describe("mapRowToRunStep", () => {
       output: "also invalid",
     });
     expect(result.input).toBeUndefined();
-    expect(result.output).toBeUndefined();
+    expect(result.output).toEqual("also invalid");  // text output preserved as-is (jsonb column)
   });
 
   test("handles deeply nested objects", () => {

package/src/createPgStoreConfig.ts

@@ -19,6 +19,7 @@ import { PostgreSQLChannelInstallationStore } from "./stores/PostgreSQLChannelIn
 import { PostgreSQLA2AApiKeyStore } from "./stores/PostgreSQLA2AApiKeyStore";
 import { PostgreSQLScheduleStorage } from "./stores/PostgreSQLScheduleStorage";
 import { PostgreSQLTaskStore } from "./stores/PostgreSQLTaskStore";
+import { PostgreSQLTaskWorkItemStore } from "./stores/PostgreSQLTaskWorkItemStore";
 import { MenuStore } from "./stores/MenuStore";
 import { PostgresSharedResourceStore } from "./stores/PostgresSharedResourceStore";
 import { PostgreSQLCollectionStore } from "./stores/PostgreSQLCollectionStore";
@@ -62,11 +63,12 @@ import { addWorkspaceProjectToQueue } from "./migrations/add_workspace_project_t
 import { createWorkflowTrackingTables, addStepThreadId, addWorkflowRunsTenantStatusUpdatedIndex } from "./migrations/workflow_tracking_migrations";
 import { evalMigrations } from "./migrations/eval_migrations";
 import { createA2AApiKeysTable } from "./migrations/a2a_api_key_migration";
-import { createTasksTable } from "./migrations/task_migration";
+import { createTasksTable, addTaskFieldsMigration, addTaskProjectFieldsMigration } from "./migrations/task_migration";
 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 } from "./migrations/task_work_items_migration";
 
 export async function createPgStoreConfig(connectionString: string) {
   const pool = new Pool({ connectionString });
@@ -118,6 +120,10 @@ export async function createPgStoreConfig(connectionString: string) {
   mm.register(createSharedResourcesTable);       // v135
   mm.register(addFileContentType);               // v136
   mm.register(createCollectionsTable);           // v137
+  mm.register(addTaskFieldsMigration);            // v139
+  mm.register(createTaskWorkItemsMigration);      // v138
+  mm.register(addTaskProjectFieldsMigration);     // v140
+  mm.register(addWorkItemProjectFieldsMigration); // v140
   mm.register(createConnectionConfigsTable);      // v160
   mm.register(addWorkflowRunsTenantStatusUpdatedIndex); // v161
 
@@ -130,6 +136,8 @@ export async function createPgStoreConfig(connectionString: string) {
 
   const opts = { pool };
 
+  const taskWorkItemStore = new PostgreSQLTaskWorkItemStore(pool);
+
   return {
     workspace: new PostgreSQLWorkspaceStore(opts),
     project: new PostgreSQLProjectStore(opts),
@@ -148,6 +156,7 @@ export async function createPgStoreConfig(connectionString: string) {
     workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
     threadMessageQueue: new ThreadMessageQueueStore(opts),
     task: new PostgreSQLTaskStore(opts),
+    taskWorkItem: taskWorkItemStore,
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),

package/src/migrations/task_migration.ts

@@ -49,3 +49,34 @@ export const createTasksTable: Migration = {
     await client.query("DROP TABLE IF EXISTS lattice_tasks");
   },
 };
+
+export const addTaskFieldsMigration: Migration = {
+  version: 139,
+  name: "add_task_fields_require_review_deps_result_failure",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_tasks
+        ADD COLUMN IF NOT EXISTS require_review BOOLEAN DEFAULT FALSE,
+        ADD COLUMN IF NOT EXISTS dependencies JSONB,
+        ADD COLUMN IF NOT EXISTS result TEXT,
+        ADD COLUMN IF NOT EXISTS failure_reason TEXT
+    `);
+  },
+};
+
+export const addTaskProjectFieldsMigration: Migration = {
+  version: 140,
+  name: "add_task_project_workspace_fields",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_tasks
+        ADD COLUMN IF NOT EXISTS workspace_id TEXT,
+        ADD COLUMN IF NOT EXISTS project_id TEXT
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_tasks_project
+        ON lattice_tasks (tenant_id, project_id)
+    `);
+  },
+};

package/src/migrations/task_work_items_migration.ts

@@ -0,0 +1,51 @@
+import type { PoolClient } from "pg";
+import type { Migration } from "./migration";
+
+export const createTaskWorkItemsMigration: Migration = {
+  version: 138,
+  name: "create_task_work_items_table",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_task_work_items (
+        id TEXT NOT NULL,
+        tenant_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        action TEXT NOT NULL,
+        actor TEXT NOT NULL,
+        thread_id TEXT,
+        summary TEXT,
+        detail JSONB,
+        attempt INTEGER,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (tenant_id, id)
+      )
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_task_id
+        ON lattice_task_work_items (tenant_id, task_id)
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_action
+        ON lattice_task_work_items (tenant_id, task_id, action)
+    `);
+  },
+};
+
+export const addWorkItemProjectFieldsMigration: Migration = {
+  version: 140,
+  name: "add_task_work_item_project_fields",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_task_work_items
+        ADD COLUMN IF NOT EXISTS workspace_id TEXT,
+        ADD COLUMN IF NOT EXISTS project_id TEXT
+    `);
+
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_project
+        ON lattice_task_work_items (tenant_id, project_id)
+    `);
+  },
+};

package/src/stores/PostgreSQLConnectionStore.ts

@@ -30,6 +30,14 @@ export class PostgreSQLConnectionStore implements ConnectionStore {
     this.db = db;
   }
 
+  async listByTenant(tenantId: string): Promise<ConnectionEntry[]> {
+    const result = await this.db.query<ConnectionRow>(
+      `SELECT * FROM ${TABLE} WHERE tenant_id = $1 ORDER BY created_at`,
+      [tenantId],
+    );
+    return result.rows.map((row) => this.mapRow(row));
+  }
+
   async listByType(tenantId: string, type: string): Promise<ConnectionEntry[]> {
     const result = await this.db.query<ConnectionRow>(
       `SELECT * FROM ${TABLE} WHERE tenant_id = $1 AND type = $2 ORDER BY created_at`,

package/src/stores/PostgreSQLEvalStore.ts

@@ -828,6 +828,18 @@ export class PostgreSQLEvalStore implements EvalStore {
     return rows.length ? this.mapRowToRunResult(rows[0] as unknown as Record<string, unknown>) : null;
   }
 
+  /** Delete a run result by ID */
+  async deleteRunResult(tenantId: string, id: string): Promise<boolean> {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_eval_run_results
+       WHERE id = $1
+         AND run_id IN (SELECT id FROM lattice_eval_runs WHERE tenant_id = $2)`,
+      [id, tenantId],
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+
   /** Get a single run result by ID with tenant isolation */
   private async getRunResultById(tenantId: string, id: string): Promise<EvalRunResult | null> {
     await this.ensureInitialized();

package/src/stores/PostgreSQLTaskStore.ts

@@ -12,7 +12,7 @@ import type {
   TaskListFilter,
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
-import { createTasksTable } from "../migrations/task_migration";
+import { createTasksTable, addTaskFieldsMigration, addTaskProjectFieldsMigration } from "../migrations/task_migration";
 import { v4 as uuidv4 } from "uuid";
 
 interface TaskRow {
@@ -29,6 +29,12 @@ interface TaskRow {
   parent_id: string | null;
   source_id: string | null;
   context: Record<string, unknown> | null;
+  require_review: boolean | null;
+  dependencies: string[] | null;
+  result: string | null;
+  failure_reason: string | null;
+  workspace_id: string | null;
+  project_id: string | null;
   created_at: string;
   updated_at: string;
 }
@@ -48,6 +54,12 @@ function mapRowToTask(row: TaskRow): TaskItem {
     parentId: row.parent_id ?? undefined,
     sourceId: row.source_id ?? undefined,
     context: row.context ?? undefined,
+    requireReview: row.require_review ?? undefined,
+    dependencies: row.dependencies ?? undefined,
+    result: row.result ?? undefined,
+    failureReason: row.failure_reason ?? undefined,
+    workspaceId: row.workspace_id ?? undefined,
+    projectId: row.project_id ?? undefined,
     createdAt: new Date(row.created_at),
     updatedAt: new Date(row.updated_at),
   };
@@ -85,6 +97,8 @@ export class PostgreSQLTaskStore implements TaskStore {
 
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createTasksTable);
+    this.migrationManager.register(addTaskFieldsMigration);
+    this.migrationManager.register(addTaskProjectFieldsMigration);
 
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
@@ -123,8 +137,8 @@ export class PostgreSQLTaskStore implements TaskStore {
     const now = new Date().toISOString();
 
     await this.pool.query(
-      `INSERT INTO lattice_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)`,
+      `INSERT INTO lattice_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, require_review, dependencies, result, failure_reason, workspace_id, project_id, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)`,
       [
         id,
         params.tenantId,
@@ -139,6 +153,12 @@ export class PostgreSQLTaskStore implements TaskStore {
         params.parentId || null,
         params.sourceId || null,
         params.context ? JSON.stringify(params.context) : null,
+        params.requireReview ?? null,
+        params.dependencies ? JSON.stringify(params.dependencies) : null,
+        params.result ?? null,
+        params.failureReason ?? null,
+        params.workspaceId || null,
+        params.projectId || null,
         now,
         now,
       ],
@@ -172,13 +192,24 @@ export class PostgreSQLTaskStore implements TaskStore {
       params.push(filter.ownerId);
     }
     if (filter.status) {
-      conditions.push(`status = $${paramIndex++}`);
-      params.push(filter.status);
+      const statuses = filter.status.split(',').map(s => s.trim()).filter(Boolean);
+      const placeholders = statuses.map((_, i) => `$${paramIndex + i}`).join(', ');
+      conditions.push(`status IN (${placeholders})`);
+      params.push(...statuses);
+      paramIndex += statuses.length;
     }
     if (filter.priority) {
       conditions.push(`priority = $${paramIndex++}`);
       params.push(filter.priority);
     }
+    if (filter.workspaceId) {
+      conditions.push(`workspace_id = $${paramIndex++}`);
+      params.push(filter.workspaceId);
+    }
+    if (filter.projectId) {
+      conditions.push(`project_id = $${paramIndex++}`);
+      params.push(filter.projectId);
+    }
     if (filter.parentId) {
       conditions.push(`parent_id = $${paramIndex++}`);
       params.push(filter.parentId);
@@ -265,6 +296,30 @@ export class PostgreSQLTaskStore implements TaskStore {
       setClauses.push(`owner_id = $${paramIndex++}`);
       params.push(updates.ownerId);
     }
+    if (updates.requireReview !== undefined) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== undefined) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== undefined) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== undefined) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== undefined) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== undefined) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
 
     if (setClauses.length === 0) {
       return existing;

package/src/stores/PostgreSQLTaskWorkItemStore.ts

@@ -0,0 +1,67 @@
+import type { Pool } from "pg";
+import type { TaskWorkItemStore, TaskWorkItem, CreateWorkItemRequest, TaskWorkItemListFilter } from "@axiom-lattice/protocols";
+import { v4 } from "uuid";
+
+export class PostgreSQLTaskWorkItemStore implements TaskWorkItemStore {
+  constructor(private pool: Pool) {}
+
+  async create(params: CreateWorkItemRequest): Promise<TaskWorkItem> {
+    const id = v4();
+    const result = await this.pool.query(
+      `INSERT INTO lattice_task_work_items
+        (id, tenant_id, task_id, action, actor, thread_id, summary, detail, attempt, workspace_id, project_id)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+       RETURNING *`,
+      [
+        id, params.tenantId, params.taskId, params.action, params.actor,
+        params.threadId || null, params.summary || null,
+        params.detail ? JSON.stringify(params.detail) : null,
+        params.attempt || null,
+        params.workspaceId || null,
+        params.projectId || null,
+      ]
+    );
+    return this.rowToItem(result.rows[0]);
+  }
+
+  async list(filter: TaskWorkItemListFilter): Promise<TaskWorkItem[]> {
+    let query = `SELECT * FROM lattice_task_work_items WHERE tenant_id = $1 AND task_id = $2`;
+    const params: unknown[] = [filter.tenantId, filter.taskId];
+
+    if (filter.action) {
+      query += ` AND action = $${params.length + 1}`;
+      params.push(filter.action);
+    }
+
+    query += ` ORDER BY created_at ASC`;
+
+    if (filter.limit) {
+      query += ` LIMIT $${params.length + 1}`;
+      params.push(filter.limit);
+    }
+    if (filter.offset) {
+      query += ` OFFSET $${params.length + 1}`;
+      params.push(filter.offset);
+    }
+
+    const result = await this.pool.query(query, params);
+    return result.rows.map((row: Record<string, unknown>) => this.rowToItem(row));
+  }
+
+  private rowToItem(row: Record<string, unknown>): TaskWorkItem {
+    return {
+      id: row.id as string,
+      taskId: row.task_id as string,
+      tenantId: row.tenant_id as string,
+      action: row.action as string,
+      actor: row.actor as string,
+      threadId: row.thread_id as string | undefined,
+      summary: row.summary as string | undefined,
+      detail: row.detail as Record<string, unknown> | undefined,
+      attempt: row.attempt as number | undefined,
+      workspaceId: row.workspace_id as string | undefined,
+      projectId: row.project_id as string | undefined,
+      createdAt: new Date(row.created_at as string),
+    };
+  }
+}

package/src/stores/PostgreSQLTenantStore.ts

@@ -261,8 +261,8 @@ export class PostgreSQLTenantStore implements TenantStore {
     }
 
     if (updates.metadata !== undefined) {
-      updateFields.push(`metadata = $${paramIndex++}`);
-      updateValues.push(updates.metadata);
+      updateFields.push(`metadata = COALESCE(lattice_tenants.metadata, '{}'::jsonb) || $${paramIndex++}::jsonb`);
+      updateValues.push(JSON.stringify(updates.metadata));
     }
 
     if (updateFields.length === 0) {

package/src/stores/PostgreSQLWorkflowTrackingStore.ts

@@ -374,7 +374,9 @@ export function mapRowToRunStep(row: any): RunStep {
     edgeTo: row.edge_to,
     edgePurpose: row.edge_purpose,
     input: safeParse(row.input, undefined),
-    output: safeParse(row.output, undefined),
+    output: typeof row.output === "string"
+      ? safeParse(row.output, row.output as any)
+      : row.output ?? undefined,
     status: row.status,
     errorMessage: row.error_message,
     startedAt: row.started_at,