@axiom-lattice/pg-stores 1.0.70 → 1.0.72

package/dist/index.js

@@ -32,8 +32,9 @@ var index_exports = {};
 __export(index_exports, {
   ChannelBindingStore: () => ChannelBindingStore,
   ChannelIdentityMappingStore: () => ChannelIdentityMappingStore,
+  MenuStore: () => MenuStore,
   MigrationManager: () => MigrationManager,
-  Pool: () => import_pg20.Pool,
+  Pool: () => import_pg22.Pool,
   PostgreSQLA2AApiKeyStore: () => PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore: () => PostgreSQLChannelInstallationStore,
@@ -55,6 +56,7 @@ __export(index_exports, {
   addProjectConfigColumn: () => addProjectConfigColumn,
   addScheduleTenantId: () => addScheduleTenantId,
   addSkillTenantId: () => addSkillTenantId,
+  addStepThreadId: () => addStepThreadId,
   addThreadTenantId: () => addThreadTenantId,
   alterChannelInstallationsTable: () => alterChannelInstallationsTable,
   changeAssistantPrimaryKey: () => changeAssistantPrimaryKey,
@@ -72,6 +74,7 @@ __export(index_exports, {
   createEvalRunsTable: () => createEvalRunsTable,
   createEvalSuitesTable: () => createEvalSuitesTable,
   createMcpServerConfigsTable: () => createMcpServerConfigsTable,
+  createMenuItemsTable: () => createMenuItemsTable,
   createMetricsConfigsTable: () => createMetricsConfigsTable,
   createPgStoreConfig: () => createPgStoreConfig,
   createProjectsTable: () => createProjectsTable,
@@ -86,7 +89,7 @@ __export(index_exports, {
   evalMigrations: () => evalMigrations
 });
 module.exports = __toCommonJS(index_exports);
-var import_pg20 = require("pg");
+var import_pg22 = require("pg");
 
 // src/stores/PostgreSQLThreadStore.ts
 var import_pg = require("pg");
@@ -690,6 +693,30 @@ var changeAssistantPrimaryKey = {
   }
 };
 
+// src/migrations/assistant_owner_user_migration.ts
+var addAssistantOwnerUserId = {
+  version: 132,
+  name: "add_assistant_owner_user_id",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_assistants
+      ADD COLUMN IF NOT EXISTS owner_user_id VARCHAR(255)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_assistants_owner_user_id
+      ON lattice_assistants(owner_user_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "DROP INDEX IF EXISTS idx_lattice_assistants_owner_user_id"
+    );
+    await client.query(
+      "ALTER TABLE lattice_assistants DROP COLUMN IF EXISTS owner_user_id"
+    );
+  }
+};
+
 // src/stores/PostgreSQLAssistantStore.ts
 var PostgreSQLAssistantStore = class {
   constructor(options) {
@@ -705,6 +732,7 @@ var PostgreSQLAssistantStore = class {
     this.migrationManager.register(createAssistantsTable);
     this.migrationManager.register(addAssistantTenantId);
     this.migrationManager.register(changeAssistantPrimaryKey);
+    this.migrationManager.register(addAssistantOwnerUserId);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLAssistantStore:", error);
@@ -740,7 +768,7 @@ var PostgreSQLAssistantStore = class {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, name, description, graph_definition, created_at, updated_at
+      SELECT id, tenant_id, name, description, graph_definition, owner_user_id, created_at, updated_at
       FROM lattice_assistants
       WHERE tenant_id = $1
       ORDER BY created_at DESC
@@ -756,7 +784,7 @@ var PostgreSQLAssistantStore = class {
     await this.ensureInitialized();
     const result = await this.pool.query(
       `
-      SELECT id, tenant_id, name, description, graph_definition, created_at, updated_at
+      SELECT id, tenant_id, name, description, graph_definition, owner_user_id, created_at, updated_at
       FROM lattice_assistants
       WHERE tenant_id = $1 AND id = $2
     `,
@@ -775,12 +803,13 @@ var PostgreSQLAssistantStore = class {
     const now = /* @__PURE__ */ new Date();
     await this.pool.query(
       `
-      INSERT INTO lattice_assistants (id, tenant_id, name, description, graph_definition, created_at, updated_at)
-      VALUES ($1, $2, $3, $4, $5, $6, $7)
+      INSERT INTO lattice_assistants (id, tenant_id, name, description, graph_definition, owner_user_id, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
       ON CONFLICT (id, tenant_id) DO UPDATE SET
         name = EXCLUDED.name,
         description = EXCLUDED.description,
         graph_definition = EXCLUDED.graph_definition,
+        owner_user_id = EXCLUDED.owner_user_id,
         updated_at = EXCLUDED.updated_at
     `,
       [
@@ -789,6 +818,7 @@ var PostgreSQLAssistantStore = class {
         data.name,
         data.description || null,
         JSON.stringify(data.graphDefinition),
+        data.ownerUserId || null,
         now,
         now
       ]
@@ -799,6 +829,7 @@ var PostgreSQLAssistantStore = class {
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
+      ownerUserId: data.ownerUserId,
       createdAt: now,
       updatedAt: now
     };
@@ -827,6 +858,10 @@ var PostgreSQLAssistantStore = class {
       updateFields.push(`graph_definition = $${paramIndex++}`);
       updateValues.push(JSON.stringify(updates.graphDefinition));
     }
+    if (updates.ownerUserId !== void 0) {
+      updateFields.push(`owner_user_id = $${paramIndex++}`);
+      updateValues.push(updates.ownerUserId || null);
+    }
     if (updateFields.length === 0) {
       return existing;
     }
@@ -873,6 +908,23 @@ var PostgreSQLAssistantStore = class {
     );
     return result.rows.length > 0;
   }
+  /**
+   * Get assistant by owner user ID
+   */
+  async getByOwner(tenantId, userId) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, tenant_id, name, description, graph_definition, owner_user_id, created_at, updated_at
+      FROM lattice_assistants
+      WHERE tenant_id = $1 AND owner_user_id = $2
+      LIMIT 1
+    `,
+      [tenantId, userId]
+    );
+    if (result.rows.length === 0) return null;
+    return this.mapRowToAssistant(result.rows[0]);
+  }
   /**
    * Dispose resources and close the connection pool
    * Should be called when the store is no longer needed
@@ -900,6 +952,7 @@ var PostgreSQLAssistantStore = class {
       name: row.name,
       description: row.description || void 0,
       graphDefinition: typeof row.graph_definition === "string" ? JSON.parse(row.graph_definition) : row.graph_definition,
+      ownerUserId: row.owner_user_id || void 0,
       createdAt: row.created_at,
       updatedAt: row.updated_at
     };
@@ -3096,6 +3149,22 @@ var createWorkflowTrackingTables = {
     `);
   }
 };
+var addStepThreadId = {
+  name: "add_step_thread_id",
+  version: 113,
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_workflow_steps
+      ADD COLUMN IF NOT EXISTS thread_id VARCHAR(255);
+    `);
+  },
+  down: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_workflow_steps
+      DROP COLUMN IF EXISTS thread_id;
+    `);
+  }
+};
 
 // src/stores/PostgreSQLWorkflowTrackingStore.ts
 var PostgreSQLWorkflowTrackingStore = class {
@@ -3109,6 +3178,7 @@ var PostgreSQLWorkflowTrackingStore = class {
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createWorkflowTrackingTables);
+    this.migrationManager.register(addStepThreadId);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize PostgreSQLWorkflowTrackingStore:", error);
@@ -3241,8 +3311,8 @@ var PostgreSQLWorkflowTrackingStore = class {
     const now = /* @__PURE__ */ new Date();
     const id = `step_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     await this.pool.query(
-      `INSERT INTO lattice_workflow_steps (id, run_id, tenant_id, step_type, step_name, edge_from, edge_to, edge_purpose, input, status, started_at, created_at, updated_at)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+      `INSERT INTO lattice_workflow_steps (id, run_id, tenant_id, step_type, step_name, edge_from, edge_to, edge_purpose, input, thread_id, status, started_at, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)`,
       [
         id,
         request.runId,
@@ -3253,6 +3323,7 @@ var PostgreSQLWorkflowTrackingStore = class {
         request.edgeTo || null,
         request.edgePurpose || null,
         request.input ? JSON.stringify(request.input) : null,
+        request.threadId || null,
         "running",
         now,
         now,
@@ -3265,6 +3336,7 @@ var PostgreSQLWorkflowTrackingStore = class {
       tenantId: request.tenantId,
       stepType: request.stepType,
       stepName: request.stepName,
+      threadId: request.threadId,
       edgeFrom: request.edgeFrom,
       edgeTo: request.edgeTo,
       edgePurpose: request.edgePurpose,
@@ -3275,6 +3347,25 @@ var PostgreSQLWorkflowTrackingStore = class {
       updatedAt: now
     };
   }
+  async upsertRunStep(request) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_workflow_steps WHERE run_id = $1 AND step_type = $2 AND step_name = $3`,
+      [request.runId, request.stepType, request.stepName]
+    );
+    if (result.rows.length > 0) {
+      const existing = this.mapRowToRunStep(result.rows[0]);
+      if (!existing.threadId && request.threadId) {
+        await this.pool.query(
+          `UPDATE lattice_workflow_steps SET thread_id = $1, updated_at = $2 WHERE run_id = $3 AND id = $4`,
+          [request.threadId, /* @__PURE__ */ new Date(), request.runId, existing.id]
+        );
+        existing.threadId = request.threadId;
+      }
+      return existing;
+    }
+    return this.createRunStep(request);
+  }
   async updateRunStep(runId, stepId, updates) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
@@ -3359,6 +3450,7 @@ var PostgreSQLWorkflowTrackingStore = class {
       tenantId: row.tenant_id,
       stepType: row.step_type,
       stepName: row.step_name,
+      threadId: row.thread_id,
       edgeFrom: row.edge_from,
       edgeTo: row.edge_to,
       edgePurpose: row.edge_purpose,
@@ -4411,6 +4503,30 @@ var alterMessageQueueIdColumn = {
   }
 };
 
+// src/migrations/add_workspace_project_to_queue.ts
+var addWorkspaceProjectToQueue = {
+  version: 131,
+  name: "add_workspace_project_to_queue",
+  up: async (client) => {
+    await client.query(`
+      ALTER TABLE lattice_thread_message_queue
+      ADD COLUMN IF NOT EXISTS workspace_id VARCHAR(255)
+    `);
+    await client.query(`
+      ALTER TABLE lattice_thread_message_queue
+      ADD COLUMN IF NOT EXISTS project_id VARCHAR(255)
+    `);
+  },
+  down: async (client) => {
+    await client.query(
+      "ALTER TABLE lattice_thread_message_queue DROP COLUMN IF EXISTS workspace_id"
+    );
+    await client.query(
+      "ALTER TABLE lattice_thread_message_queue DROP COLUMN IF EXISTS project_id"
+    );
+  }
+};
+
 // src/stores/ThreadMessageQueueStore.ts
 var ThreadMessageQueueStore = class {
   constructor(options) {
@@ -4427,6 +4543,7 @@ var ThreadMessageQueueStore = class {
     this.migrationManager.register(addPriorityAndCommandColumns);
     this.migrationManager.register(addCustomRunConfigColumn);
     this.migrationManager.register(alterMessageQueueIdColumn);
+    this.migrationManager.register(addWorkspaceProjectToQueue);
     if (options.autoMigrate !== false) {
       this.initialize().catch((error) => {
         console.error("Failed to initialize ThreadMessageQueueStore:", error);
@@ -4456,7 +4573,7 @@ var ThreadMessageQueueStore = class {
    * Add message to queue
    */
   async addMessage(params) {
-    const { threadId, tenantId, assistantId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "human", priority = 0, command, custom_run_config, id } = params;
     const seqResult = await this.pool.query(
       `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq
        FROM lattice_thread_message_queue 
@@ -4466,10 +4583,10 @@ var ThreadMessageQueueStore = class {
     const nextSeq = seqResult.rows[0].next_seq;
     const result = await this.pool.query(
       `INSERT INTO lattice_thread_message_queue 
-       (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+       (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
        RETURNING *`,
-      [id || import_crypto.default.randomUUID(), threadId, tenantId, assistantId, JSON.stringify(content), type, nextSeq, priority, command ? JSON.stringify(command) : null, custom_run_config ? JSON.stringify(custom_run_config) : null]
+      [id || import_crypto.default.randomUUID(), threadId, tenantId, assistantId, workspaceId || null, projectId || null, JSON.stringify(content), type, nextSeq, priority, command ? JSON.stringify(command) : null, custom_run_config ? JSON.stringify(custom_run_config) : null]
     );
     return this.rowToMessage(result.rows[0]);
   }
@@ -4478,7 +4595,7 @@ var ThreadMessageQueueStore = class {
    * Uses priority=100 to ensure message is processed first
    */
   async addMessageAtHead(params) {
-    const { threadId, tenantId, assistantId, content, type = "human", command, custom_run_config, id } = params;
+    const { threadId, tenantId, assistantId, workspaceId, projectId, content, type = "human", command, custom_run_config, id } = params;
     const resolvedTenantId = tenantId;
     const resolvedAssistantId = assistantId;
     const seqResult = await this.pool.query(
@@ -4490,10 +4607,10 @@ var ThreadMessageQueueStore = class {
     const nextSeq = seqResult.rows[0].next_seq;
     const result = await this.pool.query(
       `INSERT INTO lattice_thread_message_queue 
-       (id, thread_id, tenant_id, assistant_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, 100, $8, $9)
+       (id, thread_id, tenant_id, assistant_id, workspace_id, project_id, message_content, message_type, sequence_order, priority, command, custom_run_config)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 100, $10, $11)
        RETURNING *`,
-      [id || import_crypto.default.randomUUID(), threadId, resolvedTenantId, resolvedAssistantId, JSON.stringify(content), type, nextSeq, command ? JSON.stringify(command) : null, custom_run_config ? JSON.stringify(custom_run_config) : null]
+      [id || import_crypto.default.randomUUID(), threadId, resolvedTenantId, resolvedAssistantId, workspaceId || null, projectId || null, JSON.stringify(content), type, nextSeq, command ? JSON.stringify(command) : null, custom_run_config ? JSON.stringify(custom_run_config) : null]
     );
     return this.rowToMessage(result.rows[0]);
   }
@@ -4537,7 +4654,7 @@ var ThreadMessageQueueStore = class {
    */
   async getThreadsWithPendingMessages() {
     const result = await this.pool.query(
-      `SELECT DISTINCT tenant_id, assistant_id, thread_id 
+      `SELECT DISTINCT ON (thread_id) tenant_id, assistant_id, thread_id, workspace_id, project_id
        FROM lattice_thread_message_queue 
        WHERE status IN ('pending', 'processing')
        ORDER BY thread_id`
@@ -4545,7 +4662,9 @@ var ThreadMessageQueueStore = class {
     return result.rows.map((row) => ({
       tenantId: row.tenant_id,
       assistantId: row.assistant_id,
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      workspaceId: row.workspace_id || void 0,
+      projectId: row.project_id || void 0
     }));
   }
   /**
@@ -4972,6 +5091,25 @@ var PostgreSQLChannelInstallationStore = class {
     );
     return result.rows.map((row) => this.mapRowToInstallation(row));
   }
+  async getAllInstallations(channel) {
+    await this.ensureInitialized();
+    const result = channel ? await this.pool.query(
+      `
+          SELECT id, tenant_id, channel, name, config, enabled, fallback_agent_id, reject_when_no_binding, created_at, updated_at
+          FROM lattice_channel_installations
+          WHERE channel = $1
+          ORDER BY created_at DESC
+          `,
+      [channel]
+    ) : await this.pool.query(
+      `
+          SELECT id, tenant_id, channel, name, config, enabled, fallback_agent_id, reject_when_no_binding, created_at, updated_at
+          FROM lattice_channel_installations
+          ORDER BY created_at DESC
+          `
+    );
+    return result.rows.map((row) => this.mapRowToInstallation(row));
+  }
   async createInstallation(tenantId, installationId, data) {
     await this.ensureInitialized();
     const now = /* @__PURE__ */ new Date();
@@ -5885,33 +6023,501 @@ var PostgreSQLScheduleStorage = class {
   }
 };
 
+// src/stores/PostgreSQLTaskStore.ts
+var import_pg18 = require("pg");
+
+// src/migrations/task_migration.ts
+var createTasksTable = {
+  version: 133,
+  name: "create_lattice_tasks_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_tasks (
+        id VARCHAR(255) PRIMARY KEY,
+        tenant_id VARCHAR(255) NOT NULL,
+        owner_type VARCHAR(10) NOT NULL DEFAULT 'user',
+        owner_id VARCHAR(255) NOT NULL,
+        title VARCHAR(500) NOT NULL,
+        description TEXT,
+        status VARCHAR(20) NOT NULL DEFAULT 'pending',
+        priority VARCHAR(10) NOT NULL DEFAULT 'medium',
+        due_date VARCHAR(50),
+        metadata JSONB,
+        parent_id VARCHAR(255),
+        source_id VARCHAR(255),
+        context JSONB,
+        created_at VARCHAR(50) NOT NULL,
+        updated_at VARCHAR(50) NOT NULL
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_tasks_tenant_id
+      ON lattice_tasks(tenant_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_tasks_owner
+      ON lattice_tasks(tenant_id, owner_type, owner_id)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_tasks_status
+      ON lattice_tasks(tenant_id, status)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_tasks_parent_id
+      ON lattice_tasks(tenant_id, parent_id)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS lattice_tasks");
+  }
+};
+
+// src/stores/PostgreSQLTaskStore.ts
+var import_uuid2 = require("uuid");
+function mapRowToTask(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    ownerType: row.owner_type,
+    ownerId: row.owner_id,
+    title: row.title,
+    description: row.description ?? void 0,
+    status: row.status,
+    priority: row.priority,
+    dueDate: row.due_date ?? void 0,
+    metadata: row.metadata ?? void 0,
+    parentId: row.parent_id ?? void 0,
+    sourceId: row.source_id ?? void 0,
+    context: row.context ?? void 0,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at)
+  };
+}
+var PostgreSQLTaskStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    this.initPromise = null;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg18.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg18.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createTasksTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLTaskStore:", error);
+        throw error;
+      });
+    }
+  }
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  async create(params) {
+    await this.ensureInitialized();
+    const id = (0, import_uuid2.v4)();
+    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, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)`,
+      [
+        id,
+        params.tenantId,
+        params.ownerType,
+        params.ownerId,
+        params.title,
+        params.description || null,
+        params.status || "pending",
+        params.priority || "medium",
+        params.dueDate || null,
+        params.metadata ? JSON.stringify(params.metadata) : null,
+        params.parentId || null,
+        params.sourceId || null,
+        params.context ? JSON.stringify(params.context) : null,
+        now,
+        now
+      ]
+    );
+    return await this.getById(params.tenantId, id);
+  }
+  async getById(tenantId, id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_tasks WHERE tenant_id = $1 AND id = $2`,
+      [tenantId, id]
+    );
+    if (result.rows.length === 0) return null;
+    return mapRowToTask(result.rows[0]);
+  }
+  async list(filter) {
+    await this.ensureInitialized();
+    const conditions = [`tenant_id = $1`];
+    const params = [filter.tenantId];
+    let paramIndex = 2;
+    if (filter.ownerType) {
+      conditions.push(`owner_type = $${paramIndex++}`);
+      params.push(filter.ownerType);
+    }
+    if (filter.ownerId) {
+      conditions.push(`owner_id = $${paramIndex++}`);
+      params.push(filter.ownerId);
+    }
+    if (filter.status) {
+      conditions.push(`status = $${paramIndex++}`);
+      params.push(filter.status);
+    }
+    if (filter.priority) {
+      conditions.push(`priority = $${paramIndex++}`);
+      params.push(filter.priority);
+    }
+    if (filter.parentId) {
+      conditions.push(`parent_id = $${paramIndex++}`);
+      params.push(filter.parentId);
+    }
+    if (filter.sourceId) {
+      conditions.push(`source_id = $${paramIndex++}`);
+      params.push(filter.sourceId);
+    }
+    if (filter.metadata) {
+      for (const [key, value] of Object.entries(filter.metadata)) {
+        const safeKey = key.replace(/[^a-zA-Z0-9_]/g, "");
+        if (safeKey) {
+          conditions.push(`metadata->>'${safeKey}' = $${paramIndex++}`);
+          params.push(String(value));
+        }
+      }
+    }
+    const where = conditions.join(" AND ");
+    const limit = filter.limit || 100;
+    const offset = filter.offset || 0;
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_tasks WHERE ${where} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
+      [...params, limit, offset]
+    );
+    return result.rows.map((r) => mapRowToTask(r));
+  }
+  async update(tenantId, id, updates) {
+    await this.ensureInitialized();
+    const existing = await this.getById(tenantId, id);
+    if (!existing) 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.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(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 (setClauses.length === 0) {
+      return existing;
+    }
+    setClauses.push(`updated_at = $${paramIndex++}`);
+    params.push((/* @__PURE__ */ new Date()).toISOString());
+    params.push(tenantId, id);
+    await this.pool.query(
+      `UPDATE lattice_tasks SET ${setClauses.join(", ")} WHERE tenant_id = $${paramIndex++} AND id = $${paramIndex++}`,
+      params
+    );
+    return this.getById(tenantId, id);
+  }
+  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/MenuStore.ts
+var import_pg19 = require("pg");
+
+// src/migrations/menu_items_migration.ts
+var createMenuItemsTable = {
+  version: 134,
+  name: "create_menu_items_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_menu_items (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        tenant_id VARCHAR(255) NOT NULL,
+        menu_target VARCHAR(20) NOT NULL CHECK (menu_target IN ('sidebar', 'workspace')),
+        "group" VARCHAR(100),
+        name VARCHAR(255) NOT NULL,
+        icon VARCHAR(50),
+        sort_order INT NOT NULL DEFAULT 0,
+        content_type VARCHAR(20) NOT NULL CHECK (content_type IN ('agent', 'html', 'custom')),
+        content_config JSONB NOT NULL DEFAULT '{}',
+        enabled BOOLEAN NOT NULL DEFAULT true,
+        created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMP NOT NULL DEFAULT NOW()
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_menu_items_tenant_target
+      ON lattice_menu_items(tenant_id, menu_target)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_menu_items_sort
+      ON lattice_menu_items(tenant_id, menu_target, sort_order)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP TABLE IF EXISTS lattice_menu_items");
+  }
+};
+
+// src/stores/MenuStore.ts
+var MenuStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.initPromise = null;
+    this.pool = typeof options.poolConfig === "string" ? new import_pg19.Pool({ connectionString: options.poolConfig }) : new import_pg19.Pool(options.poolConfig);
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createMenuItemsTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize MenuStore:", error);
+        throw error;
+      });
+    }
+  }
+  async initialize() {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = (async () => {
+      try {
+        await this.migrationManager.migrate();
+        this.initialized = true;
+      } finally {
+        this.initPromise = null;
+      }
+    })();
+    return this.initPromise;
+  }
+  async list(params) {
+    await this.ensureInitialized();
+    const conditions = ["tenant_id = $1"];
+    const values = [params.tenantId];
+    let idx = 2;
+    if (params.menuTarget) {
+      conditions.push(`menu_target = $${idx++}`);
+      values.push(params.menuTarget);
+    }
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_menu_items
+       WHERE ${conditions.join(" AND ")}
+         AND enabled = true
+       ORDER BY sort_order ASC`,
+      values
+    );
+    return result.rows.map((r) => this.mapRowToMenuItem(r));
+  }
+  async getById(id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `SELECT * FROM lattice_menu_items WHERE id = $1`,
+      [id]
+    );
+    if (result.rows.length === 0) return null;
+    return this.mapRowToMenuItem(result.rows[0]);
+  }
+  async create(input) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `INSERT INTO lattice_menu_items
+         (tenant_id, menu_target, "group", name, icon, sort_order, content_type, content_config)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+       RETURNING *`,
+      [
+        input.tenantId,
+        input.menuTarget,
+        input.group || null,
+        input.name,
+        input.icon || null,
+        input.sortOrder ?? 0,
+        input.contentType,
+        JSON.stringify(input.contentConfig)
+      ]
+    );
+    return this.mapRowToMenuItem(result.rows[0]);
+  }
+  async update(id, patch) {
+    await this.ensureInitialized();
+    const existing = await this.pool.query(
+      `SELECT * FROM lattice_menu_items WHERE id = $1`,
+      [id]
+    );
+    if (existing.rows.length === 0) {
+      throw new Error(`MenuItem ${id} not found`);
+    }
+    const row = existing.rows[0];
+    const setClauses = [];
+    const values = [];
+    let idx = 1;
+    if (patch.group !== void 0) {
+      setClauses.push(`"group" = $${idx++}`);
+      values.push(patch.group);
+    }
+    if (patch.name !== void 0) {
+      setClauses.push(`name = $${idx++}`);
+      values.push(patch.name);
+    }
+    if (patch.icon !== void 0) {
+      setClauses.push(`icon = $${idx++}`);
+      values.push(patch.icon);
+    }
+    if (patch.sortOrder !== void 0) {
+      setClauses.push(`sort_order = $${idx++}`);
+      values.push(patch.sortOrder);
+    }
+    if (patch.contentConfig !== void 0) {
+      setClauses.push(`content_config = $${idx++}`);
+      values.push(JSON.stringify(patch.contentConfig));
+    }
+    if (patch.enabled !== void 0) {
+      setClauses.push(`enabled = $${idx++}`);
+      values.push(patch.enabled);
+    }
+    if (setClauses.length === 0) {
+      return this.mapRowToMenuItem(row);
+    }
+    setClauses.push(`updated_at = NOW()`);
+    values.push(id);
+    const result = await this.pool.query(
+      `UPDATE lattice_menu_items SET ${setClauses.join(", ")} WHERE id = $${idx}
+       RETURNING *`,
+      values
+    );
+    return this.mapRowToMenuItem(result.rows[0]);
+  }
+  async delete(id) {
+    await this.ensureInitialized();
+    await this.pool.query(`DELETE FROM lattice_menu_items WHERE id = $1`, [id]);
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  mapRowToMenuItem(row) {
+    return {
+      id: row.id,
+      tenantId: row.tenant_id,
+      menuTarget: row.menu_target,
+      group: row.group || void 0,
+      name: row.name,
+      icon: row.icon || void 0,
+      sortOrder: row.sort_order,
+      contentType: row.content_type,
+      contentConfig: row.content_config,
+      enabled: row.enabled,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+};
+
 // src/createPgStoreConfig.ts
+var import_langgraph_checkpoint_postgres = require("@langchain/langgraph-checkpoint-postgres");
 function createPgStoreConfig(connectionString) {
-  const opts = { poolConfig: connectionString, autoMigrate: false };
-  const optsAuto = { poolConfig: connectionString, autoMigrate: true };
+  const opts = { poolConfig: connectionString, autoMigrate: true };
+  const checkpoint = import_langgraph_checkpoint_postgres.PostgresSaver.fromConnString(connectionString);
+  checkpoint.setup().catch((err) => {
+    console.error("[pg-stores] Failed to setup checkpoint table:", err.message || err);
+  });
   return {
     workspace: new PostgreSQLWorkspaceStore(opts),
     project: new PostgreSQLProjectStore(opts),
-    eval: new PostgreSQLEvalStore(optsAuto),
+    eval: new PostgreSQLEvalStore(opts),
     user: new PostgreSQLUserStore(opts),
     tenant: new PostgreSQLTenantStore(opts),
     userTenantLink: new PostgreSQLUserTenantLinkStore(opts),
-    channelBinding: new ChannelBindingStore(optsAuto),
-    channelInstallation: new PostgreSQLChannelInstallationStore(optsAuto),
+    channelBinding: new ChannelBindingStore(opts),
+    channelInstallation: new PostgreSQLChannelInstallationStore(opts),
     thread: new PostgreSQLThreadStore(opts),
     database: new PostgreSQLDatabaseConfigStore(opts),
     metrics: new PostgreSQLMetricsServerConfigStore(opts),
     mcp: new PostgreSQLMcpServerConfigStore(opts),
     assistant: new PostgreSQLAssistantStore(opts),
-    workflowTracking: new PostgreSQLWorkflowTrackingStore(optsAuto),
-    threadMessageQueue: new ThreadMessageQueueStore(optsAuto),
-    a2aApiKey: new PostgreSQLA2AApiKeyStore(optsAuto),
-    schedule: new PostgreSQLScheduleStorage(opts)
+    workflowTracking: new PostgreSQLWorkflowTrackingStore(opts),
+    threadMessageQueue: new ThreadMessageQueueStore(opts),
+    task: new PostgreSQLTaskStore(opts),
+    a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
+    schedule: new PostgreSQLScheduleStorage(opts),
+    menu: new MenuStore(opts),
+    checkpoint
   };
 }
 
 // src/stores/PostgreSQLSkillStore.ts
-var import_pg18 = require("pg");
+var import_pg20 = require("pg");
 
 // src/migrations/skill_migrations.ts
 var createSkillsTable = {
@@ -6073,9 +6679,9 @@ var PostgreSQLSkillStore = class {
     this.ownsPool = true;
     this.initPromise = null;
     if (typeof options.poolConfig === "string") {
-      this.pool = new import_pg18.Pool({ connectionString: options.poolConfig });
+      this.pool = new import_pg20.Pool({ connectionString: options.poolConfig });
     } else {
-      this.pool = new import_pg18.Pool(options.poolConfig);
+      this.pool = new import_pg20.Pool(options.poolConfig);
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSkillsTable);
@@ -6429,12 +7035,12 @@ var createChannelIdentityMappingTables = {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-var import_pg19 = require("pg");
+var import_pg21 = require("pg");
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new import_pg19.Pool({ connectionString: options.poolConfig }) : new import_pg19.Pool(options.poolConfig);
+    this.pool = typeof options.poolConfig === "string" ? new import_pg21.Pool({ connectionString: options.poolConfig }) : new import_pg21.Pool(options.poolConfig);
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelIdentityMappingTables);
     if (options.autoMigrate !== false) {
@@ -6649,6 +7255,7 @@ function mapRowToChannelIdentityMapping(row) {
 0 && (module.exports = {
   ChannelBindingStore,
   ChannelIdentityMappingStore,
+  MenuStore,
   MigrationManager,
   Pool,
   PostgreSQLA2AApiKeyStore,
@@ -6672,6 +7279,7 @@ function mapRowToChannelIdentityMapping(row) {
   addProjectConfigColumn,
   addScheduleTenantId,
   addSkillTenantId,
+  addStepThreadId,
   addThreadTenantId,
   alterChannelInstallationsTable,
   changeAssistantPrimaryKey,
@@ -6689,6 +7297,7 @@ function mapRowToChannelIdentityMapping(row) {
   createEvalRunsTable,
   createEvalSuitesTable,
   createMcpServerConfigsTable,
+  createMenuItemsTable,
   createMetricsConfigsTable,
   createPgStoreConfig,
   createProjectsTable,