@axiom-lattice/pg-stores 2.0.10 → 3.0.1

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // src/index.ts
-import { Pool as Pool26 } from "pg";
+import { Pool as Pool27 } from "pg";
 
 // src/createPgStoreConfig.ts
-import { Pool as Pool23 } from "pg";
+import { Pool as Pool24 } from "pg";
 
 // src/migrations/migration.ts
 var MigrationManager = class {
@@ -2352,6 +2352,24 @@ var dropProjectFolderPathColumn = {
   }
 };
 
+// src/migrations/add_project_kind_column.ts
+var addProjectKindColumn = {
+  version: 165,
+  name: "add_project_kind_column",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_projects
+      ADD COLUMN IF NOT EXISTS kind TEXT NOT NULL DEFAULT 'business'
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_projects
+      DROP COLUMN IF EXISTS kind
+    `);
+  }
+};
+
 // src/stores/PostgreSQLProjectStore.ts
 var PostgreSQLProjectStore = class {
   constructor(options) {
@@ -2374,6 +2392,7 @@ var PostgreSQLProjectStore = class {
     this.migrationManager.register(createProjectsTable);
     this.migrationManager.register(addProjectConfigColumn);
     this.migrationManager.register(dropProjectFolderPathColumn);
+    this.migrationManager.register(addProjectKindColumn);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLProjectStore:", error);
@@ -2419,6 +2438,7 @@ var PostgreSQLProjectStore = class {
       name: row.name,
       description: row.description || void 0,
       config: row.config || void 0,
+      kind: row.kind || "business",
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
@@ -2426,16 +2446,22 @@ var PostgreSQLProjectStore = class {
   /**
    * Get all projects for a specific workspace
    */
-  async getProjectsByWorkspace(tenantId, workspaceId) {
+  async getProjectsByWorkspace(tenantId, workspaceId, filter) {
     await this.ensureInitialized();
+    const conditions = ["tenant_id = $1", "workspace_id = $2"];
+    const values = [tenantId, workspaceId];
+    if (filter?.kind !== void 0) {
+      values.push(filter.kind);
+      conditions.push(`kind = $${values.length}`);
+    }
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, workspace_id, name, description, config, created_at, updated_at
+      SELECT id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at
       FROM lattice_projects
-      WHERE tenant_id = $1 AND workspace_id = $2
+      WHERE ${conditions.join(" AND ")}
       ORDER BY created_at DESC
     `,
-      [tenantId, workspaceId]
+      values
     );
     return result.rows.map(this.mapRowToProject);
   }
@@ -2446,7 +2472,7 @@ var PostgreSQLProjectStore = class {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, workspace_id, name, description, config, created_at, updated_at
+      SELECT id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at
       FROM lattice_projects
       WHERE id = $1 AND tenant_id = $2
     `,
@@ -2463,18 +2489,20 @@ var PostgreSQLProjectStore = class {
   async createProject(tenantId, workspaceId, id, data) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
+    const kind = data.kind || "business";
     await this.pool.query(
       `
-      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, config, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
       ON CONFLICT (id, tenant_id) DO UPDATE SET
         workspace_id = EXCLUDED.workspace_id,
         name = EXCLUDED.name,
         description = EXCLUDED.description,
         config = EXCLUDED.config,
+        kind = EXCLUDED.kind,
         updated_at = EXCLUDED.updated_at
     `,
-      [id, tenantId, workspaceId, data.name, data.description || null, data.config || null, now, now]
+      [id, tenantId, workspaceId, data.name, data.description || null, data.config || null, kind, now, now]
     );
     return {
       id,
@@ -2483,6 +2511,7 @@ var PostgreSQLProjectStore = class {
       name: data.name,
       description: data.description,
       config: data.config,
+      kind,
       createdAt: now,
       updatedAt: now
     };
@@ -2515,6 +2544,10 @@ var PostgreSQLProjectStore = class {
       updateFields.push(`config = $${paramIndex++}`);
       updateValues.push(updates.config || null);
     }
+    if (updates.kind !== void 0) {
+      updateFields.push(`kind = $${paramIndex++}`);
+      updateValues.push(updates.kind);
+    }
     if (updateFields.length === 0) {
       return existing;
     }
@@ -5745,6 +5778,24 @@ var createA2AApiKeysTable = {
   }
 };
 
+// src/migrations/add_a2a_key_assistant_ids.ts
+var addA2AKeyAssistantIds = {
+  version: 167,
+  name: "add_a2a_key_assistant_ids",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_a2a_api_keys
+        ADD COLUMN IF NOT EXISTS assistant_ids JSONB
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_a2a_api_keys
+        DROP COLUMN IF EXISTS assistant_ids
+    `);
+  }
+};
+
 // src/stores/PostgreSQLA2AApiKeyStore.ts
 import { encrypt as encrypt5, decrypt as decrypt5 } from "@axiom-lattice/core";
 import { randomUUID } from "crypto";
@@ -5756,8 +5807,8 @@ function mapRowToRecord(row) {
     id: row.id,
     key: decrypt5(row.key_value),
     tenantId: row.tenant_id,
-    projectId: row.project_id || void 0,
-    workspaceId: row.workspace_id || void 0,
+    projectId: row.project_id,
+    assistantIds: row.assistant_ids ?? void 0,
     label: row.label || void 0,
     enabled: row.enabled,
     createdAt: row.created_at,
@@ -5780,6 +5831,7 @@ var PostgreSQLA2AApiKeyStore = class {
     })();
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createA2AApiKeysTable);
+    this.migrationManager.register(addA2AKeyAssistantIds);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLA2AApiKeyStore:", error);
@@ -5818,6 +5870,14 @@ var PostgreSQLA2AApiKeyStore = class {
     }
     return null;
   }
