@axiom-lattice/pg-stores 2.0.10 → 3.0.1

package/src/__tests__/PostgreSQLTaskStore.integration.test.ts

@@ -0,0 +1,90 @@
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+import { PostgreSQLTaskStore } from "../stores/PostgreSQLTaskStore";
+
+const databaseUrl = process.env.TEST_DATABASE_URL;
+const describeIfDatabase = databaseUrl ? describe : describe.skip;
+const CANONICAL_UTC_MILLIS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+describeIfDatabase("PostgreSQLTaskStore timestamp contract", () => {
+  let pool: Pool;
+  let store: PostgreSQLTaskStore;
+  const tenantId = `timestamp-contract-${randomUUID()}`;
+
+  beforeAll(async () => {
+    pool = new Pool({ connectionString: databaseUrl });
+    store = new PostgreSQLTaskStore({ poolConfig: databaseUrl });
+    await store.initialize();
+  });
+
+  afterEach(async () => {
+    await pool.query("DELETE FROM lattice_tasks WHERE tenant_id = $1", [tenantId]);
+  });
+
+  afterAll(async () => {
+    await store.dispose();
+    await pool.end();
+  });
+
+  it("updates canonical VARCHAR timestamps monotonically as UTC ISO text", async () => {
+    const task = await store.create({
+      tenantId,
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Canonical timestamp",
+    });
+
+    const updated = await store.update(tenantId, task.id, { metadata: { trainingRound: true } });
+    const row = await pool.query<{ updated_at: string }>(
+      "SELECT updated_at FROM lattice_tasks WHERE tenant_id = $1 AND id = $2",
+      [tenantId, task.id],
+    );
+
+    expect(updated!.updatedAt.getTime()).toBeGreaterThan(task.updatedAt.getTime());
+    expect(row.rows[0].updated_at).toMatch(CANONICAL_UTC_MILLIS);
+  });
+
+  it("repairs shape-valid impossible and plainly malformed timestamps without cast errors", async () => {
+    const task = await store.create({
+      tenantId,
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Repair timestamp",
+    });
+
+    for (const malformed of ["2026-99-99T00:00:00.000Z", "not-a-date"]) {
+      await pool.query(
+        "UPDATE lattice_tasks SET updated_at = $1 WHERE tenant_id = $2 AND id = $3",
+        [malformed, tenantId, task.id],
+      );
+
+      await expect(store.update(tenantId, task.id, { metadata: { repaired: malformed } })).resolves.toBeTruthy();
+      const row = await pool.query<{ updated_at: string }>(
+        "SELECT updated_at FROM lattice_tasks WHERE tenant_id = $1 AND id = $2",
+        [tenantId, task.id],
+      );
+      expect(row.rows[0].updated_at).toMatch(CANONICAL_UTC_MILLIS);
+    }
+  });
+
+  it("makes snapshot CAS safely miss malformed stored timestamps", async () => {
+    const task = await store.create({
+      tenantId,
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Malformed snapshot",
+    });
+    await pool.query(
+      "UPDATE lattice_tasks SET updated_at = $1 WHERE tenant_id = $2 AND id = $3",
+      ["2026-02-31T00:00:00.000Z", tenantId, task.id],
+    );
+
+    await expect(store.updateIfStatusAndUpdatedAt(
+      tenantId,
+      task.id,
+      { description: "must not write" },
+      ["pending"],
+      task.updatedAt,
+    )).resolves.toBeNull();
+  });
+});

package/src/__tests__/PostgreSQLTaskStore.test.ts

