@axiom-lattice/pg-stores 1.0.71 → 1.0.72

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/index.ts
-import { Pool as Pool20 } from "pg";
+import { Pool as Pool22 } from "pg";
 
 // src/stores/PostgreSQLThreadStore.ts
 import { Pool } from "pg";
@@ -603,6 +603,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) {
@@ -618,6 +642,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);
@@ -653,7 +678,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
@@ -669,7 +694,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
     `,
@@ -688,12 +713,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
     `,
       [
@@ -702,6 +728,7 @@ var PostgreSQLAssistantStore = class {
         data.name,
         data.description || null,
         JSON.stringify(data.graphDefinition),
+        data.ownerUserId || null,
         now,
         now
       ]
@@ -712,6 +739,7 @@ var PostgreSQLAssistantStore = class {
       name: data.name,
       description: data.description,
       graphDefinition: data.graphDefinition,
+      ownerUserId: data.ownerUserId,
       createdAt: now,
       updatedAt: now
     };
@@ -740,6 +768,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;
     }
@@ -786,6 +818,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
@@ -813,6 +862,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
     };
@@ -3009,6 +3059,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 {
@@ -3022,6 +3088,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);
@@ -3154,8 +3221,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,
@@ -3166,6 +3233,7 @@ var PostgreSQLWorkflowTrackingStore = class {
         request.edgeTo || null,
         request.edgePurpose || null,
         request.input ? JSON.stringify(request.input) : null,
+        request.threadId || null,
         "running",
         now,
         now,
@@ -3178,6 +3246,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,
@@ -3195,7 +3264,15 @@ var PostgreSQLWorkflowTrackingStore = class {
       [request.runId, request.stepType, request.stepName]
     );
     if (result.rows.length > 0) {
-      return this.mapRowToRunStep(result.rows[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);
   }
@@ -3283,6 +3360,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,
@@ -4335,6 +4413,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) {
@@ -4351,6 +4453,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);
@@ -4380,7 +4483,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 
@@ -4390,10 +4493,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 || crypto.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 || crypto.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]);
   }
@@ -4402,7 +4505,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(
@@ -4414,10 +4517,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 || crypto.randomUUID(), threadId, resolvedTenantId, resolvedAssistantId, JSON.stringify(content), type, nextSeq, command ? JSON.stringify(command) : null, custom_run_config ? JSON.stringify(custom_run_config) : null]
+      [id || crypto.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]);
   }
@@ -4461,7 +4564,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`
@@ -4469,7 +4572,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
     }));
   }
   /**
@@ -4896,6 +5001,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();
@@ -5811,33 +5935,501 @@ var PostgreSQLScheduleStorage = class {
   }
 };
 
+// src/stores/PostgreSQLTaskStore.ts
+import { Pool as Pool18 } from "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
+import { v4 as uuidv42 } from "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 Pool18({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new Pool18(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 = 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, 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
+import { Pool as Pool19 } from "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 Pool19({ connectionString: options.poolConfig }) : new Pool19(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
+import { PostgresSaver } from "@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 = 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
-import { Pool as Pool18 } from "pg";
+import { Pool as Pool20 } from "pg";
 
 // src/migrations/skill_migrations.ts
 var createSkillsTable = {
@@ -5999,9 +6591,9 @@ var PostgreSQLSkillStore = class {
     this.ownsPool = true;
     this.initPromise = null;
     if (typeof options.poolConfig === "string") {
-      this.pool = new Pool18({ connectionString: options.poolConfig });
+      this.pool = new Pool20({ connectionString: options.poolConfig });
     } else {
-      this.pool = new Pool18(options.poolConfig);
+      this.pool = new Pool20(options.poolConfig);
     }
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createSkillsTable);
@@ -6355,12 +6947,12 @@ var createChannelIdentityMappingTables = {
 };
 
 // src/stores/ChannelIdentityMappingStore.ts
-import { Pool as Pool19 } from "pg";
+import { Pool as Pool21 } from "pg";
 var ChannelIdentityMappingStore = class {
   constructor(options) {
     this.initialized = false;
     this.initPromise = null;
-    this.pool = typeof options.poolConfig === "string" ? new Pool19({ connectionString: options.poolConfig }) : new Pool19(options.poolConfig);
+    this.pool = typeof options.poolConfig === "string" ? new Pool21({ connectionString: options.poolConfig }) : new Pool21(options.poolConfig);
     this.migrationManager = new MigrationManager(this.pool);
     this.migrationManager.register(createChannelIdentityMappingTables);
     if (options.autoMigrate !== false) {
@@ -6574,8 +7166,9 @@ function mapRowToChannelIdentityMapping(row) {
 export {
   ChannelBindingStore,
   ChannelIdentityMappingStore,
+  MenuStore,
   MigrationManager,
-  Pool20 as Pool,
+  Pool22 as Pool,
   PostgreSQLA2AApiKeyStore,
   PostgreSQLAssistantStore,
   PostgreSQLChannelInstallationStore,
@@ -6597,6 +7190,7 @@ export {
   addProjectConfigColumn,
   addScheduleTenantId,
   addSkillTenantId,
+  addStepThreadId,
   addThreadTenantId,
   alterChannelInstallationsTable,
   changeAssistantPrimaryKey,
@@ -6614,6 +7208,7 @@ export {
   createEvalRunsTable,
   createEvalSuitesTable,
   createMcpServerConfigsTable,
+  createMenuItemsTable,
   createMetricsConfigsTable,
   createPgStoreConfig,
   createProjectsTable,