@axiom-lattice/local-stores 3.0.2 → 3.1.1

package/dist/index.js

@@ -34,6 +34,7 @@ __export(index_exports, {
   InMemoryConversationStore: () => InMemoryConversationStore,
   LocalA2AApiKeyStore: () => LocalA2AApiKeyStore,
   LocalAssistantStore: () => LocalAssistantStore,
+  LocalCapabilityBundleStore: () => LocalCapabilityBundleStore,
   LocalChannelBindingStore: () => LocalChannelBindingStore,
   LocalChannelInstallationStore: () => LocalChannelInstallationStore,
   LocalConnectionStore: () => LocalConnectionStore,
@@ -656,6 +657,7 @@ function mapRowToWorkspace(row) {
 }
 
 // src/stores/LocalProjectStore.ts
+var import_protocols = require("@axiom-lattice/protocols");
 var DDL4 = `
 CREATE TABLE IF NOT EXISTS lt_projects (
   id TEXT NOT NULL,
@@ -696,6 +698,7 @@ var LocalProjectStore = class {
     return row ? mapRowToProject(row) : null;
   }
   async createProject(tenantId, workspaceId, id, data) {
+    (0, import_protocols.assertGenericProjectConfig)(data.config);
     const now = nowISO();
     const kind = data.kind || "business";
     this.db.prepare(
@@ -705,23 +708,18 @@ var LocalProjectStore = class {
          workspace_id = excluded.workspace_id,
          name = excluded.name,
          description = excluded.description,
-         config = excluded.config,
+         config = CASE
+           WHEN json_type(lt_projects.config, '$.capabilityBundleIds') IS NOT NULL
+           THEN json_set(COALESCE(excluded.config, '{}'), '$.capabilityBundleIds', json_extract(lt_projects.config, '$.capabilityBundleIds'))
+           ELSE excluded.config
+         END,
          kind = excluded.kind,
          updated_at = excluded.updated_at`
     ).run(id, tenantId, workspaceId, data.name, data.description || null, data.config ? JSON.stringify(data.config) : null, kind, now, now);
-    return {
-      id,
-      tenantId,
-      workspaceId,
-      name: data.name,
-      description: data.description,
-      config: data.config,
-      kind,
-      createdAt: parseISO(now),
-      updatedAt: parseISO(now)
-    };
+    return await this.getProjectById(tenantId, id);
   }
   async updateProject(tenantId, id, updates) {
+    (0, import_protocols.assertGenericProjectConfig)(updates.config);
     const existing = await this.getProjectById(tenantId, id);
     if (!existing) return null;
     const setClauses = [];
@@ -735,8 +733,13 @@ var LocalProjectStore = class {
       values.push(updates.description || null);
     }
     if (updates.config !== void 0) {
-      setClauses.push("config = ?");
-      values.push(updates.config ? JSON.stringify(updates.config) : null);
+      setClauses.push(`config = CASE
+        WHEN json_type(config, '$.capabilityBundleIds') IS NOT NULL
+        THEN json_set(json(?), '$.capabilityBundleIds', json_extract(config, '$.capabilityBundleIds'))
+        ELSE ?
+      END`);
+      const config = JSON.stringify(updates.config ?? {});
+      values.push(config, config);
     }
     if (updates.kind !== void 0) {
       setClauses.push("kind = ?");
@@ -758,6 +761,52 @@ var LocalProjectStore = class {
     ).run(tenantId, id);
     return result.changes > 0;
   }
+  async updateCapabilityBundleIds(tenantId, projectId, bundleIds, expectedRevisions = {}) {
+    const now = nowISO();
+    const result = this.db.prepare(
+      `UPDATE lt_projects
+       SET config = json_set(COALESCE(config, '{}'), '$.capabilityBundleIds', json(?)), updated_at = ?
+       WHERE tenant_id = ? AND id = ?
+        AND NOT EXISTS (
+          SELECT 1 FROM json_each(?) AS requested
+         WHERE NOT EXISTS (
+           SELECT 1 FROM lt_capability_bundles
+           WHERE tenant_id = ? AND id = requested.value
+          )
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM json_each(?) AS expected
+          WHERE EXISTS (
+            SELECT 1 FROM lt_capability_bundles
+            WHERE tenant_id = ? AND id = expected.key AND updated_at <> expected.value
+          )
+        )`
+    ).run(JSON.stringify(bundleIds), now, tenantId, projectId, JSON.stringify(bundleIds), tenantId, JSON.stringify(expectedRevisions), tenantId);
+    if (result.changes > 0) {
+      const project = await this.getProjectById(tenantId, projectId);
+      return project ? { status: "updated", project } : { status: "project_not_found" };
+    }
+    const revisionMismatch = this.db.prepare(
+      "SELECT 1 FROM lt_capability_bundles WHERE tenant_id = ? AND id IN (SELECT key FROM json_each(?)) AND updated_at <> (SELECT value FROM json_each(?) WHERE key = lt_capability_bundles.id) LIMIT 1"
+    ).get(tenantId, JSON.stringify(expectedRevisions), JSON.stringify(expectedRevisions));
+    if (revisionMismatch) return { status: "bundle_conflict" };
+    return await this.getProjectById(tenantId, projectId) ? { status: "bundle_not_found" } : { status: "project_not_found" };
+  }
+  async isCapabilityBundleReferenced(tenantId, bundleId) {
+    const rows = this.db.prepare("SELECT config FROM lt_projects WHERE tenant_id = ?").all(tenantId);
+    return rows.some((row) => {
+      if (!row.config) return false;
+      let config;
+      try {
+        config = JSON.parse(row.config);
+      } catch {
+        return false;
+      }
+      if (config === null || typeof config !== "object" || Array.isArray(config)) return false;
+      const ids = config.capabilityBundleIds;
+      return Array.isArray(ids) && ids.every((id) => typeof id === "string") && ids.includes(bundleId);
+    });
+  }
   /** Add a column if it does not exist (SQLite version compatible). */
   ensureColumn(table, column, ddl) {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
@@ -2236,8 +2285,34 @@ var LocalEvalStore = class {
     return this.getProjectById(tenantId, id);
   }
   async deleteProject(tenantId, id) {
-    const result = this.db.prepare(`DELETE FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`).run(tenantId, id);
-    return result.changes > 0;
+    const db = this.db.getRawDb();
+    db.run("BEGIN TRANSACTION");
+    try {
+      db.run(
+        `DELETE FROM lt_eval_run_results
+         WHERE run_id IN (
+           SELECT id FROM lt_eval_runs WHERE tenant_id = ? AND project_id = ?
+         )`,
+        [tenantId, id]
+      );
+      db.run(
+        `DELETE FROM lt_eval_cases
+         WHERE tenant_id = ? AND suite_id IN (
+           SELECT id FROM lt_eval_suites WHERE tenant_id = ? AND project_id = ?
+         )`,
+        [tenantId, tenantId, id]
+      );
+      db.run(`DELETE FROM lt_eval_runs WHERE tenant_id = ? AND project_id = ?`, [tenantId, id]);
+      db.run(`DELETE FROM lt_eval_suites WHERE tenant_id = ? AND project_id = ?`, [tenantId, id]);
+      db.run(`DELETE FROM lt_eval_projects WHERE tenant_id = ? AND id = ?`, [tenantId, id]);
+      const deleted = db.getRowsModified() > 0;
+      db.run("COMMIT");
+      this.db.save();
+      return deleted;
+    } catch (error) {
+      db.run("ROLLBACK");
+      throw error;
+    }
   }
   // -------------------------------------------------------------------------
   // Suites
@@ -3097,11 +3172,11 @@ var LocalA2AApiKeyStore = class {
     const rows = this.db.prepare(
       `SELECT * FROM lt_a2a_api_keys WHERE enabled = 1`
     ).all();
-    const map = /* @__PURE__ */ new Map();
+    const map2 = /* @__PURE__ */ new Map();
     for (const row of rows) {
       try {
         const key = (0, import_core3.decrypt)(row.key_value);
-        map.set(key, {
+        map2.set(key, {
           key,
           tenantId: row.tenant_id,
           projectId: row.project_id,
@@ -3110,7 +3185,7 @@ var LocalA2AApiKeyStore = class {
       } catch {
       }
     }
-    return map;
+    return map2;
   }
 };
 function mapRowToRecord(row) {
@@ -3157,6 +3232,7 @@ CREATE INDEX IF NOT EXISTS idx_lt_tmq_pending ON lt_thread_message_queue(status,
 `;
 var LocalThreadMessageQueueStore = class {
   constructor(db) {
+    this.capacityTail = Promise.resolve();
     this.db = db;
     ensureTable(db, DDL17);
   }
@@ -3175,18 +3251,65 @@ var LocalThreadMessageQueueStore = class {
       params.threadId,
       params.tenantId,
       params.assistantId,
-      params.workspaceId || null,
-      params.projectId || null,
+      params.workspaceId ?? null,
+      params.projectId ?? null,
       JSON.stringify(params.content),
       params.type || "human",
       nextSeq,
-      params.priority || 0,
+      params.priority ?? 0,
       params.command ? JSON.stringify(params.command) : null,
       params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
       now
     );
     return this.getById(id);
   }
+  async addMessageIfCapacity(params, maxSize) {
+    let release;
+    const previous = this.capacityTail;
+    this.capacityTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      const scope = {
+        tenantId: params.tenantId,
+        assistantId: params.assistantId,
+        workspaceId: params.workspaceId,
+        projectId: params.projectId
+      };
+      const filter = scopeClause(scope);
+      const id = params.id || (0, import_crypto4.randomUUID)();
+      const limit = maxSize === Infinity ? -1 : maxSize;
+      const result = this.db.prepare(
+        `INSERT INTO lt_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, created_at)
+         SELECT ?, ?, ?, ?, ?, ?, ?, ?,
+           (SELECT COALESCE(MAX(sequence_order), 0) + 1 FROM lt_thread_message_queue WHERE thread_id = ?),
+           ?, ?, ?, ?
+         WHERE ? = -1 OR (SELECT COUNT(*) FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql}) < ?`
+      ).run(
+        id,
+        params.threadId,
+        params.tenantId,
+        params.assistantId,
+        params.workspaceId ?? null,
+        params.projectId ?? null,
+        JSON.stringify(params.content),
+        params.type || "human",
+        params.threadId,
+        params.priority ?? 0,
+        params.command ? JSON.stringify(params.command) : null,
+        params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
+        nowISO(),
+        limit,
+        params.threadId,
+        ...filter.params,
+        limit
+      );
+      return result.changes > 0;
+    } finally {
+      release();
+    }
+  }
   async addMessageAtHead(params) {
     const now = nowISO();
     const id = params.id || (0, import_crypto4.randomUUID)();
@@ -3201,8 +3324,8 @@ var LocalThreadMessageQueueStore = class {
       params.threadId,
       params.tenantId,
       params.assistantId,
-      params.workspaceId || null,
-      params.projectId || null,
+      params.workspaceId ?? null,
+      params.projectId ?? null,
       JSON.stringify(params.content),
       params.type || "human",
       seqRow.next_seq,
@@ -3212,50 +3335,63 @@ var LocalThreadMessageQueueStore = class {
     );
     return this.getById(id);
   }
-  async getPendingMessages(threadId) {
+  async getPendingMessages(threadId, scope) {
+    const filter = scopeClause(scope);
     const rows = this.db.prepare(
-      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending' ORDER BY priority DESC, sequence_order ASC`
-    ).all(threadId);
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql} ORDER BY priority DESC, sequence_order ASC`
+    ).all(threadId, ...filter.params);
     return rows.map(rowToMessage);
   }
-  async getProcessingMessages(threadId) {
+  async getProcessingMessages(threadId, scope) {
+    const filter = scopeClause(scope);
     const rows = this.db.prepare(
-      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'processing' ORDER BY priority DESC, sequence_order ASC`
-    ).all(threadId);
+      `SELECT * FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'processing'${filter.sql} ORDER BY priority DESC, sequence_order ASC`
+    ).all(threadId, ...filter.params);
     return rows.map(rowToMessage);
   }
-  async getQueueSize(threadId) {
+  async getQueueSize(threadId, scope) {
+    const filter = scopeClause(scope);
     const row = this.db.prepare(
-      `SELECT COUNT(*) as count FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'`
-    ).get(threadId);
+      `SELECT COUNT(*) as count FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql}`
+    ).get(threadId, ...filter.params);
     return row.count;
   }
   async getThreadsWithPendingMessages() {
     const rows = this.db.prepare(
-      `SELECT DISTINCT ON (thread_id) tenant_id, assistant_id, thread_id, workspace_id, project_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') ORDER BY thread_id`
+      `SELECT tenant_id, assistant_id, thread_id, workspace_id, project_id FROM lt_thread_message_queue WHERE status IN ('pending', 'processing') GROUP BY tenant_id, assistant_id, thread_id, workspace_id, project_id ORDER BY thread_id`
     ).all();
     return rows.map((r) => ({
       tenantId: r.tenant_id,
       assistantId: r.assistant_id,
       threadId: r.thread_id,
-      workspaceId: r.workspace_id || void 0,
-      projectId: r.project_id || void 0
+      workspaceId: r.workspace_id,
+      projectId: r.project_id
     }));
   }
-  async removeMessage(messageId) {
-    const result = this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE id = ?`).run(messageId);
+  async removeMessage(messageId, scope) {
+    const filter = scopeClause(scope);
+    const result = this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE id = ?${filter.sql}`).run(messageId, ...filter.params);
     return result.changes > 0;
   }