@@ -0,0 +1,287 @@
+/**
+ * PostgreSQLTaskStore.create tests
+ *
+ * Verifies create() honors a caller-provided id (single-ID mapping
+ * with external systems such as A2A) and falls back to a generated
+ * UUID when omitted.
+ */
+
+import { describe, expect, it, jest, beforeEach } from "@jest/globals";
+import type { Pool } from "pg";
+
+const mockQuery = jest.fn();
+
+import { PostgreSQLTaskStore } from "../stores/PostgreSQLTaskStore";
+
+const fullRow = (id: string) => ({
+  id,
+  tenant_id: "t1",
+  owner_type: "agent",
+  owner_id: "owner-1",
+  title: "t",
+  description: null,
+  status: "pending",
+  priority: "medium",
+  due_date: null,
+  metadata: null,
+  parent_id: null,
+  source_id: null,
+  context: null,
+  require_review: null,
+  dependencies: null,
+  result: null,
+  failure_reason: null,
+  workspace_id: null,
+  project_id: null,
+  files: null,
+  created_at: "2026-01-01T00:00:00.000Z",
+  updated_at: "2026-01-01T00:00:00.000Z",
+});
+
+describe("PostgreSQLTaskStore.create", () => {
+  const pool = { query: mockQuery } as unknown as Pool;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("honors a caller-provided id", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery
+      .mockResolvedValueOnce({ rows: [] }) // INSERT
+      .mockResolvedValueOnce({ rows: [fullRow("a2a-task-1")] }); // getById
+
+    const result = await store.create({
+      id: "a2a-task-1",
+      tenantId: "t1",
+      ownerType: "agent",
+      ownerId: "owner-1",
+      title: "t",
+    });
+
+    expect(result.id).toBe("a2a-task-1");
+    const insertParams = mockQuery.mock.calls[0][1] as unknown[];
+    expect(insertParams[0]).toBe("a2a-task-1");
+  });
+
+  it("generates a uuid when id is omitted", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery
+      .mockResolvedValueOnce({ rows: [] }) // INSERT
+      .mockResolvedValueOnce({ rows: [fullRow("some-uuid")] }); // getById
+
+    await store.create({
+      tenantId: "t1",
+      ownerType: "agent",
+      ownerId: "owner-1",
+      title: "t",
+    });
+
+    const insertParams = mockQuery.mock.calls[0][1] as unknown[];
+    expect(insertParams[0]).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    );
+  });
+
+  it("uses one conditional UPDATE that blocks current statuses", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+
+    const result = await store.updateIfStatusNotIn(
+      "t1",
+      "task-1",
+      { status: "completed", result: "done" },
+      ["cancelled"],
+    );
+
+    expect(result?.id).toBe("task-1");
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const [sql, params] = mockQuery.mock.calls[0] as unknown as [string, unknown[]];
+    expect(sql).toContain("status <> ALL");
+    expect(sql).toContain("RETURNING *");
+    expect(params).toContainEqual(["cancelled"]);
+    expect(sql).toContain("updated_at::timestamptz + interval '1 millisecond'");
+  });
+
+  it("casts varchar updated_at before interval arithmetic on ordinary metadata updates", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery
+      .mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 })
+      .mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+
+    await store.update("t1", "task-1", { metadata: { trainingRound: true } });
+
+    const updateSql = mockQuery.mock.calls[1][0] as string;
+    expect(updateSql).toContain("updated_at::timestamptz + interval '1 millisecond'");
+    expect(updateSql).toContain("to_char");
+    expect(updateSql).toMatch(/CASE\s+WHEN updated_at ~/);
+    expect(updateSql).toContain("substring(updated_at FROM 6 FOR 2)::integer BETWEEN 1 AND 12");
+    expect(updateSql).toContain("substring(updated_at FROM 9 FOR 2)::integer BETWEEN 1 AND CASE");
+    expect(updateSql).toContain("updated_at <> '9999-12-31T23:59:59.999Z'");
+    expect(updateSql).not.toContain("updated_at + interval '1 millisecond'");
+    expect(updateSql).toContain("RETURNING *");
+  });
+
+  it("returns null when ordinary update cannot advance the maximum timestamp", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery
+      .mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 })
+      .mockResolvedValueOnce({ rows: [], rowCount: 0 });
+
+    await expect(store.update("t1", "task-1", { title: "Cannot advance" })).resolves.toBeNull();
+  });
+
+  it("treats context undefined as an ordinary update no-op", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+
+    const result = await store.update("t1", "task-1", { context: undefined });
+
+    expect(result?.id).toBe("task-1");
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns null when the conditional update is blocked", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 });
+
+    await expect(
+      store.updateIfStatusNotIn("t1", "task-1", { status: "completed" }, ["cancelled"]),
+    ).resolves.toBeNull();
+  });
+
+  it("uses one conditional UPDATE restricted to expected statuses", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+
+    await store.updateIfStatusIn(
+      "t1", "task-1", { status: "completed" }, ["in_progress", "interrupted"],
+    );
+
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const [sql, params] = mockQuery.mock.calls[0] as unknown as [string, unknown[]];
+    expect(sql).toContain("status = ANY");
+    expect(sql).toContain("RETURNING *");
+    expect(params).toContainEqual(["in_progress", "interrupted"]);
+    expect(sql).toContain("updated_at::timestamptz + interval '1 millisecond'");
+  });
+
+  it("returns null when no expected status matches or the task is missing", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValue({ rows: [], rowCount: 0 });
+
+    await expect(store.updateIfStatusIn(
+      "t1", "task-1", { status: "completed" }, ["in_progress"],
+    )).resolves.toBeNull();
+    await expect(store.updateIfStatusIn(
+      "t1", "missing", { status: "completed" }, ["in_progress"],
+    )).resolves.toBeNull();
+  });
+
+  it("uses one conditional UPDATE restricted to status and updatedAt snapshot", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+    const snapshot = new Date("2026-01-01T00:00:00.000Z");
+
+    const result = await store.updateIfStatusAndUpdatedAt(
+      "t1", "task-1", { status: "completed" }, ["in_progress"], snapshot,
+    );
+
+    expect(result?.id).toBe("task-1");
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const [sql, params] = mockQuery.mock.calls[0] as unknown as [string, unknown[]];
+    expect(sql).toContain("status = ANY");
+    expect(sql).toContain("updated_at =");
+    expect(sql).toContain("date_trunc('milliseconds'");
+    expect(sql).toContain("updated_at::timestamptz + interval '1 millisecond'");
+    expect(sql).toMatch(/CASE WHEN CASE\s+WHEN updated_at ~/);
+    expect(sql).toContain("THEN updated_at::timestamptz =");
+    expect(sql).toContain("ELSE FALSE");
+    expect(sql).toContain("RETURNING *");
+    expect(params).toContain(snapshot.toISOString());
+  });
+
+  it("returns null when the status matches but updatedAt snapshot is stale", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 });
+
+    await expect(store.updateIfStatusAndUpdatedAt(
+      "t1", "task-1", { description: "stale overwrite" }, ["in_progress"], "2026-01-01T00:00:00.000Z",
+    )).resolves.toBeNull();
+  });
+
+  it("lets only one caller update the same snapshot", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery
+      .mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 })
+      .mockResolvedValueOnce({ rows: [], rowCount: 0 });
+    const snapshot = "2026-01-01T00:00:00.000Z";
+
+    const [first, second] = await Promise.all([
+      store.updateIfStatusAndUpdatedAt("t1", "task-1", { description: "first" }, ["in_progress"], snapshot),
+      store.updateIfStatusAndUpdatedAt("t1", "task-1", { description: "second" }, ["in_progress"], snapshot),
+    ]);
+
+    expect(first?.id).toBe("task-1");
+    expect(second).toBeNull();
+  });
+
+  it("passes null lifecycle outputs through a snapshot update as SQL NULL", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("task-1")], rowCount: 1 });
+
+    await store.updateIfStatusAndUpdatedAt(
+      "t1",
+      "task-1",
+      { result: null, failureReason: null, context: null },
+      ["failed"],
+      "2026-01-01T00:00:00.000Z",
+    );
+
+    const [sql, params] = mockQuery.mock.calls[0] as unknown as [string, unknown[]];
+    expect(sql).toContain("result =");
+    expect(sql).toContain("failure_reason =");
+    expect(sql).toContain("context =");
+    expect(params.filter((value) => value === null)).toHaveLength(3);
+  });
+
+  it("uses one UPDATE with exact child and parent snapshot predicates", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [fullRow("child-1")], rowCount: 1 });
+    const childSnapshot = "2026-01-01T00:00:00.000Z";
+    const parentSnapshot = "2026-01-01T00:00:01.000Z";
+
+    const result = await store.updateIfStatusUpdatedAtAndParentUpdatedAt(
+      "t1", "child-1", { status: "completed" }, ["in_progress"], childSnapshot,
+      "parent-1", parentSnapshot,
+    );
+
+    expect(result?.id).toBe("child-1");
+    expect(mockQuery).toHaveBeenCalledTimes(1);
+    const [sql, params] = mockQuery.mock.calls[0] as unknown as [string, unknown[]];
+    expect(sql).toContain("UPDATE lattice_tasks AS child");
+    expect(sql).toContain("EXISTS");
+    expect(sql).toContain("parent.tenant_id = child.tenant_id");
+    expect(sql).toContain("parent.id =");
+    expect(sql).toContain("child.updated_at::timestamptz + interval '1 millisecond'");
+    expect(sql).toMatch(/CASE WHEN CASE\s+WHEN child\.updated_at ~/);
+    expect(sql).toContain("THEN child.updated_at::timestamptz =");
+    expect(sql).toMatch(/CASE WHEN CASE\s+WHEN parent\.updated_at ~/);
+    expect(sql).toContain("THEN parent.updated_at::timestamptz =");
+    expect(sql.match(/<> '9999-12-31T23:59:59\.999Z'/g)).toHaveLength(2);
+    expect(params).toEqual(expect.arrayContaining([
+      "t1", "child-1", ["in_progress"], childSnapshot, "parent-1", parentSnapshot,
+    ]));
+  });
+
+  it("returns null when the parent snapshot predicate does not match", async () => {
+    const store = new PostgreSQLTaskStore({ pool });
+    mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 0 });
+
+    await expect(store.updateIfStatusUpdatedAtAndParentUpdatedAt(
+      "t1", "child-1", { status: "completed" }, ["in_progress"], "2026-01-01T00:00:00.000Z",
+      "missing-parent", "2026-01-01T00:00:01.000Z",
+    )).resolves.toBeNull();
+  });
+
+});