+  async findById(id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_a2a_api_keys WHERE id = $1`,
+      [id]
+    );
+    return result.rows[0] ? mapRowToRecord(result.rows[0]) : null;
+  }
   async list(params) {
     await this.ensureInitialized();
     const limit = params.limit || 100;
@@ -5839,9 +5899,9 @@ var PostgreSQLA2AApiKeyStore = class {
     await this.ensureInitialized();
     const key = generateApiKey();
     const result = await this.pool.query(
-      `INSERT INTO lattice_a2a_api_keys (key_value, tenant_id, project_id, workspace_id, label)
+      `INSERT INTO lattice_a2a_api_keys (key_value, tenant_id, project_id, assistant_ids, label)
        VALUES ($1, $2, $3, $4, $5) RETURNING *`,
-      [encrypt5(key), input.tenantId, input.projectId || null, input.workspaceId || null, input.label || null]
+      [encrypt5(key), input.tenantId, input.projectId, input.assistantIds ? JSON.stringify(input.assistantIds) : null, input.label || null]
     );
     const record = mapRowToRecord(result.rows[0]);
     record.key = key;
@@ -5892,16 +5952,240 @@ var PostgreSQLA2AApiKeyStore = class {
       map.set(key, {
         key,
         tenantId: row.tenant_id,
-        projectId: row.project_id || void 0,
-        workspaceId: row.workspace_id || void 0
+        projectId: row.project_id,
+        assistantIds: row.assistant_ids ?? void 0
       });
     }
     return map;
   }
 };
 
-// src/stores/PostgreSQLScheduleStorage.ts
+// src/stores/PostgreSQLAgentWebAppStore.ts
+import { randomUUID as randomUUID2 } from "crypto";
 import { Pool as Pool17 } from "pg";
