@axiom-lattice/local-stores 1.0.21 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/local-stores",
-  "version": "1.0.21",
+  "version": "1.0.24",
   "description": "Local SQLite-based stores for Axiom Lattice framework",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,8 +25,8 @@
     "@types/sql.js": "^1.4.11",
     "sql.js": "^1.14.1",
     "uuid": "^14.0.1",
-    "@axiom-lattice/core": "2.1.99",
-    "@axiom-lattice/protocols": "2.1.51"
+    "@axiom-lattice/core": "2.1.102",
+    "@axiom-lattice/protocols": "2.1.53"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

package/src/createLocalStoreConfig.ts

@@ -36,6 +36,7 @@ import { LocalThreadMessageQueueStore } from "./stores/LocalThreadMessageQueueSt
 import { LocalSkillStore } from "./stores/LocalSkillStore";
 import { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
 import { LocalTaskStore } from "./stores/LocalTaskStore";
+import { LocalTaskWorkItemStore } from "./stores/LocalTaskWorkItemStore";
 
 export interface LocalStoreConfigOptions {
   /**
@@ -80,6 +81,7 @@ export async function createLocalStoreConfig(options: LocalStoreConfigOptions =
     skill: new LocalSkillStore(db),
     schedule: new LocalScheduleStorage(db),
     task: new LocalTaskStore(db),
+    taskWorkItem: new LocalTaskWorkItemStore(db),
     checkpoint: SqliteSaver.fromConnString(dbPath),
   };
 }

package/src/index.ts

@@ -47,3 +47,4 @@ export { LocalThreadMessageQueueStore } from "./stores/LocalThreadMessageQueueSt
 export { LocalSkillStore } from "./stores/LocalSkillStore";
 export { LocalScheduleStorage } from "./stores/LocalScheduleStorage";
 export { LocalTaskStore } from "./stores/LocalTaskStore";
+export { LocalTaskWorkItemStore } from "./stores/LocalTaskWorkItemStore";

package/src/stores/LocalConnectionStore.ts

@@ -42,6 +42,13 @@ export class LocalConnectionStore implements ConnectionStore {
     ensureTable(db, DDL);
   }
 
+  async listByTenant(tenantId: string): Promise<ConnectionEntry[]> {
+    const rows = this.db.prepare(
+      `SELECT * FROM connection_configs WHERE tenant_id = ? ORDER BY created_at`,
+    ).all(tenantId) as unknown as ConnectionRow[];
+    return rows.map((r) => this.mapRow(r));
+  }
+
   async listByType(tenantId: string, type: string): Promise<ConnectionEntry[]> {
     const rows = this.db.prepare(
       `SELECT * FROM connection_configs WHERE tenant_id = ? AND type = ? ORDER BY created_at`,

package/src/stores/LocalEvalStore.ts

@@ -404,6 +404,14 @@ export class LocalEvalStore implements EvalStore {
     return this.getRunResultById(tenantId, id);
   }
 
+  async deleteRunResult(tenantId: string, id: string): Promise<boolean> {
+    const result = this.db.prepare(
+      `DELETE FROM lt_eval_run_results
+       WHERE id = ? AND run_id IN (SELECT id FROM lt_eval_runs WHERE tenant_id = ?)`,
+    ).run(id, tenantId);
+    return result.changes > 0;
+  }
+
   // -------------------------------------------------------------------------
   // Reports
   // -------------------------------------------------------------------------

package/src/stores/LocalTaskStore.ts

@@ -28,6 +28,12 @@ CREATE TABLE IF NOT EXISTS lt_tasks (
   parent_id TEXT,
   source_id TEXT,
   context TEXT,
+  require_review INTEGER DEFAULT 0,
+  dependencies TEXT,
+  result TEXT,
+  failure_reason TEXT,
+  workspace_id TEXT,
+  project_id TEXT,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL,
   PRIMARY KEY (tenant_id, id)
@@ -48,6 +54,12 @@ interface TaskRow {
   parent_id: string | null;
   source_id: string | null;
   context: string | null;
+  require_review: number | null;
+  dependencies: string | null;
+  result: string | null;
+  failure_reason: string | null;
+  workspace_id: string | null;
+  project_id: string | null;
   created_at: string;
   updated_at: string;
 }
@@ -67,6 +79,12 @@ function mapRowToTask(row: TaskRow): TaskItem {
     parentId: row.parent_id ?? undefined,
     sourceId: row.source_id ?? undefined,
     context: row.context ? JSON.parse(row.context) : undefined,
+    requireReview: row.require_review === 1 ? true : (row.require_review ? true : undefined),
+    dependencies: row.dependencies ? JSON.parse(row.dependencies) : undefined,
+    result: row.result || undefined,
+    failureReason: row.failure_reason || undefined,
+    workspaceId: row.workspace_id ?? undefined,
+    projectId: row.project_id ?? undefined,
     createdAt: parseISO(row.created_at),
     updatedAt: parseISO(row.updated_at),
   };
@@ -78,6 +96,12 @@ export class LocalTaskStore implements TaskStore {
   constructor(db: DatabaseWrapper) {
     this.db = db;
     ensureTable(db, DDL);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN require_review INTEGER DEFAULT 0;`);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN dependencies TEXT;`);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN result TEXT;`);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN failure_reason TEXT;`);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN workspace_id TEXT;`);
+    this.db.exec(`ALTER TABLE lt_tasks ADD COLUMN project_id TEXT;`);
   }
 
   async create(
@@ -87,14 +111,19 @@ export class LocalTaskStore implements TaskStore {
     const now = nowISO();
 
     this.db.prepare(
-      `INSERT INTO lt_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT INTO lt_tasks (id, tenant_id, owner_type, owner_id, title, description, status, priority, due_date, metadata, parent_id, source_id, context, require_review, dependencies, result, failure_reason, workspace_id, project_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     ).run(
       id, params.tenantId, params.ownerType, params.ownerId, params.title,
       params.description || null, params.status || 'pending', params.priority || 'medium',
       params.dueDate || null, params.metadata ? JSON.stringify(params.metadata) : null,
       params.parentId || null, params.sourceId || null,
-      params.context ? JSON.stringify(params.context) : null, now, now,
+      params.context ? JSON.stringify(params.context) : null,
+      params.requireReview ? 1 : 0,
+      params.dependencies ? JSON.stringify(params.dependencies) : null,
+      params.result || null, params.failureReason || null,
+      params.workspaceId || null, params.projectId || null,
+      now, now,
     );
 
     return (await this.getById(params.tenantId, id))!;
@@ -113,8 +142,15 @@ export class LocalTaskStore implements TaskStore {
 
     if (filter.ownerType) { conditions.push('owner_type = ?'); params.push(filter.ownerType); }
     if (filter.ownerId) { conditions.push('owner_id = ?'); params.push(filter.ownerId); }
-    if (filter.status) { conditions.push('status = ?'); params.push(filter.status); }
+    if (filter.status) {
+      const statuses = filter.status.split(',').map(s => s.trim()).filter(Boolean);
+      const placeholders = statuses.map(() => '?').join(', ');
+      conditions.push(`status IN (${placeholders})`);
+      params.push(...statuses);
+    }
     if (filter.priority) { conditions.push('priority = ?'); params.push(filter.priority); }
+    if (filter.workspaceId) { conditions.push('workspace_id = ?'); params.push(filter.workspaceId); }
+    if (filter.projectId) { conditions.push('project_id = ?'); params.push(filter.projectId); }
     if (filter.parentId) { conditions.push('parent_id = ?'); params.push(filter.parentId); }
     if (filter.sourceId) { conditions.push('source_id = ?'); params.push(filter.sourceId); }
     if (filter.metadata) {
@@ -160,6 +196,12 @@ export class LocalTaskStore implements TaskStore {
     if (updates.context !== undefined) { setClauses.push('context = ?'); values.push(JSON.stringify(updates.context)); }
     if (updates.ownerType !== undefined) { setClauses.push('owner_type = ?'); values.push(updates.ownerType); }
     if (updates.ownerId !== undefined) { setClauses.push('owner_id = ?'); values.push(updates.ownerId); }
+    if (updates.requireReview !== undefined) { setClauses.push('require_review = ?'); values.push(updates.requireReview ? 1 : 0); }
+    if (updates.dependencies !== undefined) { setClauses.push('dependencies = ?'); values.push(JSON.stringify(updates.dependencies)); }
+    if (updates.result !== undefined) { setClauses.push('result = ?'); values.push(updates.result); }
+    if (updates.failureReason !== undefined) { setClauses.push('failure_reason = ?'); values.push(updates.failureReason); }
+    if (updates.workspaceId !== undefined) { setClauses.push('workspace_id = ?'); values.push(updates.workspaceId); }
+    if (updates.projectId !== undefined) { setClauses.push('project_id = ?'); values.push(updates.projectId); }
 
     if (setClauses.length === 1) return existing;
 

package/src/stores/LocalTaskWorkItemStore.ts

@@ -0,0 +1,113 @@
+/**
+ * Local SQLite implementation of TaskWorkItemStore.
+ */
+
+import { DatabaseWrapper } from "../database";
+import type {
+  TaskWorkItemStore,
+  TaskWorkItem,
+  CreateWorkItemRequest,
+  TaskWorkItemListFilter,
+} from "@axiom-lattice/protocols";
+import { ensureTable, nowISO, parseISO } from "../database";
+import { v4 as uuid } from "uuid";
+
+const DDL = `
+CREATE TABLE IF NOT EXISTS lt_task_work_items (
+  id TEXT NOT NULL,
+  tenant_id TEXT NOT NULL,
+  task_id TEXT NOT NULL,
+  action TEXT NOT NULL,
+  actor TEXT NOT NULL,
+  thread_id TEXT,
+  summary TEXT,
+  detail TEXT,
+  attempt INTEGER,
+  workspace_id TEXT,
+  project_id TEXT,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY (tenant_id, id)
+);
+`;
+
+interface WorkItemRow {
+  id: string;
+  tenant_id: string;
+  task_id: string;
+  action: string;
+  actor: string;
+  thread_id: string | null;
+  summary: string | null;
+  detail: string | null;
+  attempt: number | null;
+  workspace_id: string | null;
+  project_id: string | null;
+  created_at: string;
+}
+
+function mapRowToWorkItem(row: WorkItemRow): TaskWorkItem {
+  return {
+    id: row.id,
+    tenantId: row.tenant_id,
+    taskId: row.task_id,
+    action: row.action,
+    actor: row.actor,
+    threadId: row.thread_id ?? undefined,
+    summary: row.summary ?? undefined,
+    detail: row.detail ? JSON.parse(row.detail) : undefined,
+    attempt: row.attempt ?? undefined,
+    workspaceId: row.workspace_id ?? undefined,
+    projectId: row.project_id ?? undefined,
+    createdAt: parseISO(row.created_at),
+  };
+}
+
+export class LocalTaskWorkItemStore implements TaskWorkItemStore {
+  private db: DatabaseWrapper;
+
+  constructor(db: DatabaseWrapper) {
+    this.db = db;
+    ensureTable(db, DDL);
+    this.db.exec(`ALTER TABLE lt_task_work_items ADD COLUMN workspace_id TEXT;`);
+    this.db.exec(`ALTER TABLE lt_task_work_items ADD COLUMN project_id TEXT;`);
+  }
+
+  async create(params: CreateWorkItemRequest): Promise<TaskWorkItem> {
+    const id = uuid();
+    const now = nowISO();
+
+    this.db.prepare(
+      `INSERT INTO lt_task_work_items (id, tenant_id, task_id, action, actor, thread_id, summary, detail, attempt, workspace_id, project_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      id, params.tenantId, params.taskId, params.action, params.actor,
+      params.threadId || null, params.summary || null,
+      params.detail ? JSON.stringify(params.detail) : null,
+      params.attempt ?? null,
+      params.workspaceId || null,
+      params.projectId || null,
+      now,
+    );
+
+    const row = this.db.prepare(
+      `SELECT * FROM lt_task_work_items WHERE tenant_id = ? AND id = ?`,
+    ).get(params.tenantId, id) as unknown as WorkItemRow | undefined;
+    return mapRowToWorkItem(row!);
+  }
+
+  async list(filter: TaskWorkItemListFilter): Promise<TaskWorkItem[]> {
+    const conditions: string[] = ['tenant_id = ?', 'task_id = ?'];
+    const params: unknown[] = [filter.tenantId, filter.taskId];
+
+    if (filter.action) { conditions.push('action = ?'); params.push(filter.action); }
+
+    const where = conditions.join(' AND ');
+    const limit = filter.limit || 100;
+    const offset = filter.offset || 0;
+
+    const rows = this.db.prepare(
+      `SELECT * FROM lt_task_work_items WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+    ).all(...params, limit, offset) as unknown as WorkItemRow[];
+    return rows.map(mapRowToWorkItem);
+  }
+}