package/src/__tests__/PostgreSQLTaskWorkItemStore.test.ts

@@ -0,0 +1,104 @@
+import type { Pool } from "pg";
+import { PostgreSQLTaskWorkItemStore } from "../stores/PostgreSQLTaskWorkItemStore";
+import { addTaskWorkItemEventKeyMigration } from "../migrations/task_work_items_migration";
+
+describe("PostgreSQLTaskWorkItemStore", () => {
+  const row = {
+    id: "item-1", tenant_id: "tenant-1", task_id: "task-1", event_key: "evidence:key",
+    action: "completion_evidence", actor: "agent:a", thread_id: null, summary: "first",
+    detail: null, attempt: null, workspace_id: null, project_id: null,
+    created_at: "2026-01-01T00:00:00.000Z",
+  };
+
+  it.each([
+    [undefined, "ASC"],
+    ["asc", "ASC"],
+    ["desc", "DESC"],
+  ] as const)("uses %s order as %s with deterministic IDs", async (order, sqlOrder) => {
+    const query = jest.fn().mockResolvedValue({ rows: [] });
+    const store = new PostgreSQLTaskWorkItemStore({ query } as unknown as Pool);
+
+    await store.list({
+      tenantId: "tenant-1",
+      taskId: "task-1",
+      limit: 100,
+      ...(order && { order }),
+    });
+
+    expect(query).toHaveBeenCalledWith(
+      expect.stringContaining(`ORDER BY created_at ${sqlOrder}, id ${sqlOrder} LIMIT $3`),
+      ["tenant-1", "task-1", 100],
+    );
+  });
+
+  it("filters by workspaceId and projectId", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [] });
+    const store = new PostgreSQLTaskWorkItemStore({ query } as unknown as Pool);
+
+    await store.list({
+      tenantId: "tenant-1",
+      taskId: "task-1",
+      workspaceId: "workspace-1",
+      projectId: "project-1",
+      order: "desc",
+      limit: 100,
+    });
+
+    expect(query).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "workspace_id = $3 AND project_id = $4 ORDER BY created_at DESC, id DESC LIMIT $5",
+      ),
+      ["tenant-1", "task-1", "workspace-1", "project-1", 100],
+    );
+  });
+
+  it("looks up an event key by tenant and task", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [row] });
+    const store = new PostgreSQLTaskWorkItemStore({ query } as unknown as Pool);
+
+    const result = await store.findByEventKey("tenant-1", "task-1", "evidence:key");
+
+    expect(query).toHaveBeenCalledWith(
+      expect.stringContaining("tenant_id = $1 AND task_id = $2 AND event_key = $3"),
+      ["tenant-1", "task-1", "evidence:key"],
+    );
+    expect(result?.eventKey).toBe("evidence:key");
+  });
+
+  it("maps a null event key to undefined", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [{ ...row, event_key: null }] });
+    const store = new PostgreSQLTaskWorkItemStore({ query } as unknown as Pool);
+
+    const result = await store.list({ tenantId: "tenant-1", taskId: "task-1" });
+
+    expect(result[0].eventKey).toBeUndefined();
+  });
+
+  it("atomically inserts by task-scoped event key or returns the existing row", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [row] });
+    const store = new PostgreSQLTaskWorkItemStore({ query } as unknown as Pool);
+
+    const result = await store.createIfAbsentByEventKey({
+      tenantId: "tenant-1", taskId: "task-1", eventKey: "evidence:key",
+      action: "completion_evidence", actor: "agent:a", summary: "first",
+    });
+
+    expect(query).toHaveBeenCalledTimes(1);
+    expect(query).toHaveBeenCalledWith(
+      expect.stringMatching(/INSERT[\s\S]+ON CONFLICT \(tenant_id, task_id, event_key\)[\s\S]+RETURNING/),
+      expect.arrayContaining(["tenant-1", "task-1", "evidence:key"]),
+    );
+    expect(result.eventKey).toBe("evidence:key");
+  });
+
+  it("migrates a task-scoped unique event key", async () => {
+    const query = jest.fn().mockResolvedValue({ rows: [] });
+
+    await addTaskWorkItemEventKeyMigration.up({ query } as never);
+
+    expect(query).toHaveBeenCalledWith(expect.stringContaining("ADD COLUMN IF NOT EXISTS event_key TEXT"));
+    expect(query).toHaveBeenCalledWith(expect.stringContaining(
+      "(tenant_id, task_id, event_key) WHERE event_key IS NOT NULL",
+    ));
+  });
+});

