@axiom-lattice/pg-stores 3.1.0 → 3.1.2

package/src/migrations/task_migration.ts

@@ -98,10 +98,25 @@ export const addFilesToTasks: Migration = {
   },
 };
 
+/** Add JSONB containment support for dependency recovery queries. */
+export const addTaskDependenciesGinIndex: Migration = {
+  version: 174,
+  name: "add_task_dependencies_gin_index",
+  up: async (client) => {
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_lattice_tasks_dependencies_gin
+      ON lattice_tasks USING GIN (dependencies jsonb_path_ops)
+      WHERE dependencies IS NOT NULL`);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_tasks_dependencies_gin");
+  },
+};
+
 /** All task migrations in version order */
 export const taskMigrations: Migration[] = [
   createTasksTable,
   addTaskFieldsMigration,
   addTaskProjectFieldsMigration,
   addFilesToTasks,
+  addTaskDependenciesGinIndex,
 ];

package/src/migrations/task_work_items_migration.ts

@@ -16,7 +16,7 @@ export const createTaskWorkItemsMigration: Migration = {
         summary TEXT,
         detail JSONB,
         attempt INTEGER,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT date_trunc('milliseconds', clock_timestamp()),
         PRIMARY KEY (tenant_id, id)
       )
     `);
@@ -64,3 +64,47 @@ export const addTaskWorkItemEventKeyMigration: Migration = {
     `);
   },
 };
+
+export const addTaskWorkItemPendingIndexesMigration: Migration = {
+  version: 171,
+  name: "add_task_work_item_pending_indexes",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_pending_order
+        ON lattice_task_work_items (tenant_id, task_id, action, created_at DESC, id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_task_work_items_reconciled_result
+        ON lattice_task_work_items (tenant_id, task_id, (detail ->> 'executionResultId'))
+        WHERE action = 'execution_reconciled'
+    `);
+  },
+};
+
+/** Add deterministic project lifecycle event scan support. */
+export const addProjectLifecycleEventIndex: Migration = {
+  version: 175,
+  name: "add_project_lifecycle_event_index",
+  up: async (client) => {
+    await client.query(`UPDATE lattice_task_work_items
+      SET created_at = date_trunc('milliseconds', created_at)
+      WHERE created_at <> date_trunc('milliseconds', created_at)`);
+    await client.query(`ALTER TABLE lattice_task_work_items
+      ALTER COLUMN created_at SET DEFAULT date_trunc('milliseconds', clock_timestamp())`);
+    await client.query(`CREATE INDEX IF NOT EXISTS idx_task_work_items_project_lifecycle
+      ON lattice_task_work_items (tenant_id, workspace_id, project_id, created_at DESC, id DESC)
+      WHERE event_key IS NOT NULL`);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_task_work_items_project_lifecycle");
+  },
+};
+
+/** Complete standalone TaskWorkItem migration chain in dependency order. */
+export const taskWorkItemMigrations: Migration[] = [
+  createTaskWorkItemsMigration,
+  addWorkItemProjectFieldsMigration,
+  addTaskWorkItemEventKeyMigration,
+  addTaskWorkItemPendingIndexesMigration,
+  addProjectLifecycleEventIndex,
+];

package/src/stores/ChannelBindingStore.ts

@@ -1,13 +1,16 @@
 import { Pool } from "pg";
 import type { PoolConfig } from "pg";
