@axiom-lattice/local-stores 3.0.2 → 3.1.1

package/src/stores/LocalEvalStore.ts

@@ -264,8 +264,34 @@ export class LocalEvalStore implements EvalStore {
   }
 
   async deleteProject(tenantId: string, id: string): Promise<boolean> {
-    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;
+    }
   }
 
   // -------------------------------------------------------------------------

package/src/stores/LocalProjectStore.ts

@@ -9,7 +9,9 @@ import type {
   ProjectFilter,
   CreateProjectRequest,
   UpdateProjectRequest,
+  UpdateProjectCapabilityBundlesResult,
 } from "@axiom-lattice/protocols";
+import { assertGenericProjectConfig } from "@axiom-lattice/protocols";
 import { ensureTable, nowISO, parseISO } from "../database";
 
 const DDL = `
@@ -75,6 +77,7 @@ export class LocalProjectStore implements ProjectStore {
     id: string,
     data: CreateProjectRequest,
   ): Promise<Project> {
+    assertGenericProjectConfig(data.config);
     const now = nowISO();
     const kind = data.kind || "business";
 
@@ -85,22 +88,16 @@ export class LocalProjectStore implements ProjectStore {
          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)) as Project;
   }
 
   async updateProject(
@@ -108,6 +105,7 @@ export class LocalProjectStore implements ProjectStore {
     id: string,
     updates: UpdateProjectRequest,
   ): Promise<Project | null> {
+    assertGenericProjectConfig(updates.config);
     const existing = await this.getProjectById(tenantId, id);
     if (!existing) return null;
 
@@ -123,8 +121,13 @@ export class LocalProjectStore implements ProjectStore {
       values.push(updates.description || null);
     }
     if (updates.config !== undefined) {
-      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 !== undefined) {
       setClauses.push("kind = ?");
@@ -152,6 +155,56 @@ export class LocalProjectStore implements ProjectStore {
     return result.changes > 0;
   }
 
+  async updateCapabilityBundleIds(tenantId: string, projectId: string, bundleIds: string[], expectedRevisions: Record<string, string> = {}): Promise<UpdateProjectCapabilityBundlesResult> {
+    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: string, bundleId: string): Promise<boolean> {
+    const rows = this.db.prepare("SELECT config FROM lt_projects WHERE tenant_id = ?").all(tenantId) as unknown as Array<{ config: string | null }>;
+    return rows.some((row) => {
+      if (!row.config) return false;
+      let config: Record<string, unknown>;
+      try {
+        config = JSON.parse(row.config) as Record<string, unknown>;
+      } 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). */
   private ensureColumn(table: string, column: string, ddl: string): void {
     const cols = this.db.prepare(`PRAGMA table_info(${table})`).all() as unknown as Array<{ name: string }>;

package/src/stores/LocalTaskWorkItemStore.ts

@@ -10,6 +10,7 @@ import type {
   CreateWorkItemIfAbsentRequest,
   TaskWorkItemListFilter,
 } from "@axiom-lattice/protocols";
+import { MAX_PENDING_EXECUTION_RESULTS_LIMIT } from "@axiom-lattice/protocols";
 import { ensureTable, nowISO, parseISO } from "../database";
 import { v4 as uuid } from "uuid";
 
@@ -76,6 +77,11 @@ export class LocalTaskWorkItemStore implements TaskWorkItemStore {
     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). */
@@ -154,4 +160,43 @@ export class LocalTaskWorkItemStore implements TaskWorkItemStore {
     ).all(...params, limit, offset) as unknown as WorkItemRow[];
     return rows.map(mapRowToWorkItem);
   }
+
+  /** List pending execution results using one bounded SQLite 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 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) as unknown as WorkItemRow[];
+    return rows.map(mapRowToWorkItem);
+  }
 }

package/src/stores/LocalThreadMessageQueueStore.ts

@@ -8,6 +8,7 @@ import type {
   PendingMessage,
   AddMessageParams,
   ThreadInfo,
+  QueueScope,
 } from "@axiom-lattice/core";
 import { ensureTable, nowISO, parseISO } from "../database";
 import { randomUUID } from "crypto";
@@ -52,6 +53,7 @@ interface QueueRow {
 
 export class LocalThreadMessageQueueStore implements IMessageQueueStore {
   private db: DatabaseWrapper;
+  private capacityTail: Promise<void> = Promise.resolve();
 
   constructor(db: DatabaseWrapper) {
     this.db = db;
@@ -72,9 +74,9 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     ).run(
       id, 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,
@@ -83,6 +85,43 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
     return this.getById(id);
   }
 
+  async addMessageIfCapacity(params: AddMessageParams, maxSize: number): Promise<boolean> {
+    let release!: () => void;
+    const previous = this.capacityTail;
+    this.capacityTail = new Promise<void>((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 || 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: AddMessageParams): Promise<PendingMessage> {
     const now = nowISO();
     const id = params.id || randomUUID();
@@ -96,7 +135,7 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 100, ?, ?, ?)`,
     ).run(
       id, 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,
       params.command ? JSON.stringify(params.command) : null,
       params.custom_run_config ? JSON.stringify(params.custom_run_config) : null,
@@ -106,57 +145,70 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
     return this.getById(id);
   }
 