package/src/__tests__/add_a2a_key_assistant_ids.test.ts

@@ -0,0 +1,34 @@
+/**
+ * add_a2a_key_assistant_ids migration tests
+ *
+ * Verifies the migration adds (and removes) the assistant_ids JSONB
+ * column on lattice_a2a_api_keys.
+ */
+
+import { describe, expect, it, jest } from "@jest/globals";
+import type { PoolClient } from "pg";
+import { addA2AKeyAssistantIds } from "../migrations/add_a2a_key_assistant_ids";
+
+describe("add_a2a_key_assistant_ids migration", () => {
+  it("has name add_a2a_key_assistant_ids", () => {
+    expect(addA2AKeyAssistantIds.name).toBe("add_a2a_key_assistant_ids");
+  });
+
+  it("has a version greater than the current max (166)", () => {
+    expect(addA2AKeyAssistantIds.version).toBe(167);
+  });
+
+  it("emits ADD COLUMN assistant_ids JSONB in up()", async () => {
+    const queries: string[] = [];
+    const client = { query: jest.fn(async (sql: string) => { queries.push(sql); }) };
+    await addA2AKeyAssistantIds.up(client as unknown as PoolClient);
+    expect(queries.some((q) => q.includes("ADD COLUMN IF NOT EXISTS assistant_ids JSONB"))).toBe(true);
+  });
+
+  it("emits DROP COLUMN assistant_ids in down()", async () => {
+    const queries: string[] = [];
+    const client = { query: jest.fn(async (sql: string) => { queries.push(sql); }) };
+    await addA2AKeyAssistantIds.down?.(client as unknown as PoolClient);
+    expect(queries.some((q) => q.includes("DROP COLUMN IF EXISTS assistant_ids"))).toBe(true);
+  });
+});