-import type {
-  Binding,
-  BindingRegistry,
-  CreateBindingInput,
+import {
+  DuplicateChannelBindingSubjectError,
+  type Binding, type BindingListParams, type BindingMutablePatch,
+  type BindingRegistry, type CreateBindingInput,
 } from "@axiom-lattice/protocols";
 import { MigrationManager } from "../migrations/migration";
 import { createChannelBindingsTable } from "../migrations/channel_bindings_migration";
 
+const BINDING_SUBJECT_CONSTRAINT =
+  "lattice_channel_bindings_channel_channel_installation_id_te_key";
+
 export interface ChannelBindingStoreOptions {
   pool?: Pool;
   poolConfig?: string | PoolConfig;
@@ -107,13 +110,33 @@ export class ChannelBindingStore implements BindingRegistry {
     return this.mapRowToBinding(result.rows[0]);
   }
 
-  async create(input: CreateBindingInput): Promise<Binding> {
+  async findById(tenantId: string, id: string): Promise<Binding | null> {
     await this.ensureInitialized();
     const result = await this.pool.query<BindingRow>(
+      "SELECT * FROM lattice_channel_bindings WHERE id = $1 AND tenant_id = $2",
+      [id, tenantId],
+    );
+    return result.rows[0] ? this.mapRowToBinding(result.rows[0]) : null;
+  }
+
+  async findBySubject(params: {
+    tenantId: string; channel: string; channelInstallationId: string; senderId: string;
+  }): Promise<Binding | null> {
+    await this.ensureInitialized();
+    const result = await this.pool.query<BindingRow>(`SELECT * FROM lattice_channel_bindings
+      WHERE tenant_id = $1 AND channel = $2 AND channel_installation_id = $3 AND sender_id = $4 LIMIT 1`,
+    [params.tenantId, params.channel, params.channelInstallationId, params.senderId]);
+    return result.rows[0] ? this.mapRowToBinding(result.rows[0]) : null;
+  }
+
+  async create(input: CreateBindingInput): Promise<Binding> {
+    await this.ensureInitialized();
+    try {
+      const result = await this.pool.query<BindingRow>(
       `INSERT INTO lattice_channel_bindings
          (channel, channel_installation_id, tenant_id, sender_id, agent_id,
-          thread_mode, sender_display_name, sender_metadata, workspace_id, project_id)
-       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+            thread_id, thread_mode, sender_display_name, sender_metadata, workspace_id, project_id, enabled)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
        RETURNING *`,
       [
         input.channel,
@@ -121,75 +144,58 @@ export class ChannelBindingStore implements BindingRegistry {
         input.tenantId,
         input.senderId,
         input.agentId,
+        input.threadId || null,
         input.threadMode || "fixed",
         input.senderDisplayName || null,
         input.senderMetadata ? JSON.stringify(input.senderMetadata) : null,
-        input.workspaceId || null,
-        input.projectId || null,
+         input.workspaceId || null,
+         input.projectId || null,
+         input.enabled ?? true,
       ],
-    );
-    return this.mapRowToBinding(result.rows[0]);
+      );
+      return this.mapRowToBinding(result.rows[0]);
+    } catch (error) {
+      if (isBindingSubjectConflict(error)) {
+        throw new DuplicateChannelBindingSubjectError();
+      }
+      throw error;
+    }
   }
 
-  async update(id: string, patch: Partial<Binding>): Promise<Binding> {
+  async update(tenantId: string, id: string, patch: BindingMutablePatch): Promise<Binding> {
     await this.ensureInitialized();
-    const existing = await this.pool.query<BindingRow>(
-      `SELECT * FROM lattice_channel_bindings WHERE id = $1`,
-      [id],
-    );
-    if (existing.rows.length === 0) {
-      throw new Error(`Binding ${id} not found`);
-    }
-
-    const row = existing.rows[0];
-    const updated = {
-      channel: patch.channel ?? row.channel,
-      channel_installation_id: patch.channelInstallationId ?? row.channel_installation_id,
-      sender_id: patch.senderId ?? row.sender_id,
-      agent_id: patch.agentId ?? row.agent_id,
-      thread_id: patch.threadId !== undefined ? patch.threadId : row.thread_id,
-      workspace_id: patch.workspaceId !== undefined ? patch.workspaceId : row.workspace_id,
-      project_id: patch.projectId !== undefined ? patch.projectId : row.project_id,
-      thread_mode: patch.threadMode ?? row.thread_mode,
-      sender_display_name: patch.senderDisplayName !== undefined
-        ? patch.senderDisplayName : row.sender_display_name,
-      sender_metadata: patch.senderMetadata !== undefined
-        ? patch.senderMetadata : row.sender_metadata,
-      enabled: patch.enabled ?? row.enabled,
-    };
-
     const result = await this.pool.query<BindingRow>(
       `UPDATE lattice_channel_bindings SET
-         channel = $1, channel_installation_id = $2, sender_id = $3,
-         agent_id = $4, thread_id = $5, workspace_id = $6, project_id = $7,
-         thread_mode = $8, sender_display_name = $9, sender_metadata = $10,
-         enabled = $11, updated_at = NOW()
-       WHERE id = $12
+         agent_id = COALESCE($1, agent_id),
+         thread_id = COALESCE($2, thread_id),
+         workspace_id = COALESCE($3, workspace_id),
+         project_id = COALESCE($4, project_id),
+         thread_mode = COALESCE($5, thread_mode),
+         sender_display_name = COALESCE($6, sender_display_name),
+         sender_metadata = COALESCE($7, sender_metadata),
+         enabled = COALESCE($8, enabled), updated_at = NOW()
+       WHERE id = $9 AND tenant_id = $10
        RETURNING *`,
       [
-        updated.channel, updated.channel_installation_id, updated.sender_id,
-        updated.agent_id, updated.thread_id, updated.workspace_id,
-        updated.project_id, updated.thread_mode, updated.sender_display_name,
-        updated.sender_metadata ? JSON.stringify(updated.sender_metadata) : null,
-        updated.enabled, id,
+        patch.agentId ?? null, patch.threadId ?? null, patch.workspaceId ?? null,
+        patch.projectId ?? null, patch.threadMode ?? null, patch.senderDisplayName ?? null,
+        patch.senderMetadata ? JSON.stringify(patch.senderMetadata) : null,
+        patch.enabled ?? null, id, tenantId,
       ],
     );
+    if (!result.rows[0]) throw new Error(`Binding ${id} not found`);
     return this.mapRowToBinding(result.rows[0]);
   }
 
-  async delete(id: string): Promise<void> {
+  async delete(tenantId: string, id: string): Promise<void> {
     await this.ensureInitialized();
-    await this.pool.query(`DELETE FROM lattice_channel_bindings WHERE id = $1`, [id]);
+    await this.pool.query(
+      `DELETE FROM lattice_channel_bindings WHERE id = $1 AND tenant_id = $2`,
+      [id, tenantId],
+    );
   }
 
-  async list(params: {
-    channel?: string;
-    agentId?: string;
-    tenantId: string;
-    channelInstallationId?: string;
-    limit?: number;
-    offset?: number;
-  }): Promise<Binding[]> {
+  async list(params: BindingListParams): Promise<Binding[]> {
     await this.ensureInitialized();
     const conditions: string[] = ["tenant_id = $1"];
     const values: unknown[] = [params.tenantId];
@@ -207,6 +213,14 @@ export class ChannelBindingStore implements BindingRegistry {
       conditions.push(`channel_installation_id = $${idx++}`);
       values.push(params.channelInstallationId);
     }
+    if (params.excludeChannels?.length) {
+      conditions.push(`channel <> ALL($${idx++}::text[])`);
+      values.push(params.excludeChannels);
+    }
+    for (const prefix of params.excludeInstallationIdPrefixes ?? []) {
+      conditions.push(`channel_installation_id NOT LIKE $${idx++} ESCAPE '\\'`);
+      values.push(`${escapeLikePattern(prefix)}%`);
+    }
 
     const limit = params.limit ?? 50;
     const offset = params.offset ?? 0;
@@ -222,7 +236,16 @@ export class ChannelBindingStore implements BindingRegistry {
     return result.rows.map((r) => this.mapRowToBinding(r));
   }
 
-  async import(bindings: CreateBindingInput[]): Promise<Binding[]> {
+  async import(tenantId: string, bindings: CreateBindingInput[]): Promise<Binding[]> {
+    if (bindings.some((binding) => binding.channel === "room")) {
+      throw new Error("Room bindings cannot be imported through the public store API");
+    }
+    if (bindings.some((binding) => binding.channelInstallationId.startsWith("room-internal:"))) {
+      throw new Error("Internal bindings cannot be imported through the public store API");
+    }
+    if (bindings.some((binding) => binding.tenantId !== tenantId)) {
+      throw new Error("Binding import tenant mismatch");
+    }
     const result: Binding[] = [];
     for (const input of bindings) {
       result.push(await this.create(input));
@@ -231,7 +254,13 @@ export class ChannelBindingStore implements BindingRegistry {
   }
 
   async export(params: { tenantId: string }): Promise<Binding[]> {
-    return this.list({ tenantId: params.tenantId, limit: 10000, offset: 0 });
+    return this.list({
+      tenantId: params.tenantId,
+      excludeChannels: ["room"],
+      excludeInstallationIdPrefixes: ["room-internal:"],
+      limit: 10000,
+      offset: 0,
+    });
   }
 
   private async ensureInitialized(): Promise<void> {
@@ -260,3 +289,14 @@ export class ChannelBindingStore implements BindingRegistry {
     };
   }
 }
+
+function isBindingSubjectConflict(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  const pgError = error as { code?: unknown; constraint?: unknown };
+  return pgError.code === "23505"
+    && pgError.constraint === BINDING_SUBJECT_CONSTRAINT;
+}
+
+function escapeLikePattern(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}

package/src/stores/PostgreSQLCapabilityBundleStore.ts

@@ -0,0 +1,306 @@
+import { randomUUID } from "crypto";
+import { Pool } from "pg";
+import type { PoolConfig } from "pg";
+import type {
+  CapabilityBundle,
+  CapabilityBundleDeleteResult,
+  CapabilityBundleStore,
+  InternalCreateCapabilityBundleInput,
+  InternalUpdateCapabilityBundleInput,
+} from "@axiom-lattice/protocols";
+import { MigrationManager } from "../migrations/migration";
+import { createCapabilityBundlesTable } from "../migrations/capability_bundle_migration";
+
+/**
+ * Configures PostgreSQL connectivity and migration behavior for capability bundles.
+ *
+ * @remarks
+ * An injected `pool` is externally managed and assumed to have migrations applied.
+ * When `poolConfig` is used, the store owns the pool and runs migrations eagerly
+ * unless `autoMigrate` is false. Call `initialize()` before use in that case.
+ */
+export interface PostgreSQLCapabilityBundleStoreOptions {
+  /** Externally managed PostgreSQL pool. */
+  pool?: Pool;
+  /** Connection string or pool configuration used to create an owned pool. */
+  poolConfig?: string | PoolConfig;
+  /** Whether an owned pool should run migrations during construction. @default true */
+  autoMigrate?: boolean;
+}
+
+type Row = {
+  id: string;
+  tenant_id: string;
+  bundle_key: string;
+  name: string;
+  description: string | null;
+  capabilities: unknown;
+  created_at: Date;
+  updated_at: Date | string;
+};
+const duplicateMessage = "Capability bundle key already exists for tenant";
+function map(row: Row): CapabilityBundle {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    key: row.bundle_key,
+    name: row.name,
+    description: row.description ?? undefined,
+    capabilities: row.capabilities as CapabilityBundle["capabilities"],
+    createdAt: row.created_at.toISOString(),
+    updatedAt: typeof row.updated_at === "string" ? row.updated_at : row.updated_at.toISOString(),
+  };
+}
+
+function isDuplicate(error: unknown): boolean {
+  return typeof error === "object"
+    && error !== null
+    && "code" in error
+    && error.code === "23505";
+}
+
+/**
+ * Persists tenant-scoped capability bundles in PostgreSQL.
+ *
+ * @example
+ * ```ts
+ * const store = new PostgreSQLCapabilityBundleStore({ poolConfig: connectionString });
+ * await store.initialize();
+ * const bundles = await store.listByTenant("tenant-1");
+ * await store.dispose();
+ * ```
+ *
+ * @remarks
+ * Stores created from `poolConfig` own their pool and must be disposed. Stores
+ * created with an injected pool neither migrate nor close that pool.
+ */
+export class PostgreSQLCapabilityBundleStore implements CapabilityBundleStore {
+  private readonly pool: Pool;
+  private migrationManager!: MigrationManager;
+  private initialized = false;
+  private ownsPool = true;
+  private initPromise: Promise<void> | null = null;
+
+  /**
+   * Creates a PostgreSQL capability bundle store.
+   *
+   * @param options - Pool ownership, connection, and migration options.
+   */
+  constructor(options: PostgreSQLCapabilityBundleStoreOptions) {
+    if (options.pool) {
+      this.pool = options.pool;
+      this.ownsPool = false;
+      this.initialized = true;
+      return;
+    }
+
+    this.pool = typeof options.poolConfig === "string"
+      ? new Pool({ connectionString: options.poolConfig })
+      : options.poolConfig
+        ? new Pool(options.poolConfig)
+        : (() => { throw new Error("Either pool or poolConfig must be provided"); })();
+
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createCapabilityBundlesTable);
+
+    if (options.autoMigrate !== false) {
+      this.startInitialization();
+    }
+  }
+
+  /**
+   * Applies pending migrations for an internally managed pool.
+   *
+   * @returns A shared promise that resolves when initialization completes.
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+    if (this.initPromise) return this.initPromise;
+    return this.startInitialization();
+  }
+
+  private startInitialization(): Promise<void> {
+    this.initPromise = this.migrationManager.migrate().then(() => {
+      this.initialized = true;
+    });
+    void this.initPromise.catch(() => undefined);
+    return this.initPromise;
+  }
+
+  /**
+   * Closes the pool when it was created by this store.
+   *
+   * @returns A promise that resolves after owned resources are released.
+   */
+  async dispose(): Promise<void> {
+    if (this.ownsPool) await this.pool.end();
+  }
+
+  private async ready(): Promise<void> {
+    if (!this.initialized) await this.initialize();
+  }
+
+  async listByTenant(tenantId: string): Promise<CapabilityBundle[]> {
+    await this.ready();
+    const result = await this.pool.query<Row>(
+      "SELECT id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at FROM lattice_capability_bundles WHERE tenant_id = $1 ORDER BY created_at",
+      [tenantId],
+    );
+    return result.rows.map(map);
+  }
+
+  async getById(tenantId: string, id: string): Promise<CapabilityBundle | null> {
+    await this.ready();
+    const result = await this.pool.query<Row>(
+      "SELECT id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at FROM lattice_capability_bundles WHERE tenant_id = $1 AND id = $2",
+      [tenantId, id],
+    );
+    return result.rows[0] ? map(result.rows[0]) : null;
+  }
+
+  async getManyByIds(tenantId: string, ids: string[]): Promise<CapabilityBundle[]> {
+    await this.ready();
+    if (ids.length === 0) return [];
+    const result = await this.pool.query<Row>(
+      "SELECT id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at FROM lattice_capability_bundles WHERE tenant_id = $1 AND id = ANY($2::uuid[])",
+      [tenantId, ids],
+    );
+    return result.rows.map(map);
+  }
+
+  async create(
+    tenantId: string,
+    input: InternalCreateCapabilityBundleInput,
+  ): Promise<CapabilityBundle> {
+    await this.ready();
+    try {
+      const result = await this.pool.query<Row>(
+        `INSERT INTO lattice_capability_bundles
+         (id, tenant_id, bundle_key, name, description, capabilities)
+         VALUES ($1, $2, $3, $4, $5, $6::jsonb)
+          RETURNING id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at`,
+        [
+          randomUUID(),
+          tenantId,
+          input.key,
+          input.name,
+          input.description ?? null,
+          JSON.stringify(input.capabilities),
+        ],
+      );
+      return map(result.rows[0]);
+    } catch (error) {
+      if (isDuplicate(error)) throw new Error(duplicateMessage);
+      throw error;
+    }
+  }
+
+  async update(
+    tenantId: string,
+    id: string,
+    input: InternalUpdateCapabilityBundleInput,
+  ): Promise<CapabilityBundle | { status: "conflict" } | null> {
+    await this.ready();
+    const fields: string[] = [];
+    const values: unknown[] = [];
+    const add = (field: string, value: unknown): void => {
+      values.push(value);
+      fields.push(`${field} = $${values.length}`);
+    };
+    if (input.name !== undefined) add("name", input.name);
+    if (Object.prototype.hasOwnProperty.call(input, "description")) {
+      add("description", input.description ?? null);
+    }
+    if (input.capabilities !== undefined) {
+      add("capabilities", JSON.stringify(input.capabilities));
+    }
+    if (fields.length === 0) {
+      const expectedUpdatedAt = input.expectedUpdatedAt;
+      const result = await this.pool.query<Row>(
+        `SELECT id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at
+         FROM lattice_capability_bundles
+         WHERE tenant_id = $1 AND id = $2${expectedUpdatedAt === undefined ? "" : " AND updated_at::text = $3"}`,
+        expectedUpdatedAt === undefined ? [tenantId, id] : [tenantId, id, expectedUpdatedAt],
+      );
+      if (result.rows[0]) return map(result.rows[0]);
+      return expectedUpdatedAt === undefined ? null : { status: "conflict" };
+    }
+
+     const expectedUpdatedAt = input.expectedUpdatedAt;
+     values.push(tenantId, id);
+     if (expectedUpdatedAt !== undefined) values.push(expectedUpdatedAt);
+     const tenantParam = values.length - (expectedUpdatedAt === undefined ? 1 : 2);
+     const idParam = tenantParam + 1;
+     const revisionPredicate = expectedUpdatedAt === undefined ? "" : ` AND updated_at::text = $${values.length}`;
+    try {
+      const result = await this.pool.query<Row>(
+         `UPDATE lattice_capability_bundles
+          SET ${fields.join(", ")}, updated_at = GREATEST(updated_at + interval '1 microsecond', clock_timestamp())
+          WHERE tenant_id = $${tenantParam} AND id = $${idParam}${revisionPredicate}
+         RETURNING id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at::text AS updated_at`,
+        values,
+      );
+       if (result.rows[0]) return map(result.rows[0]);
+       return expectedUpdatedAt === undefined ? null : { status: "conflict" };
+    } catch (error) {
+      if (isDuplicate(error)) throw new Error(duplicateMessage);
+      throw error;
+    }
+  }
+
+  async deleteIfUnreferenced(tenantId: string, id: string): Promise<CapabilityBundleDeleteResult> {
+    await this.ready();
+    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],
+      );
+      const projectIds = await client.query<{ id: string }>(
+        `SELECT id FROM lattice_projects
+         WHERE tenant_id = $1
+         ORDER BY id`,
+        [tenantId],
+      );
+      if (projectIds.rows.length > 0) {
+        await client.query(
+          `SELECT pg_advisory_xact_lock(hashtextextended($1 || ':project:' || project_id, 0))
+           FROM unnest($2::text[]) AS project_id
+           ORDER BY project_id`,
+          [tenantId, projectIds.rows.map((project) => project.id)],
+        );
+      }
+      await client.query(
+        `SELECT id FROM lattice_projects
+         WHERE tenant_id = $1
+         FOR UPDATE`,
+        [tenantId],
+      );
+      await client.query("SELECT pg_advisory_xact_lock(hashtextextended($1 || ':' || $2, 0))", [tenantId, id]);
+      const referenced = await client.query(
+        `SELECT 1 FROM lattice_projects
+         WHERE tenant_id = $1
+         AND jsonb_typeof(config->'capabilityBundleIds') = 'array'
+         AND COALESCE(config->'capabilityBundleIds', '[]'::jsonb) ? $2
+         LIMIT 1`,
+        [tenantId, id],
+      );
+      if (referenced.rows.length > 0) {
+        await client.query("COMMIT");
+        return "in_use";
+      }
+      const deleted = await client.query(
+        "DELETE FROM lattice_capability_bundles WHERE tenant_id = $1 AND id = $2 RETURNING id",
+        [tenantId, id],
+      );
+      await client.query("COMMIT");
+      return deleted.rows.length > 0 ? "deleted" : "not_found";
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+}