+
+// src/migrations/agent_web_apps_migration.ts
+var createAgentWebAppsTable = {
+  version: 169,
+  name: "create_agent_web_apps_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_agent_web_apps (
+        id VARCHAR(255) PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        assistant_id VARCHAR(255) NOT NULL,
+        name VARCHAR(255) NOT NULL,
+        description TEXT,
+        status VARCHAR(32) NOT NULL DEFAULT 'draft'
+          CONSTRAINT chk_lattice_agent_web_apps_status CHECK (status IN ('draft', 'active', 'disabled')),
+        integration JSONB NOT NULL,
+        scope JSONB NOT NULL,
+        features JSONB NOT NULL,
+        appearance JSONB NOT NULL DEFAULT '{}'::jsonb,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', NOW()),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', NOW())
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_agent_web_apps_tenant_assistant
+      ON lattice_agent_web_apps(tenant_id, assistant_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_agent_web_apps_tenant_assistant"
+    );
+    await client.query("DROP TABLE IF EXISTS lattice_agent_web_apps");
+  }
+};
+
+// src/stores/PostgreSQLAgentWebAppStore.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isIntegration(value) {
+  return isRecord(value) && value.type === "react_sdk";
+}
+function isScope(value) {
+  return isRecord(value) && typeof value.defaultProjectId === "string" && isStringArray(value.allowedProjectIds) && (value.defaultModelKey === void 0 || typeof value.defaultModelKey === "string") && (value.allowedModelKeys === void 0 || isStringArray(value.allowedModelKeys));
+}
+function isFeatures(value) {
+  return isRecord(value) && typeof value.projectSelector === "boolean" && typeof value.modelSelector === "boolean" && typeof value.threadManagement === "boolean" && typeof value.attachments === "boolean" && typeof value.hitl === "boolean" && typeof value.genUI === "boolean";
+}
+function isAppearance(value) {
+  return isRecord(value) && (value.title === void 0 || typeof value.title === "string") && (value.welcomeMessage === void 0 || typeof value.welcomeMessage === "string") && (value.primaryColor === void 0 || typeof value.primaryColor === "string");
+}
+function isStatus(value) {
+  return value === "draft" || value === "active" || value === "disabled";
+}
+function mapRow(row) {
+  if (!isStatus(row.status) || !isIntegration(row.integration) || !isScope(row.scope) || !isFeatures(row.features) || !isAppearance(row.appearance)) {
+    throw new Error(`Invalid agent web app row: ${row.id}`);
+  }
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    assistantId: row.assistant_id,
+    name: row.name,
+    description: row.description ?? void 0,
+    status: row.status,
+    integration: row.integration,
+    scope: row.scope,
+    features: row.features,
+    appearance: row.appearance,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var PostgreSQLAgentWebAppStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    this.initPromise = null;
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+    this.pool = typeof options.poolConfig === "string" ? new Pool17({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool17(options.poolConfig) : (() => {
+      throw new Error("Either pool or poolConfig must be provided");
+    })();
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createAgentWebAppsTable);
+    if (options.autoMigrate !== false) {
+      this.startInitialization();
+    }
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    return this.startInitialization();
+  }
+  startInitialization() {
+    this.initPromise = this.migrationManager.migrate().then(() => {
+      this.initialized = true;
+    });
+    void this.initPromise.catch(() => void 0);
+    return this.initPromise;
+  }
+  async dispose() {
+    if (this.ownsPool) await this.pool.end();
+  }
+  async ensureInitialized() {
+    if (!this.initialized) await this.initialize();
+  }
+  async list(tenantId, assistantId) {
+    await this.ensureInitialized();
+    const result = assistantId === void 0 ? await this.pool.query(
+      `SELECT * FROM lattice_agent_web_apps
+         WHERE tenant_id = $1
+         ORDER BY created_at DESC, id DESC`,
+      [tenantId]
+    ) : await this.pool.query(
+      `SELECT * FROM lattice_agent_web_apps
+         WHERE tenant_id = $1 AND assistant_id = $2
+         ORDER BY created_at DESC, id DESC`,
+      [tenantId, assistantId]
+    );
+    return result.rows.map(mapRow);
+  }
+  async getById(tenantId, webAppId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_web_apps
+       WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, webAppId]
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+  async findById(webAppId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_agent_web_apps
+       WHERE id = $1`,
+      [webAppId]
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+  async create(tenantId, input) {
+    await this.ensureInitialized();
+    const id = `webapp_${randomUUID2().replace(/-/g, "")}`;
+    const result = await this.pool.query(
+      `INSERT INTO lattice_agent_web_apps
+       (id, tenant_id, assistant_id, name, description, status, integration, scope, features, appearance)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8::jsonb, $9::jsonb, $10::jsonb)
+       RETURNING *`,
+      [
+        id,
+        tenantId,
+        input.assistantId,
+        input.name,
+        input.description ?? null,
+        "draft",
+        JSON.stringify(input.integration),
+        JSON.stringify(input.scope),
+        JSON.stringify(input.features),
+        JSON.stringify(input.appearance)
+      ]
+    );
+    return mapRow(result.rows[0]);
+  }
+  async update(tenantId, webAppId, patch, options) {
+    await this.ensureInitialized();
+    const assignments = [];
+    const values = [];
+    const add = (column, value) => {
+      values.push(value);
+      assignments.push(`${column} = $${values.length}`);
+    };
+    if (patch.name !== void 0) add("name", patch.name);
+    if (Object.prototype.hasOwnProperty.call(patch, "description")) {
+      add("description", patch.description ?? null);
+    }
+    if (patch.scope !== void 0) {
+      add("scope", JSON.stringify(patch.scope));
+    }
+    if (patch.features !== void 0) {
+      add("features", JSON.stringify(patch.features));
+    }
+    if (patch.appearance !== void 0) {
+      add("appearance", JSON.stringify(patch.appearance));
+    }
+    if (patch.status !== void 0) add("status", patch.status);
+    if (assignments.length === 0) return this.getById(tenantId, webAppId);
+    values.push(tenantId, webAppId);
+    const tenantParam = values.length - 1;
+    const idParam = values.length;
+    const expectedUpdatedAtClause = options?.expectedUpdatedAt ? ` AND date_trunc('milliseconds', updated_at) = $${values.push(options.expectedUpdatedAt)}` : "";
+    const result = await this.pool.query(
+      `UPDATE lattice_agent_web_apps
+       SET ${assignments.join(", ")}, updated_at = GREATEST(
+         date_trunc('milliseconds', clock_timestamp()),
+         updated_at + interval '1 millisecond'
+       )
+       WHERE tenant_id = $${tenantParam} AND id = $${idParam}${expectedUpdatedAtClause}
+       RETURNING *`,
+      values
+    );
+    return result.rows[0] ? mapRow(result.rows[0]) : null;
+  }
+  async delete(tenantId, webAppId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_agent_web_apps
+       WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, webAppId]
+    );
+    return result.rowCount === 1;
+  }
+};
+
+// src/stores/PostgreSQLScheduleStorage.ts
+import { Pool as Pool18 } from "pg";
 import {
   ScheduledTaskStatus
 } from "@axiom-lattice/protocols";
@@ -6078,9 +6362,9 @@ var PostgreSQLScheduleStorage = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool17({ connectionString: options.poolConfig });
+      this.pool = new Pool18({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new Pool17(options.poolConfig);
+      this.pool = new Pool18(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -6518,7 +6802,7 @@ var PostgreSQLScheduleStorage = class {
 };
 
 // src/stores/PostgreSQLTaskStore.ts
-import { Pool as Pool18 } from "pg";
+import { Pool as Pool19 } from "pg";
 
 // src/migrations/task_migration.ts
 var createTasksTable = {
@@ -6617,6 +6901,49 @@ var taskMigrations = [
 
 // src/stores/PostgreSQLTaskStore.ts
 import { v4 as uuidv42 } from "uuid";
+function nextUpdatedAtSql(column = "updated_at") {
+  return `to_char(
+    date_trunc('milliseconds', GREATEST(
+      clock_timestamp(),
+      CASE
+        WHEN ${canonicalTimestampValidationSql(column)}
+          THEN ${column}::timestamptz + interval '1 millisecond'
+        ELSE clock_timestamp()
+      END
+    ))
+      AT TIME ZONE 'UTC',
+    'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'
+  )`;
+}
+function canonicalTimestampValidationSql(column, allowMaximum = false) {
+  const year = `substring(${column} FROM 1 FOR 4)::integer`;
+  const month = `substring(${column} FROM 6 FOR 2)::integer`;
+  const day = `substring(${column} FROM 9 FOR 2)::integer`;
+  return `CASE
+    WHEN ${column} ~ '^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}[.][0-9]{3}Z$' THEN
+      ${allowMaximum ? "" : `${column} <> '9999-12-31T23:59:59.999Z' AND`}
+      ${year} BETWEEN 1 AND 9999
+      AND ${month} BETWEEN 1 AND 12
+      AND ${day} BETWEEN 1 AND CASE
+        WHEN ${month} = 2 THEN CASE
+          WHEN (${year} % 400 = 0) OR (${year} % 4 = 0 AND ${year} % 100 <> 0) THEN 29
+          ELSE 28
+        END
+        WHEN ${month} IN (4, 6, 9, 11) THEN 30
+        ELSE 31
+      END
+      AND substring(${column} FROM 12 FOR 2)::integer BETWEEN 0 AND 23
+      AND substring(${column} FROM 15 FOR 2)::integer BETWEEN 0 AND 59
+      AND substring(${column} FROM 18 FOR 2)::integer BETWEEN 0 AND 59
+    ELSE FALSE
+  END`;
+}
+function canonicalTimestampSnapshotSql(column, parameter, allowMaximum = false) {
+  return `CASE WHEN ${canonicalTimestampValidationSql(column, allowMaximum)}
+    THEN ${column}::timestamptz = ${parameter}::timestamptz
+    ELSE FALSE
+  END`;
+}
 function parseTaskFiles(raw) {
   if (!raw) return void 0;
   try {
@@ -6665,9 +6992,9 @@ var PostgreSQLTaskStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool18({ connectionString: options.poolConfig });
+      this.pool = new Pool19({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new Pool18(options.poolConfig);
+      this.pool = new Pool19(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -6702,7 +7029,7 @@ var PostgreSQLTaskStore = class {
   }
   async create(params) {
     await this.ensureInitialized();
-    const id = uuidv42();
+    const id = params.id ?? uuidv42();
     const now = (/* @__PURE__ */ 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, require_review, dependencies, result, failure_reason, workspace_id, project_id, files, created_at, updated_at)
@@ -6846,7 +7173,7 @@ var PostgreSQLTaskStore = class {
     }
     if (updates.context !== void 0) {
       setClauses.push(`context = $${paramIndex++}`);
-      params.push(JSON.stringify(updates.context));
+      params.push(updates.context === null ? null : JSON.stringify(updates.context));
     }
     if (updates.ownerType !== void 0) {
       setClauses.push(`owner_type = $${paramIndex++}`);
@@ -6883,103 +7210,537 @@ var PostgreSQLTaskStore = class {
     if (setClauses.length === 0) {
       return existing;
     }
-    setClauses.push(`updated_at = $${paramIndex++}`);
-    params.push((/* @__PURE__ */ new Date()).toISOString());
+    setClauses.push(`updated_at = ${nextUpdatedAtSql()}`);
     params.push(tenantId, id);
-    await this.pool.query(
-      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${paramIndex++} AND id = $${paramIndex++}`,
+    const result = await this.pool.query(
+      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${paramIndex++} AND id = $${paramIndex++} AND updated_at <> '9999-12-31T23:59:59.999Z' RETURNING *`,
       params
     );
-    return this.getById(tenantId, id);
+    return result.rows[0] ? mapRowToTask(result.rows[0]) : null;
   }
-  async delete(tenantId, id) {
+  /**
+   * Atomically update a task unless its current status is blocked.
+   *
+   * @param tenantId Tenant identifier.
+   * @param id Task identifier.
+   * @param updates Partial task data to update.
+   * @param blockedStatuses Current statuses that prevent the update.
+   * @returns The updated task, or `null` when missing or blocked.
+   */
+  async updateIfStatusNotIn(tenantId, id, updates, blockedStatuses) {
     await this.ensureInitialized();
-    const result = await this.pool.query(
-      `DELETE FROM lattice_tasks WHERE tenant_id = $1 AND id = $2`,
-      [tenantId, id]
-    );
-    return (result.rowCount ?? 0) > 0;
-  }
-  async dispose() {
-    if (this.ownsPool && this.pool) {
-      await this.pool.end();
+    const setClauses = [];
+    const params = [];
+    let paramIndex = 1;
+    if (updates.title !== void 0) {
+      setClauses.push(`title = $${paramIndex++}`);
+      params.push(updates.title);
     }
-  }
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initialize();
+    if (updates.description !== void 0) {
+      setClauses.push(`description = $${paramIndex++}`);
+      params.push(updates.description);
     }
-  }
-};
-
-// src/stores/PostgreSQLTaskWorkItemStore.ts
-import { v4 } from "uuid";
-var PostgreSQLTaskWorkItemStore = class {
-  constructor(pool) {
-    this.pool = pool;
-  }
-  async create(params) {
-    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) {
-    let query = `SELECT * FROM lattice_task_work_items WHERE tenant_id = $1 AND task_id = $2`;
-    const params = [filter.tenantId, filter.taskId];
-    if (filter.action) {
-      query += ` AND action = $${params.length + 1}`;
-      params.push(filter.action);
+    if (updates.status !== void 0) {
+      setClauses.push(`status = $${paramIndex++}`);
+      params.push(updates.status);
     }
-    query += ` ORDER BY created_at ASC`;
-    if (filter.limit) {
-      query += ` LIMIT $${params.length + 1}`;
-      params.push(filter.limit);
+    if (updates.priority !== void 0) {
+      setClauses.push(`priority = $${paramIndex++}`);
+      params.push(updates.priority);
     }
-    if (filter.offset) {
-      query += ` OFFSET $${params.length + 1}`;
-      params.push(filter.offset);
+    if (updates.dueDate !== void 0) {
+      setClauses.push(`due_date = $${paramIndex++}`);
+      params.push(updates.dueDate);
     }
-    const result = await this.pool.query(query, params);
-    return result.rows.map((row) => this.rowToItem(row));
-  }
-  rowToItem(row) {
-    return {
-      id: row.id,
-      taskId: row.task_id,
-      tenantId: row.tenant_id,
-      action: row.action,
-      actor: row.actor,
-      threadId: row.thread_id,
-      summary: row.summary,
-      detail: row.detail,
-      attempt: row.attempt,
-      workspaceId: row.workspace_id,
-      projectId: row.project_id,
-      createdAt: new Date(row.created_at)
-    };
-  }
+    if (updates.metadata !== void 0) {
+      setClauses.push(`metadata = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.files !== void 0) {
+      setClauses.push(`files = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.files));
+    }
+    if (updates.parentId !== void 0) {
+      setClauses.push(`parent_id = $${paramIndex++}`);
+      params.push(updates.parentId);
+    }
+    if (updates.sourceId !== void 0) {
+      setClauses.push(`source_id = $${paramIndex++}`);
+      params.push(updates.sourceId);
+    }
+    if (updates.context !== void 0) {
+      setClauses.push(`context = $${paramIndex++}`);
+      params.push(updates.context === null ? null : JSON.stringify(updates.context));
+    }
+    if (updates.ownerType !== void 0) {
+      setClauses.push(`owner_type = $${paramIndex++}`);
+      params.push(updates.ownerType);
+    }
+    if (updates.ownerId !== void 0) {
+      setClauses.push(`owner_id = $${paramIndex++}`);
+      params.push(updates.ownerId);
+    }
+    if (updates.requireReview !== void 0) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== void 0) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== void 0) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== void 0) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== void 0) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== void 0) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
+    setClauses.push(`updated_at = ${nextUpdatedAtSql()}`);
+    const tenantParam = paramIndex++;
+    const idParam = paramIndex++;
+    params.push(tenantId, id);
+    const blockedClause = blockedStatuses.length > 0 ? ` AND status <> ALL($${paramIndex}::text[])` : "";
+    if (blockedStatuses.length > 0) params.push(blockedStatuses);
+    const result = await this.pool.query(
+      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${tenantParam} AND id = $${idParam} AND updated_at <> '9999-12-31T23:59:59.999Z'${blockedClause} RETURNING *`,
+      params
+    );
+    return result.rows[0] ? mapRowToTask(result.rows[0]) : null;
+  }
+  /** Atomically update a task only when its current status is expected. */
+  async updateIfStatusIn(tenantId, id, updates, expectedStatuses) {
+    await this.ensureInitialized();
+    if (expectedStatuses.length === 0) return null;
+    const setClauses = [];
+    const params = [];
+    let paramIndex = 1;
+    if (updates.title !== void 0) {
+      setClauses.push(`title = $${paramIndex++}`);
+      params.push(updates.title);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push(`description = $${paramIndex++}`);
+      params.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push(`status = $${paramIndex++}`);
+      params.push(updates.status);
+    }
+    if (updates.priority !== void 0) {
+      setClauses.push(`priority = $${paramIndex++}`);
+      params.push(updates.priority);
+    }
+    if (updates.dueDate !== void 0) {
+      setClauses.push(`due_date = $${paramIndex++}`);
+      params.push(updates.dueDate);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push(`metadata = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.files !== void 0) {
+      setClauses.push(`files = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.files));
+    }
+    if (updates.parentId !== void 0) {
+      setClauses.push(`parent_id = $${paramIndex++}`);
+      params.push(updates.parentId);
+    }
+    if (updates.sourceId !== void 0) {
+      setClauses.push(`source_id = $${paramIndex++}`);
+      params.push(updates.sourceId);
+    }
+    if (updates.context !== void 0) {
+      setClauses.push(`context = $${paramIndex++}`);
+      params.push(updates.context === null ? null : JSON.stringify(updates.context));
+    }
+    if (updates.ownerType !== void 0) {
+      setClauses.push(`owner_type = $${paramIndex++}`);
+      params.push(updates.ownerType);
+    }
+    if (updates.ownerId !== void 0) {
+      setClauses.push(`owner_id = $${paramIndex++}`);
+      params.push(updates.ownerId);
+    }
+    if (updates.requireReview !== void 0) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== void 0) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== void 0) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== void 0) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== void 0) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== void 0) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
+    setClauses.push(`updated_at = ${nextUpdatedAtSql()}`);
+    const tenantParam = paramIndex++;
+    const idParam = paramIndex++;
+    const statusesParam = paramIndex++;
+    params.push(tenantId, id, expectedStatuses);
+    const result = await this.pool.query(
+      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${tenantParam} AND id = $${idParam} AND updated_at <> '9999-12-31T23:59:59.999Z' AND status = ANY($${statusesParam}::text[]) RETURNING *`,
+      params
+    );
+    return result.rows[0] ? mapRowToTask(result.rows[0]) : null;
+  }
+  /** Atomically update a task only when status and updatedAt match a read snapshot. */
+  async updateIfStatusAndUpdatedAt(tenantId, id, updates, expectedStatuses, expectedUpdatedAt) {
+    await this.ensureInitialized();
+    if (expectedStatuses.length === 0) return null;
+    const expectedIso = new Date(expectedUpdatedAt).toISOString();
+    const setClauses = [];
+    const params = [];
+    let paramIndex = 1;
+    if (updates.title !== void 0) {
+      setClauses.push(`title = $${paramIndex++}`);
+      params.push(updates.title);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push(`description = $${paramIndex++}`);
+      params.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push(`status = $${paramIndex++}`);
+      params.push(updates.status);
+    }
+    if (updates.priority !== void 0) {
+      setClauses.push(`priority = $${paramIndex++}`);
+      params.push(updates.priority);
+    }
+    if (updates.dueDate !== void 0) {
+      setClauses.push(`due_date = $${paramIndex++}`);
+      params.push(updates.dueDate);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push(`metadata = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.files !== void 0) {
+      setClauses.push(`files = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.files));
+    }
+    if (updates.parentId !== void 0) {
+      setClauses.push(`parent_id = $${paramIndex++}`);
+      params.push(updates.parentId);
+    }
+    if (updates.sourceId !== void 0) {
+      setClauses.push(`source_id = $${paramIndex++}`);
+      params.push(updates.sourceId);
+    }
+    if (updates.context !== void 0) {
+      setClauses.push(`context = $${paramIndex++}`);
+      params.push(updates.context === null ? null : JSON.stringify(updates.context));
+    }
+    if (updates.ownerType !== void 0) {
+      setClauses.push(`owner_type = $${paramIndex++}`);
+      params.push(updates.ownerType);
+    }
+    if (updates.ownerId !== void 0) {
+      setClauses.push(`owner_id = $${paramIndex++}`);
+      params.push(updates.ownerId);
+    }
+    if (updates.requireReview !== void 0) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== void 0) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== void 0) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== void 0) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== void 0) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== void 0) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
+    setClauses.push(`updated_at = ${nextUpdatedAtSql()}`);
+    const tenantParam = paramIndex++;
+    const idParam = paramIndex++;
+    const statusesParam = paramIndex++;
+    const updatedAtParam = paramIndex++;
+    params.push(tenantId, id, expectedStatuses, expectedIso);
+    const result = await this.pool.query(
+      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${tenantParam} AND id = $${idParam} AND status = ANY($${statusesParam}::text[]) AND ${canonicalTimestampSnapshotSql("updated_at", `$${updatedAtParam}`)} RETURNING *`,
+      params
+    );
+    return result.rows[0] ? mapRowToTask(result.rows[0]) : null;
+  }
+  /** Atomically update a child only when both child and parent snapshots match. */
+  async updateIfStatusUpdatedAtAndParentUpdatedAt(tenantId, id, updates, expectedStatuses, expectedUpdatedAt, parentId, expectedParentUpdatedAt) {
+    await this.ensureInitialized();
+    if (expectedStatuses.length === 0) return null;
+    const setClauses = [];
+    const params = [];
+    let paramIndex = 1;
+    if (updates.title !== void 0) {
+      setClauses.push(`title = $${paramIndex++}`);
+      params.push(updates.title);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push(`description = $${paramIndex++}`);
+      params.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push(`status = $${paramIndex++}`);
+      params.push(updates.status);
+    }
+    if (updates.priority !== void 0) {
+      setClauses.push(`priority = $${paramIndex++}`);
+      params.push(updates.priority);
+    }
+    if (updates.dueDate !== void 0) {
+      setClauses.push(`due_date = $${paramIndex++}`);
+      params.push(updates.dueDate);
+    }
+    if (updates.metadata !== void 0) {
+      setClauses.push(`metadata = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.metadata));
+    }
+    if (updates.files !== void 0) {
+      setClauses.push(`files = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.files));
+    }
+    if (updates.parentId !== void 0) {
+      setClauses.push(`parent_id = $${paramIndex++}`);
+      params.push(updates.parentId);
+    }
+    if (updates.sourceId !== void 0) {
+      setClauses.push(`source_id = $${paramIndex++}`);
+      params.push(updates.sourceId);
+    }
+    if (updates.context !== void 0) {
+      setClauses.push(`context = $${paramIndex++}`);
+      params.push(updates.context === null ? null : JSON.stringify(updates.context));
+    }
+    if (updates.ownerType !== void 0) {
+      setClauses.push(`owner_type = $${paramIndex++}`);
+      params.push(updates.ownerType);
+    }
+    if (updates.ownerId !== void 0) {
+      setClauses.push(`owner_id = $${paramIndex++}`);
+      params.push(updates.ownerId);
+    }
+    if (updates.requireReview !== void 0) {
+      setClauses.push(`require_review = $${paramIndex++}`);
+      params.push(updates.requireReview);
+    }
+    if (updates.dependencies !== void 0) {
+      setClauses.push(`dependencies = $${paramIndex++}`);
+      params.push(JSON.stringify(updates.dependencies));
+    }
+    if (updates.result !== void 0) {
+      setClauses.push(`result = $${paramIndex++}`);
+      params.push(updates.result);
+    }
+    if (updates.failureReason !== void 0) {
+      setClauses.push(`failure_reason = $${paramIndex++}`);
+      params.push(updates.failureReason);
+    }
+    if (updates.workspaceId !== void 0) {
+      setClauses.push(`workspace_id = $${paramIndex++}`);
+      params.push(updates.workspaceId);
+    }
+    if (updates.projectId !== void 0) {
+      setClauses.push(`project_id = $${paramIndex++}`);
+      params.push(updates.projectId);
+    }
+    setClauses.push(`updated_at = ${nextUpdatedAtSql("child.updated_at")}`);
+    const tenantParam = paramIndex++;
+    const idParam = paramIndex++;
+    const statusesParam = paramIndex++;
+    const updatedAtParam = paramIndex++;
+    const parentIdParam = paramIndex++;
+    const parentUpdatedAtParam = paramIndex++;
+    params.push(
+      tenantId,
+      id,
+      expectedStatuses,
+      new Date(expectedUpdatedAt).toISOString(),
+      parentId,
+      new Date(expectedParentUpdatedAt).toISOString()
+    );
+    const result = await this.pool.query(
+      `UPDATE lattice_tasks AS child SET ${setClauses.join(", ")}
+       WHERE child.tenant_id = $${tenantParam} AND child.id = $${idParam}
+         AND child.status = ANY($${statusesParam}::text[])
+         AND ${canonicalTimestampSnapshotSql("child.updated_at", `$${updatedAtParam}`)}
+         AND EXISTS (
+           SELECT 1 FROM lattice_tasks AS parent
+           WHERE parent.tenant_id = child.tenant_id
+             AND parent.id = $${parentIdParam}
+             AND ${canonicalTimestampSnapshotSql("parent.updated_at", `$${parentUpdatedAtParam}`, true)}
+         )
+       RETURNING child.*`,
+      params
+    );
+    return result.rows[0] ? mapRowToTask(result.rows[0]) : null;
+  }
+  async delete(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `DELETE FROM lattice_tasks WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, id]
+    );
+    return (result.rowCount ?? 0) > 0;
+  }
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+};
+
+// src/stores/PostgreSQLTaskWorkItemStore.ts
+import { v4 } from "uuid";
+var PostgreSQLTaskWorkItemStore = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  async create(params) {
+    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]);
+  }
+  /** Find an event by its tenant- and task-scoped key without pagination. */
+  async findByEventKey(tenantId, taskId, eventKey) {
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_task_work_items
+       WHERE tenant_id = $1 AND task_id = $2 AND event_key = $3`,
+      [tenantId, taskId, eventKey]
+    );
+    return result.rows[0] ? this.rowToItem(result.rows[0]) : null;
+  }
+  /** Atomically return an existing event or create it once. */
+  async createIfAbsentByEventKey(params) {
+    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, event_key)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT (tenant_id, task_id, event_key) WHERE event_key IS NOT NULL
+       DO UPDATE SET event_key = EXCLUDED.event_key
+       RETURNING *`,
+      [
+        v4(),
+        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,
+        params.eventKey
+      ]
+    );
+    return this.rowToItem(result.rows[0]);
+  }
+  async list(filter) {
+    let query = `SELECT * FROM lattice_task_work_items WHERE tenant_id = $1 AND task_id = $2`;
+    const params = [filter.tenantId, filter.taskId];
+    if (filter.action) {
+      query += ` AND action = $${params.length + 1}`;
+      params.push(filter.action);
+    }
+    if (filter.workspaceId) {
+      query += ` AND workspace_id = $${params.length + 1}`;
+      params.push(filter.workspaceId);
+    }
+    if (filter.projectId) {
+      query += ` AND project_id = $${params.length + 1}`;
+      params.push(filter.projectId);
+    }
+    const order = filter.order === "desc" ? "DESC" : "ASC";
+    query += ` ORDER BY created_at ${order}, id ${order}`;
+    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) => this.rowToItem(row));
+  }
+  rowToItem(row) {
+    return {
+      id: row.id,
+      taskId: row.task_id,
+      tenantId: row.tenant_id,
+      action: row.action,
+      actor: row.actor,
+      threadId: row.thread_id,
+      summary: row.summary,
+      detail: row.detail,
+      attempt: row.attempt,
+      workspaceId: row.workspace_id,
+      projectId: row.project_id,
+      eventKey: row.event_key == null ? void 0 : row.event_key,
+      createdAt: new Date(row.created_at)
+    };
+  }
 };
 
 // src/stores/MenuStore.ts
-import { Pool as Pool19 } from "pg";
+import { Pool as Pool20 } from "pg";
 
 // src/migrations/menu_items_migration.ts
 var createMenuItemsTable = {
@@ -7056,7 +7817,7 @@ var MenuStore = class {
       this.initialized = true;
       return;
     }
-    this.pool = typeof options.poolConfig === "string" ? new Pool19({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool19(options.poolConfig) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new Pool20({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool20(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -7211,7 +7972,7 @@ var MenuStore = class {
 };
 
 // src/stores/PostgresSharedResourceStore.ts
-import { Pool as Pool20 } from "pg";
+import { Pool as Pool21 } from "pg";
 
 // src/migrations/shared_resources_migration.ts
 var createSharedResourcesTable = {
@@ -7265,7 +8026,7 @@ var PostgresSharedResourceStore = class {
       this.initialized = true;
       return;
     }
-    this.pool = typeof options.poolConfig === "string" ? new Pool20({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool20(options.poolConfig) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new Pool21({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool21(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -7434,7 +8195,7 @@ var PostgresSharedResourceStore = class {
 };
 
 // src/stores/PostgreSQLCollectionStore.ts
-import { Pool as Pool21 } from "pg";
+import { Pool as Pool22 } from "pg";
 var PostgreSQLCollectionStore = class {
   constructor(options) {
     this.initialized = false;
@@ -7447,9 +8208,9 @@ var PostgreSQLCollectionStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool21({ connectionString: options.poolConfig });
+      this.pool = new Pool22({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new Pool21(options.poolConfig);
+      this.pool = new Pool22(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -7564,7 +8325,7 @@ var PostgreSQLCollectionStore = class {
 import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
 
 // src/PGVectorStoreProvider.ts
-import { Pool as Pool22 } from "pg";
+import { Pool as Pool23 } from "pg";
 import { PGVectorStore } from "@langchain/community/vectorstores/pgvector";
 import { Document } from "@langchain/core/documents";
 import { embeddingsLatticeManager } from "@axiom-lattice/core";
@@ -7638,7 +8399,7 @@ var PGVectorStoreProvider = class {
   }
 };
 function createPGVectorStoreProvider(connectionString) {
-  const pool = new Pool22({ connectionString });
+  const pool = new Pool23({ connectionString });
   return {
     provider: new PGVectorStoreProvider(pool, connectionString),
     pool
@@ -7972,10 +8733,24 @@ var addWorkItemProjectFieldsMigration = {
     `);
   }
 };