package/src/__tests__/workspace-project-store.test.ts

@@ -232,4 +232,52 @@ describeIfDb("PostgreSQLProjectStore", () => {
     const deleted = await store.deleteProject(tenantId, "non-existent");
     expect(deleted).toBe(false);
   });
+
+  test("should default kind to 'business' when omitted on create", async () => {
+    const project = await store.createProject(tenantId, workspaceId, "test-proj-kind-1", {
+      name: "Default Kind",
+    });
+    expect(project.kind).toBe("business");
+
+    const fetched = await store.getProjectById(tenantId, "test-proj-kind-1");
+    expect(fetched?.kind).toBe("business");
+  });
+
+  test("should round-trip an explicit kind through create and get", async () => {
+    const project = await store.createProject(tenantId, workspaceId, "test-proj-kind-2", {
+      name: "Training Project",
+      kind: "training",
+    });
+    expect(project.kind).toBe("training");
+
+    const fetched = await store.getProjectById(tenantId, "test-proj-kind-2");
+    expect(fetched?.kind).toBe("training");
+  });
+
+  test("should update kind", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-kind-3", {
+      name: "Reclassified",
+    });
+
+    const updated = await store.updateProject(tenantId, "test-proj-kind-3", { kind: "personal" });
+    expect(updated?.kind).toBe("personal");
+  });
+
+  test("should filter projects by kind", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-kind-4", { name: "Biz", kind: "business" });
+    await store.createProject(tenantId, workspaceId, "test-proj-kind-5", { name: "Train", kind: "training" });
+
+    const training = await store.getProjectsByWorkspace(tenantId, workspaceId, { kind: "training" });
+    const ids = training.filter((p) => p.id.startsWith("test-proj-kind-")).map((p) => p.id);
+    expect(ids).toEqual(["test-proj-kind-5"]);
+  });
+
+  test("should return all projects when kind filter is omitted", async () => {
+    await store.createProject(tenantId, workspaceId, "test-proj-kind-6", { name: "Biz", kind: "business" });
+    await store.createProject(tenantId, workspaceId, "test-proj-kind-7", { name: "Train", kind: "training" });
+
+    const all = await store.getProjectsByWorkspace(tenantId, workspaceId);
+    const ids = all.filter((p) => p.id.startsWith("test-proj-kind-")).map((p) => p.id);
+    expect(ids).toHaveLength(2);
+  });
 });

