@axiom-lattice/pg-stores 3.0.2 → 3.1.1

package/src/stores/PostgreSQLProjectStore.ts

@@ -5,11 +5,13 @@
 import { Pool } from "pg";
 import type { PoolConfig } from "pg";
 import {
+  assertGenericProjectConfig,
   ProjectStore,
   Project,
   ProjectFilter,
   CreateProjectRequest,
   UpdateProjectRequest,
+  UpdateProjectCapabilityBundlesResult,
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
 import { createProjectsTable } from "../migrations/project_migrations";
@@ -218,37 +220,70 @@ export class PostgreSQLProjectStore implements ProjectStore {
     id: string,
     data: CreateProjectRequest
   ): Promise<Project> {
+    assertGenericProjectConfig(data.config);
     await this.ensureInitialized();
 
     const now = new Date();
     const kind = data.kind || "business";
 
-    await this.pool.query(
-      `
-      INSERT INTO lattice_projects (id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at)
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($1 || ':project-mutations', 0))",
+        [tenantId],
+      );
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($2 || ':project:' || $1, 0))",
+        [id, tenantId],
+      );
+      const existing = await client.query<{ config: Record<string, unknown> | null }>(
+        "SELECT config FROM lattice_projects WHERE id = $1 AND tenant_id = $2 FOR UPDATE",
+        [id, tenantId],
+      );
+      const ids = existing.rows[0]?.config?.capabilityBundleIds;
+      const bundleIds = Array.isArray(ids) && ids.every((bundleId) => typeof bundleId === "string")
+        ? [...ids].sort()
+        : [];
+      if (bundleIds.length > 0) {
+        await client.query(
+          `SELECT pg_advisory_xact_lock(hashtextextended($1 || ':' || bundle_id, 0))
+           FROM unnest($2::text[]) AS bundle_id
+           ORDER BY bundle_id`,
+          [tenantId, bundleIds],
+        );
+      }
+      const result = await client.query<{
+      id: string; tenant_id: string; workspace_id: string; name: string;
+      description: string | null; config: unknown | null; kind: string | null;
+      created_at: Date; updated_at: Date;
+      }>(
+      `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,
+        config = CASE
+          WHEN lattice_projects.config ? 'capabilityBundleIds'
+          THEN COALESCE(EXCLUDED.config, '{}'::jsonb)
+            || jsonb_build_object('capabilityBundleIds', lattice_projects.config->'capabilityBundleIds')
+          ELSE EXCLUDED.config
+        END,
         kind = EXCLUDED.kind,
         updated_at = EXCLUDED.updated_at
+      RETURNING id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at
     `,
       [id, tenantId, workspaceId, data.name, data.description || null, data.config || null, kind, now, now]
-    );
-
-    return {
-      id,
-      tenantId,
-      workspaceId,
-      name: data.name,
-      description: data.description,
-      config: data.config,
-      kind,
-      createdAt: now,
-      updatedAt: now,
-    };
+      );
+      await client.query("COMMIT");
+      return this.mapRowToProject(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
   }
 
   /**
@@ -263,17 +298,12 @@ export class PostgreSQLProjectStore implements ProjectStore {
     id: string,
     updates: UpdateProjectRequest
   ): Promise<Project | null> {
+    assertGenericProjectConfig(updates.config);
     await this.ensureInitialized();
 
-    // Get existing project
-    const existing = await this.getProjectById(tenantId, id);
-    if (!existing) {
-      return null;
-    }
-
     // Build update query dynamically based on provided fields
     const updateFields: string[] = [];
-    const updateValues: any[] = [];
+    const updateValues: unknown[] = [];
     let paramIndex = 1;
 
     if (updates.name !== undefined) {
@@ -287,8 +317,14 @@ export class PostgreSQLProjectStore implements ProjectStore {
     }
 
     if (updates.config !== undefined) {
-      updateFields.push(`config = $${paramIndex++}`);
-      updateValues.push(updates.config || null);
+      const configParam = `$${paramIndex++}`;
+      updateFields.push(`config = CASE
+        WHEN config ? 'capabilityBundleIds'
+        THEN COALESCE(${configParam}::jsonb, '{}'::jsonb)
+          || jsonb_build_object('capabilityBundleIds', config->'capabilityBundleIds')
+        ELSE ${configParam}::jsonb
+      END`);
+      updateValues.push(updates.config);
     }
 
     if (updates.kind !== undefined) {
@@ -298,28 +334,63 @@ export class PostgreSQLProjectStore implements ProjectStore {
 
     if (updateFields.length === 0) {
       // No fields to update
-      return existing;
+      return await this.getProjectById(tenantId, id);
     }
 
     // Always update updated_at
     updateFields.push(`updated_at = $${paramIndex++}`);
     updateValues.push(new Date());
 
-    // Add id and tenant_id for WHERE clause
-    updateValues.push(id);
-    updateValues.push(tenantId);
-
-    await this.pool.query(
-      `
-      UPDATE lattice_projects
-      SET ${updateFields.join(", ")}
-      WHERE id = $${paramIndex} AND tenant_id = $${paramIndex + 1}
-    `,
-      updateValues
-    );
-
-    // Return updated project
-    return await this.getProjectById(tenantId, id);
+    updateValues.push(id, tenantId);
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($1 || ':project-mutations', 0))",
+        [tenantId],
+      );
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($2 || ':project:' || $1, 0))",
+        [id, tenantId],
+      );
+      const existing = await client.query<{ config: Record<string, unknown> | null }>(
+        "SELECT config FROM lattice_projects WHERE id = $1 AND tenant_id = $2 FOR UPDATE",
+        [id, tenantId],
+      );
+      if (!existing.rows[0]) {
+        await client.query("COMMIT");
+        return null;
+      }
+      const ids = existing.rows[0].config?.capabilityBundleIds;
+      const bundleIds = Array.isArray(ids) && ids.every((bundleId) => typeof bundleId === "string")
+        ? [...ids].sort()
+        : [];
+      if (bundleIds.length > 0) {
+        await client.query(
+          `SELECT pg_advisory_xact_lock(hashtextextended($1 || ':' || bundle_id, 0))
+           FROM unnest($2::text[]) AS bundle_id
+           ORDER BY bundle_id`,
+          [tenantId, bundleIds],
+        );
+      }
+      const result = await client.query<{
+        id: string; tenant_id: string; workspace_id: string; name: string;
+        description: string | null; config: unknown | null; kind: string | null;
+        created_at: Date; updated_at: Date;
+      }>(
+        `UPDATE lattice_projects SET ${updateFields.join(", ")}
+         WHERE id = $${paramIndex} AND tenant_id = $${paramIndex + 1}
+         RETURNING id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at`,
+        updateValues,
+      );
+      await client.query("COMMIT");
+      return this.mapRowToProject(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
   }
 
   /**
@@ -327,15 +398,124 @@ export class PostgreSQLProjectStore implements ProjectStore {
    */
   async deleteProject(tenantId: string, id: string): Promise<boolean> {
     await this.ensureInitialized();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($1 || ':project-mutations', 0))",
+        [tenantId],
+      );
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($2 || ':project:' || $1, 0))",
+        [id, tenantId],
+      );
+      const selected = await client.query<{ config: Record<string, unknown> | null }>(
+        "SELECT config FROM lattice_projects WHERE id = $1 AND tenant_id = $2 FOR UPDATE",
+        [id, tenantId],
+      );
+      if (!selected.rows[0]) {
+        await client.query("COMMIT");
+        return false;
+      }
+      const ids = selected.rows[0].config?.capabilityBundleIds;
+      const bundleIds = Array.isArray(ids) && ids.every((bundleId) => typeof bundleId === "string")
+        ? [...ids].sort()
+        : [];
+      if (bundleIds.length > 0) {
+        await client.query(
+          `SELECT pg_advisory_xact_lock(hashtextextended($1 || ':' || bundle_id, 0))
+           FROM unnest($2::text[]) AS bundle_id
+           ORDER BY bundle_id`,
+          [tenantId, bundleIds],
+        );
+      }
+      const result = await client.query(
+        "DELETE FROM lattice_projects WHERE id = $1 AND tenant_id = $2",
+        [id, tenantId],
+      );
+      await client.query("COMMIT");
+      return result.rowCount !== null && result.rowCount > 0;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
 
-    const result = await this.pool.query(
-      `
-      DELETE FROM lattice_projects
-      WHERE id = $1 AND tenant_id = $2
-    `,
-      [id, tenantId]
-    );
+  async updateCapabilityBundleIds(tenantId: string, projectId: string, bundleIds: string[], expectedRevisions: Record<string, string> = {}): Promise<UpdateProjectCapabilityBundlesResult> {
+    await this.ensureInitialized();
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($1 || ':project-mutations', 0))",
+        [tenantId],
+      );
+      await client.query(
+        "SELECT pg_advisory_xact_lock(hashtextextended($2 || ':project:' || $1, 0))",
+        [projectId, tenantId],
+      );
+      await client.query(
+        "SELECT id FROM lattice_projects WHERE id = $1 AND tenant_id = $2 FOR UPDATE",
+        [projectId, tenantId],
+      );
+      if (bundleIds.length > 0) {
+        await client.query(
+          `SELECT pg_advisory_xact_lock(hashtextextended($1 || ':' || bundle_id, 0))
+           FROM unnest($2::text[]) AS bundle_id
+           ORDER BY bundle_id`,
+          [tenantId, [...bundleIds].sort()],
+        );
+        if (Object.keys(expectedRevisions).length > 0) {
+          const revisions = await client.query<{ id: string; updated_at: string }>("SELECT id, updated_at::text AS updated_at FROM lattice_capability_bundles WHERE tenant_id = $1 AND id = ANY($2::uuid[]) FOR UPDATE", [tenantId, bundleIds]);
+          if (revisions.rows.some((bundle) => expectedRevisions[bundle.id] !== undefined && expectedRevisions[bundle.id] !== bundle.updated_at)) {
+            await client.query("ROLLBACK");
+            return { status: "bundle_conflict" };
+          }
+        }
+      }
+      const result = await client.query(
+        `UPDATE lattice_projects
+         SET config = COALESCE(config, '{}'::jsonb) || jsonb_build_object('capabilityBundleIds', $3::jsonb), updated_at = NOW()
+         WHERE id = $1 AND tenant_id = $2
+         AND NOT EXISTS (
+           SELECT 1 FROM unnest($4::uuid[]) AS bundle_id
+           WHERE NOT EXISTS (
+             SELECT 1 FROM lattice_capability_bundles
+             WHERE tenant_id = $2 AND id = bundle_id
+           )
+         )
+         RETURNING id, tenant_id, workspace_id, name, description, config, kind, created_at, updated_at`,
+        [projectId, tenantId, JSON.stringify(bundleIds), bundleIds],
+      );
+      if (result.rows[0]) {
+        await client.query("COMMIT");
+        return { status: "updated", project: this.mapRowToProject(result.rows[0]) };
+      }
+      const project = await client.query(
+        "SELECT id FROM lattice_projects WHERE id = $1 AND tenant_id = $2",
+        [projectId, tenantId],
+      );
+      await client.query("COMMIT");
+      return project.rows.length > 0 ? { status: "bundle_not_found" } : { status: "project_not_found" };
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
 
-    return result.rowCount !== null && result.rowCount > 0;
+  async isCapabilityBundleReferenced(tenantId: string, bundleId: string): Promise<boolean> {
+    await this.ensureInitialized();
+    const result = await this.pool.query<{ exists: number }>(
+      `SELECT 1 AS exists FROM lattice_projects
+       WHERE tenant_id = $1
+       AND jsonb_typeof(config->'capabilityBundleIds') = 'array'
+       AND COALESCE(config->'capabilityBundleIds', '[]'::jsonb) ? $2
+       LIMIT 1`, [tenantId, bundleId],
+    );
+    return result.rows.length > 0;
   }
 }

package/src/stores/PostgreSQLTaskWorkItemStore.ts

@@ -1,5 +1,6 @@
 import type { Pool } from "pg";
 import type { TaskWorkItemStore, TaskWorkItem, CreateWorkItemRequest, CreateWorkItemIfAbsentRequest, TaskWorkItemListFilter } from "@axiom-lattice/protocols";
+import { MAX_PENDING_EXECUTION_RESULTS_LIMIT } from "@axiom-lattice/protocols";
 import { v4 } from "uuid";
 
 export class PostgreSQLTaskWorkItemStore implements TaskWorkItemStore {
@@ -87,6 +88,44 @@ export class PostgreSQLTaskWorkItemStore implements TaskWorkItemStore {
     return result.rows.map((row: Record<string, unknown>) => this.rowToItem(row));
   }
 
+  /** List pending execution results using one bounded PostgreSQL anti-join query. */
+  async listPendingExecutionResults(params: {
+    tenantId: string;
+    taskId: string;
+    limit: number;
+  }): Promise<TaskWorkItem[]> {
+    if (!Number.isSafeInteger(params.limit)
+      || params.limit < 0
+      || params.limit > MAX_PENDING_EXECUTION_RESULTS_LIMIT) {
+      const error = new RangeError(`limit must be a safe integer between 0 and ${MAX_PENDING_EXECUTION_RESULTS_LIMIT}`) as RangeError & {
+        code: "INVALID_LIMIT";
+      };
+      error.code = "INVALID_LIMIT";
+      throw error;
+    }
+    if (params.limit === 0) return [];
+    const result = await this.pool.query(
+      `SELECT result.*
+       FROM lattice_task_work_items AS result
+       WHERE result.tenant_id = $1
+         AND result.task_id = $2
+         AND result.action = 'execution_result'
+         AND result.event_key COLLATE "C" ~ '^execution-result:[A-Za-z0-9._:-]+$'
+         AND NOT EXISTS (
+           SELECT 1
+           FROM lattice_task_work_items AS reconciled
+           WHERE reconciled.tenant_id = result.tenant_id
+             AND reconciled.task_id = result.task_id
+             AND reconciled.action = 'execution_reconciled'
+             AND reconciled.detail ->> 'executionResultId' = result.event_key
+         )
+       ORDER BY result.created_at DESC, result.id DESC
+       LIMIT $3`,
+      [params.tenantId, params.taskId, params.limit],
+    );
+    return result.rows.map((row: Record<string, unknown>) => this.rowToItem(row));
+  }
+
   private rowToItem(row: Record<string, unknown>): TaskWorkItem {
     return {
       id: row.id as string,

package/src/stores/ThreadMessageQueueStore.ts

@@ -11,6 +11,7 @@ import type {
   PendingMessage,
   AddMessageParams,
   ThreadInfo,
+  QueueScope,
 } from "@axiom-lattice/core";
 import { MigrationManager } from "../migrations/migration";
 import { createThreadMessageQueueTable } from "../migrations/thread_message_queue_migrations";
@@ -108,12 +109,51 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
        (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, workspaceId || null, projectId || null, 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]);
   }
 
+  async addMessageIfCapacity(params: AddMessageParams, maxSize: number): Promise<boolean> {
+    if (maxSize === Infinity) {
+      await this.addMessage(params);
+      return true;
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const scope = { tenantId: params.tenantId, assistantId: params.assistantId, workspaceId: params.workspaceId, projectId: params.projectId };
+      const lockKey = `${params.tenantId}:${params.assistantId}:${params.threadId}:${params.workspaceId ?? ""}:${params.projectId ?? ""}`;
+      await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [lockKey]);
+      const filter = scopeClause(scope, 2);
+      const count = await client.query(
+        `SELECT COUNT(*) as count FROM lattice_thread_message_queue WHERE thread_id = $1 AND status = 'pending'${filter.sql}`,
+        [params.threadId, ...filter.params],
+      );
+      if (parseInt(count.rows[0].count, 10) >= maxSize) {
+        await client.query("ROLLBACK");
+        return false;
+      }
+      const seq = await client.query(
+        `SELECT COALESCE(MAX(sequence_order), 0) + 1 as next_seq FROM lattice_thread_message_queue WHERE thread_id = $1`,
+        [params.threadId],
+      );
+      const result = await client.query(
+        `INSERT INTO lattice_thread_message_queue (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 *`,
+        [params.id || crypto.randomUUID(), params.threadId, params.tenantId, params.assistantId, params.workspaceId ?? null, params.projectId ?? null, JSON.stringify(params.content), params.type || "human", seq.rows[0].next_seq, params.priority ?? 0, params.command ? JSON.stringify(params.command) : null, params.custom_run_config ? JSON.stringify(params.custom_run_config) : null],
+      );
+      await client.query("COMMIT");
+      return Boolean(result.rows[0]);
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
   /**
    * Add message at head of queue (high priority, e.g., STEER/Command messages)
    * Uses priority=100 to ensure message is processed first
@@ -139,7 +179,7 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
        (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, workspaceId || null, projectId || null, 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]);
@@ -148,12 +188,13 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
   /**
    * Get pending messages for thread
    */
-  async getPendingMessages(threadId: string): Promise<PendingMessage[]> {
+  async getPendingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]> {
+    const filter = scopeClause(scope, 2);
     const result = await this.pool.query(
-      `SELECT * FROM lattice_thread_message_queue 
-       WHERE thread_id = $1 AND status = 'pending'
+      `SELECT * FROM lattice_thread_message_queue
+        WHERE thread_id = $1 AND status = 'pending'${filter.sql}
        ORDER BY priority DESC, sequence_order ASC`,
-      [threadId]
+      [threadId, ...filter.params]
     );
 
     return result.rows.map(row => this.rowToMessage(row));
@@ -162,12 +203,13 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
   /**
    * Get processing messages for a thread
    */
-  async getProcessingMessages(threadId: string): Promise<PendingMessage[]> {
+  async getProcessingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]> {
+    const filter = scopeClause(scope, 2);
     const result = await this.pool.query(
       `SELECT * FROM lattice_thread_message_queue 
-       WHERE thread_id = $1 AND status = 'processing'
+        WHERE thread_id = $1 AND status = 'processing'${filter.sql}
        ORDER BY priority DESC, sequence_order ASC`,
-      [threadId]
+      [threadId, ...filter.params]
     );
 
     return result.rows.map(row => this.rowToMessage(row));
@@ -176,11 +218,12 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
   /**
    * Get queue size
    */
-  async getQueueSize(threadId: string): Promise<number> {
+  async getQueueSize(threadId: string, scope?: QueueScope): Promise<number> {
+    const filter = scopeClause(scope, 2);
     const result = await this.pool.query(
       `SELECT COUNT(*) as count FROM lattice_thread_message_queue 
-       WHERE thread_id = $1 AND status = 'pending'`,
-      [threadId]
+        WHERE thread_id = $1 AND status = 'pending'${filter.sql}`,
+      [threadId, ...filter.params]
     );
 
     return parseInt(result.rows[0].count, 10);
@@ -191,28 +234,29 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    */
   async getThreadsWithPendingMessages(): Promise<ThreadInfo[]> {
     const result = await this.pool.query(
-      `SELECT DISTINCT ON (thread_id) tenant_id, assistant_id, thread_id, workspace_id, project_id
+       `SELECT DISTINCT ON (tenant_id, assistant_id, workspace_id, project_id, 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`
+        ORDER BY tenant_id, assistant_id, workspace_id, project_id, thread_id`
     );
 
     return result.rows.map(row => ({
       tenantId: row.tenant_id,
       assistantId: row.assistant_id,
       threadId: row.thread_id,
-      workspaceId: row.workspace_id || undefined,
-      projectId: row.project_id || undefined,
+      workspaceId: row.workspace_id,
+      projectId: row.project_id,
     }));
   }
 
   /**
    * Remove message
    */
-  async removeMessage(messageId: string): Promise<boolean> {
+  async removeMessage(messageId: string, scope?: QueueScope): Promise<boolean> {
+    const filter = scopeClause(scope, 2);
     const result = await this.pool.query(
-      `DELETE FROM lattice_thread_message_queue WHERE id = $1 RETURNING id`,
-      [messageId]
+      `DELETE FROM lattice_thread_message_queue WHERE id = $1${filter.sql} RETURNING id`,
+      [messageId, ...filter.params]
     );
 
     return (result.rowCount ?? 0) > 0;
@@ -221,20 +265,30 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
   /**
    * Clear all messages for thread
    */
-  async clearMessages(threadId: string): Promise<void> {
+  async clearMessages(threadId: string, scope?: QueueScope): Promise<void> {
+    const filter = scopeClause(scope, 2);
     await this.pool.query(
-      `DELETE FROM lattice_thread_message_queue WHERE thread_id = $1`,
-      [threadId]
+      `DELETE FROM lattice_thread_message_queue WHERE thread_id = $1${filter.sql}`,
+      [threadId, ...filter.params]
     );
   }
 
   /**
    * Mark message as processing
    */
-  async markProcessing(messageId: string): Promise<void> {
+  async markProcessing(messageId: string, customRunConfig?: unknown, scope?: QueueScope): Promise<void> {
+    if (customRunConfig !== undefined) {
+      const filter = scopeClause(scope, 3);
+      await this.pool.query(
+        `UPDATE lattice_thread_message_queue SET status = 'processing', custom_run_config = $2 WHERE id = $1${filter.sql}`,
+        [messageId, JSON.stringify(customRunConfig), ...filter.params]
+      );
+      return;
+    }
+    const filter = scopeClause(scope, 2);
     await this.pool.query(
-      `UPDATE lattice_thread_message_queue SET status = 'processing' WHERE id = $1`,
-      [messageId]
+      `UPDATE lattice_thread_message_queue SET status = 'processing' WHERE id = $1${filter.sql}`,
+      [messageId, ...filter.params]
     );
   }
 
@@ -242,13 +296,14 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
    * Reset all processing messages to pending state for a thread
    * Returns the number of messages reset
    */
-  async resetProcessingToPending(threadId: string): Promise<number> {
+  async resetProcessingToPending(threadId: string, scope?: QueueScope): Promise<number> {
+    const filter = scopeClause(scope, 2);
     const result = await this.pool.query(
       `UPDATE lattice_thread_message_queue 
        SET status = 'pending'
-       WHERE thread_id = $1 AND status = 'processing'
+        WHERE thread_id = $1 AND status = 'processing'${filter.sql}
        RETURNING id`,
-      [threadId]
+      [threadId, ...filter.params]
     );
     return result.rowCount ?? 0;
   }
@@ -270,3 +325,17 @@ export class ThreadMessageQueueStore implements IMessageQueueStore {
     };
   }
 }
+
+function scopeClause(scope: QueueScope | undefined, start: number): { sql: string; params: unknown[] } {
+  if (!scope) return { sql: "", params: [] };
+  const params: unknown[] = [];
+  const entries = (["tenantId", "assistantId", "workspaceId", "projectId"] as const)
+    .map((key) => [key, scope[key]] as const);
+  const sql = entries.map(([key, value]) => {
+    const column = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    if (value == null) return ` AND ${column} IS NULL`;
+    params.push(value);
+    return ` AND ${column} = $${start + params.length - 1}`;
+  }).join("");
+  return { sql, params };
+}