+var addTaskWorkItemEventKeyMigration = {
+  version: 168,
+  name: "add_task_work_item_event_key",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_task_work_items
+        ADD COLUMN IF NOT EXISTS event_key TEXT
+    `);
+    await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_task_work_items_event_key
+        ON lattice_task_work_items (tenant_id, task_id, event_key) WHERE event_key IS NOT NULL
+    `);
+  }
+};
 
 // src/createPgStoreConfig.ts
 async function createPgStoreConfig(connectionString) {
-  const pool = new Pool23({ connectionString });
+  const pool = new Pool24({ connectionString });
   const mm = new MigrationManager(pool);
   mm.register(createThreadsTable);
   mm.register(createScheduledTasksTable);
@@ -8026,6 +8801,10 @@ async function createPgStoreConfig(connectionString) {
   mm.register(addWorkItemProjectFieldsMigration);
   mm.register(createConnectionConfigsTable);
   mm.register(addWorkflowRunsTenantStatusUpdatedIndex);
+  mm.register(addProjectKindColumn);
+  mm.register(addA2AKeyAssistantIds);
+  mm.register(addTaskWorkItemEventKeyMigration);
+  mm.register(createAgentWebAppsTable);
   await mm.migrate();
   const checkpoint = PostgresSaver.fromConnString(connectionString);
   checkpoint.setup().catch((err) => {
@@ -8053,6 +8832,7 @@ async function createPgStoreConfig(connectionString) {
     task: new PostgreSQLTaskStore(opts),
     taskWorkItem: taskWorkItemStore,
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
+    agentWebApp: new PostgreSQLAgentWebAppStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),
     sharedResource: new PostgresSharedResourceStore(opts),
@@ -8063,7 +8843,7 @@ async function createPgStoreConfig(connectionString) {
 }
 
 // src/stores/PostgreSQLSkillStore.ts
-import { Pool as Pool24 } from "pg";
+import { Pool as Pool25 } from "pg";
 var PostgreSQLSkillStore = class {
   constructor(options) {
     this.initialized = false;
@@ -8076,9 +8856,9 @@ var PostgreSQLSkillStore = class {
       return;
     }
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool24({ connectionString: options.poolConfig });
+      this.pool = new Pool25({ connectionString: options.poolConfig });
     } else if (options.poolConfig) {
-      this.pool = new Pool24(options.poolConfig);
+      this.pool = new Pool25(options.poolConfig);
     } else {
       throw new Error("Either pool or poolConfig must be provided");
     }
@@ -8379,7 +9159,7 @@ var PostgreSQLSkillStore = class {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-import { Pool as Pool25 } from "pg";
+import { Pool as Pool26 } from "pg";
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
@@ -8391,7 +9171,7 @@ var ChannelIdentityMappingStore = class {
       this.initialized = true;
       return;
     }
-    this.pool = typeof options.poolConfig === "string" ? new Pool25({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool25(options.poolConfig) : (() => {
+    this.pool = typeof options.poolConfig === "string" ? new Pool26({ connectionString: options.poolConfig }) : options.poolConfig ? new Pool26(options.poolConfig) : (() => {
       throw new Error("Either pool or poolConfig must be provided");
     })();
     this.migrationManager = new MigrationManager(this.pool);
@@ -8615,8 +9395,9 @@ export {
   MenuStore,
   MigrationManager,
   PGVectorStoreProvider,
-  Pool26 as Pool,
+  Pool27 as Pool,
   PostgreSQLA2AApiKeyStore,
+  PostgreSQLAgentWebAppStore,
   PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore,
   PostgreSQLCollectionStore,
@@ -8654,6 +9435,7 @@ export {
   changeSkillPrimaryKey,
   changeThreadPrimaryKey,
   createA2AApiKeysTable,
+  createAgentWebAppsTable,
   createAssistantsTable,
   createChannelBindingsTable,
   createChannelIdentityMappingTables,