package/src/createPgStoreConfig.ts

@@ -17,6 +17,7 @@ import { ThreadMessageQueueStore } from "./stores/ThreadMessageQueueStore";
 import { ChannelBindingStore } from "./stores/ChannelBindingStore";
 import { PostgreSQLChannelInstallationStore } from "./stores/PostgreSQLChannelInstallationStore";
 import { PostgreSQLA2AApiKeyStore } from "./stores/PostgreSQLA2AApiKeyStore";
+import { PostgreSQLAgentWebAppStore } from "./stores/PostgreSQLAgentWebAppStore";
 import { PostgreSQLScheduleStorage } from "./stores/PostgreSQLScheduleStorage";
 import { PostgreSQLTaskStore } from "./stores/PostgreSQLTaskStore";
 import { PostgreSQLTaskWorkItemStore } from "./stores/PostgreSQLTaskWorkItemStore";
@@ -43,6 +44,7 @@ import { changeSkillPrimaryKey } from "./migrations/skill_pk_migration";
 import { createWorkspacesTable } from "./migrations/workspace_migrations";
 import { createProjectsTable } from "./migrations/project_migrations";
 import { addProjectConfigColumn } from "./migrations/add_project_config_column";
+import { addProjectKindColumn } from "./migrations/add_project_kind_column";
 import { createUsersTable } from "./migrations/user_migrations";
 import { addUserStatusColumn } from "./migrations/user_status_migration";
 import { createTenantsTable } from "./migrations/tenant_migrations";
@@ -63,12 +65,14 @@ import { addWorkspaceProjectToQueue } from "./migrations/add_workspace_project_t
 import { createWorkflowTrackingTables, addStepThreadId, addWorkflowRunsTenantStatusUpdatedIndex } from "./migrations/workflow_tracking_migrations";
 import { evalMigrations } from "./migrations/eval_migrations";
 import { createA2AApiKeysTable } from "./migrations/a2a_api_key_migration";