-  async getPendingMessages(threadId: string): Promise<PendingMessage[]> {
+  async getPendingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]> {
+    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) as unknown as QueueRow[];
+      `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) as unknown as QueueRow[];
     return rows.map(rowToMessage);
   }
 
-  async getProcessingMessages(threadId: string): Promise<PendingMessage[]> {
+  async getProcessingMessages(threadId: string, scope?: QueueScope): Promise<PendingMessage[]> {
+    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) as unknown as QueueRow[];
+      `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) as unknown as QueueRow[];
     return rows.map(rowToMessage);
   }
 
-  async getQueueSize(threadId: string): Promise<number> {
+  async getQueueSize(threadId: string, scope?: QueueScope): Promise<number> {
+    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) as { count: number };
+      `SELECT COUNT(*) as count FROM lt_thread_message_queue WHERE thread_id = ? AND status = 'pending'${filter.sql}`,
+    ).get(threadId, ...filter.params) as { count: number };
     return row.count;
   }
 
   async getThreadsWithPendingMessages(): Promise<ThreadInfo[]> {
     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() as { tenant_id: string; assistant_id: string; thread_id: string; workspace_id: string | null; project_id: string | null }[];
     return rows.map((r) => ({
       tenantId: r.tenant_id,
       assistantId: r.assistant_id,
       threadId: r.thread_id,
-      workspaceId: r.workspace_id || undefined,
-      projectId: r.project_id || undefined,
+      workspaceId: r.workspace_id,
+      projectId: r.project_id,
     }));
   }
 
-  async removeMessage(messageId: string): Promise<boolean> {
-    const result = this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE id = ?`).run(messageId);
+  async removeMessage(messageId: string, scope?: QueueScope): Promise<boolean> {
+    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: string): Promise<void> {
-    this.db.prepare(`DELETE FROM lt_thread_message_queue WHERE thread_id = ?`).run(threadId);
+  async clearMessages(threadId: string, scope?: QueueScope): Promise<void> {
+    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: string): Promise<void> {
-    this.db.prepare(`UPDATE lt_thread_message_queue SET status = 'processing' WHERE id = ?`).run(messageId);
+  async markProcessing(messageId: string, customRunConfig?: unknown, scope?: QueueScope): Promise<void> {
+    const filter = scopeClause(scope);
+    if (customRunConfig === undefined) {
+      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: string): Promise<number> {
+  async resetProcessingToPending(threadId: string, scope?: QueueScope): Promise<number> {
+    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;
   }
 
@@ -166,6 +218,16 @@ export class LocalThreadMessageQueueStore implements IMessageQueueStore {
   }
 }
 
+function scopeClause(scope?: QueueScope): { sql: string; params: unknown[] } {
+  if (!scope) return { sql: "", params: [] };
+  const entries = (["tenantId", "assistantId", "workspaceId", "projectId"] as const)
+    .map((key) => [key, scope[key]] as const);
+  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: QueueRow): PendingMessage {
   return {
     id: row.id,