-  async clearMessages(threadId) {
-    this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE thread_id = ?`).run(threadId);
+  async clearMessages(threadId, scope) {
+    const filter = scopeClause(scope);
+    this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE thread_id = ?${filter.sql}`).run(threadId, ...filter.params);
   }
-  async markProcessing(messageId) {
-    this.db.prepare(`UPDATE lt_thread_message_queue SET status = 'processing' WHERE id = ?`).run(messageId);
+  async markProcessing(messageId, customRunConfig, scope) {
+    const filter = scopeClause(scope);
+    if (customRunConfig === void 0) {
+      this.db.prepare(`UPDATE lt_thread_message_queue SET status = 'processing' WHERE id = ?${filter.sql}`).run(messageId, ...filter.params);
+      return;
+    }
+    this.db.prepare(
+      `UPDATE lt_thread_message_queue SET status = 'processing', custom_run_config = ? WHERE id = ?${filter.sql}`
+    ).run(JSON.stringify(customRunConfig), messageId, ...filter.params);
   }
-  async resetProcessingToPending(threadId) {
+  async resetProcessingToPending(threadId, scope) {
+    const filter = scopeClause(scope);
     const result = this.db.prepare(
-      `UPDATE lt_thread_message_queue SET status = 'pending' WHERE thread_id = ? AND status = 'processing'`
-    ).run(threadId);
+      `UPDATE lt_thread_message_queue SET status = 'pending' WHERE thread_id = ? AND status = 'processing'${filter.sql}`
+    ).run(threadId, ...filter.params);
     return result.changes;
   }
   getById(id) {
@@ -3263,6 +3399,14 @@ var LocalThreadMessageQueueStore = class {
     return rowToMessage(row);
   }
 };
+function scopeClause(scope) {
+  if (!scope) return { sql: "", params: [] };
+  const entries = ["tenantId", "assistantId", "workspaceId", "projectId"].map((key) => [key, scope[key]]);
+  return {
+    sql: entries.map(([key, value]) => ` AND ${key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)} ${value == null ? "IS NULL" : "= ?"}`).join(""),
+    params: entries.flatMap(([, value]) => value == null ? [] : [value])
+  };
+}
 function rowToMessage(row) {
   return {
     id: row.id,
@@ -4417,6 +4561,7 @@ var LocalTaskStore = class {
 };
 
 // src/stores/LocalTaskWorkItemStore.ts
+var import_protocols2 = require("@axiom-lattice/protocols");
 var import_uuid2 = require("uuid");
 var DDL21 = `
 CREATE TABLE IF NOT EXISTS lt_task_work_items (
@@ -4461,6 +4606,11 @@ var LocalTaskWorkItemStore = class {
     this.ensureColumn("lt_task_work_items", "event_key", "event_key TEXT");
     this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_task_work_items_event_key
       ON lt_task_work_items (tenant_id, task_id, event_key);`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_task_work_items_pending_order
+      ON lt_task_work_items (tenant_id, task_id, action, created_at DESC, id DESC);`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_task_work_items_reconciled_result
+      ON lt_task_work_items (tenant_id, task_id, json_extract(detail, '$.executionResultId'))
+      WHERE action = 'execution_reconciled';`);
   }
   /** Add a column if it does not exist (SQLite version compatible). */
   ensureColumn(table, column, ddl) {
@@ -4551,6 +4701,132 @@ var LocalTaskWorkItemStore = class {
     ).all(...params, limit, offset);
     return rows.map(mapRowToWorkItem);
   }
+  /** List pending execution results using one bounded SQLite anti-join query. */
+  async listPendingExecutionResults(params) {
+    if (!Number.isSafeInteger(params.limit) || params.limit < 0 || params.limit > import_protocols2.MAX_PENDING_EXECUTION_RESULTS_LIMIT) {
+      const error = new RangeError(`limit must be a safe integer between 0 and ${import_protocols2.MAX_PENDING_EXECUTION_RESULTS_LIMIT}`);
+      error.code = "INVALID_LIMIT";
+      throw error;
+    }
+    if (params.limit === 0) return [];
+    const rows = this.db.prepare(
+      `SELECT result.*
+       FROM lt_task_work_items AS result
+       WHERE result.tenant_id = ?
+         AND result.task_id = ?
+         AND result.action = 'execution_result'
+         AND substr(result.event_key, 1, 17) = 'execution-result:'
+         AND length(result.event_key) > 17
+         AND result.event_key NOT GLOB '*[^A-Za-z0-9._:-]*'
+         AND NOT EXISTS (
+           SELECT 1
+           FROM lt_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 json_extract(reconciled.detail, '$.executionResultId') = result.event_key
+         )
+       ORDER BY result.created_at DESC, result.id DESC
+       LIMIT ?`
+    ).all(params.tenantId, params.taskId, params.limit);
+    return rows.map(mapRowToWorkItem);
+  }
+};
+
+// src/stores/LocalCapabilityBundleStore.ts
+var import_crypto6 = require("crypto");
+var DDL22 = `CREATE TABLE IF NOT EXISTS lt_capability_bundles (id TEXT NOT NULL, tenant_id TEXT NOT NULL, bundle_key TEXT NOT NULL, name TEXT NOT NULL, description TEXT, capabilities TEXT NOT NULL DEFAULT '[]', created_at TEXT NOT NULL, updated_at TEXT NOT NULL, PRIMARY KEY (tenant_id, id), UNIQUE (tenant_id, bundle_key)); CREATE INDEX IF NOT EXISTS idx_lt_capability_bundles_tenant ON lt_capability_bundles(tenant_id);`;
+var duplicateMessage = "Capability bundle key already exists for tenant";
+function map(row) {
+  return { id: row.id, tenantId: row.tenant_id, key: row.bundle_key, name: row.name, description: row.description ?? void 0, capabilities: JSON.parse(row.capabilities), createdAt: parseISO(row.created_at).toISOString(), updatedAt: parseISO(row.updated_at).toISOString() };
+}
+function isConstraint(error) {
+  return error instanceof Error && /UNIQUE constraint failed/.test(error.message);
+}
+function nextTimestamp(previous) {
+  const now = Date.now();
+  const previousTime = previous ? Date.parse(previous) : Number.NaN;
+  return new Date(Math.max(now, Number.isFinite(previousTime) ? previousTime + 1 : now)).toISOString();
+}
+var LocalCapabilityBundleStore = class {
+  /**
+   * Creates a capability bundle store over an initialized sql.js database.
+   *
+   * @param db - Shared local database wrapper used for persistence.
+   */
+  constructor(db) {
+    this.db = db;
+    ensureTable(db, DDL22);
+  }
+  async listByTenant(tenantId) {
+    return this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? ORDER BY created_at").all(tenantId).map(map);
+  }
+  async getById(tenantId, id) {
+    const row = this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? AND id = ?").get(tenantId, id);
+    return row ? map(row) : null;
+  }
+  async getManyByIds(tenantId, ids) {
+    return ids.flatMap((id) => {
+      const row = this.db.prepare("SELECT * FROM lt_capability_bundles WHERE tenant_id = ? AND id = ?").get(tenantId, id);
+      return row ? [map(row)] : [];
+    });
+  }
+  async create(tenantId, input) {
+    const now = nextTimestamp();
+    const id = (0, import_crypto6.randomUUID)();
+    try {
+      this.db.prepare("INSERT INTO lt_capability_bundles (id, tenant_id, bundle_key, name, description, capabilities, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(id, tenantId, input.key, input.name, input.description ?? null, JSON.stringify(input.capabilities), now, now);
+    } catch (error) {
+      if (isConstraint(error)) throw new Error(duplicateMessage);
+      throw error;
+    }
+    return await this.getById(tenantId, id);
+  }
+  async update(tenantId, id, input) {
+    const existing = await this.getById(tenantId, id);
+    if (!existing) return null;
+    if (input.expectedUpdatedAt !== void 0 && input.expectedUpdatedAt !== existing.updatedAt) return { status: "conflict" };
+    const fields = [];
+    const values = [];
+    const add = (field, value) => {
+      fields.push(`${field} = ?`);
+      values.push(value);
+    };
+    if (input.name !== void 0) add("name", input.name);
+    if (Object.prototype.hasOwnProperty.call(input, "description")) add("description", input.description ?? null);
+    if (input.capabilities !== void 0) add("capabilities", JSON.stringify(input.capabilities));
+    if (!fields.length) return existing;
+    const now = nextTimestamp(existing.updatedAt);
+    fields.push("updated_at = ?");
+    values.push(now, tenantId, id);
+    try {
+      if (input.expectedUpdatedAt !== void 0) {
+        const result = this.db.prepare(`UPDATE lt_capability_bundles SET ${fields.join(", ")} WHERE tenant_id = ? AND id = ? AND updated_at = ?`).run(...values, input.expectedUpdatedAt);
+        if (result.changes === 0) return { status: "conflict" };
+      } else {
+        this.db.prepare(`UPDATE lt_capability_bundles SET ${fields.join(", ")} WHERE tenant_id = ? AND id = ?`).run(...values);
+      }
+    } catch (error) {
+      if (isConstraint(error)) throw new Error(duplicateMessage);
+      throw error;
+    }
+    return this.getById(tenantId, id);
+  }
+  async deleteIfUnreferenced(tenantId, id) {
+    const result = this.db.prepare(
+      `DELETE FROM lt_capability_bundles
+       WHERE tenant_id = ? AND id = ?
+       AND NOT EXISTS (
+         SELECT 1 FROM lt_projects
+         WHERE tenant_id = ?
+         AND json_type(config, '$.capabilityBundleIds') = 'array'
+         AND EXISTS (SELECT 1 FROM json_each(config, '$.capabilityBundleIds') WHERE value = ?)
+       )`
+    ).run(tenantId, id, tenantId, id);
+    if (result.changes > 0) return "deleted";
+    if (await this.getById(tenantId, id)) return "in_use";
+    return "not_found";
+  }
 };
 
 // src/createLocalStoreConfig.ts
@@ -4579,6 +4855,7 @@ async function createLocalStoreConfig(options = {}) {
     schedule: new LocalScheduleStorage(db),
     task: new LocalTaskStore(db),
     taskWorkItem: new LocalTaskWorkItemStore(db),
+    capabilityBundle: new LocalCapabilityBundleStore(db),
     checkpoint: import_langgraph_checkpoint_sqlite.SqliteSaver.fromConnString(dbPath)
   };
 }
@@ -4625,6 +4902,7 @@ var InMemoryConversationStore = class {
   InMemoryConversationStore,
   LocalA2AApiKeyStore,
   LocalAssistantStore,
+  LocalCapabilityBundleStore,
   LocalChannelBindingStore,
   LocalChannelInstallationStore,
   LocalConnectionStore,