+import { addA2AKeyAssistantIds } from "./migrations/add_a2a_key_assistant_ids";
 import { taskMigrations } from "./migrations/task_migration";
 import { createMenuItemsTable } from "./migrations/menu_items_migration";
 import { addFileContentType } from "./migrations/menu_items_add_file_type";
 import { createSharedResourcesTable } from "./migrations/shared_resources_migration";
 import { createCollectionsTable } from "./migrations/collection_migrations";
-import { createTaskWorkItemsMigration, addWorkItemProjectFieldsMigration } from "./migrations/task_work_items_migration";
+import { createTaskWorkItemsMigration, addWorkItemProjectFieldsMigration, addTaskWorkItemEventKeyMigration } from "./migrations/task_work_items_migration";
+import { createAgentWebAppsTable } from "./migrations/agent_web_apps_migration";
 
 export async function createPgStoreConfig(connectionString: string) {
   const pool = new Pool({ connectionString });
@@ -126,6 +130,10 @@ export async function createPgStoreConfig(connectionString: string) {
   mm.register(addWorkItemProjectFieldsMigration); // v140
   mm.register(createConnectionConfigsTable);      // v160
   mm.register(addWorkflowRunsTenantStatusUpdatedIndex); // v161
+  mm.register(addProjectKindColumn);          // v165
+  mm.register(addA2AKeyAssistantIds);         // v167
+  mm.register(addTaskWorkItemEventKeyMigration); // v168
+  mm.register(createAgentWebAppsTable);        // v169
 
   await mm.migrate();
 
@@ -158,6 +166,7 @@ export async function createPgStoreConfig(connectionString: string) {
     task: new PostgreSQLTaskStore(opts),
     taskWorkItem: taskWorkItemStore,
     a2aApiKey: new PostgreSQLA2AApiKeyStore(opts),
+    agentWebApp: new PostgreSQLAgentWebAppStore(opts),
     schedule: new PostgreSQLScheduleStorage(opts),
     menu: new MenuStore(opts),
     sharedResource: new PostgresSharedResourceStore(opts),

package/src/index.ts

@@ -50,12 +50,14 @@ export * from "./migrations/channel_installations_alter_migration";
 export * from "./migrations/channel_bindings_migration";
 export * from "./migrations/shared_resources_migration";
 export * from "./migrations/a2a_api_key_migration";
+export * from "./migrations/agent_web_apps_migration";
 export * from "./migrations/workflow_tracking_migrations";
 export * from "./stores/ChannelBindingStore";
 export * from "./stores/ThreadMessageQueueStore";
 export * from "./stores/ChannelIdentityMappingStore";
 export * from "./stores/PostgreSQLChannelInstallationStore";
 export * from "./stores/PostgreSQLA2AApiKeyStore";
+export * from "./stores/PostgreSQLAgentWebAppStore";
 export * from "./stores/PostgreSQLWorkflowTrackingStore";
 export * from "./stores/PostgreSQLEvalStore";
 export * from "./migrations/eval_migrations";
@@ -181,4 +183,12 @@ export type {
   ShareVisibility,
   CreateShareRequest,
   ShareResult,
+  AgentWebAppStore,
+  AgentWebApp,
+  AgentWebAppStatus,
+  AgentWebAppScope,
+  AgentWebAppFeatures,
+  AgentWebAppAppearance,
+  CreateAgentWebAppInput,
+  UpdateAgentWebAppInput,
 } from "@axiom-lattice/protocols";

package/src/migrations/add_a2a_key_assistant_ids.ts

@@ -0,0 +1,24 @@
+import type { Migration } from "./migration";
+import type { PoolClient } from "pg";
+
+/**
+ * Adds the assistant_ids JSONB whitelist column to A2A API keys.
+ *
+ * Empty/undefined assistant_ids means all exposed agents in the tenant.
+ */
+export const addA2AKeyAssistantIds: Migration = {
+  version: 167,
+  name: "add_a2a_key_assistant_ids",
+  up: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_a2a_api_keys
+        ADD COLUMN IF NOT EXISTS assistant_ids JSONB
+    `);
+  },
+  down: async (client: PoolClient) => {
+    await client.query(`
+      ALTER TABLE lattice_a2a_api_keys
+        DROP COLUMN IF EXISTS assistant_ids
+    `);
+  },
+};