@axiom-lattice/local-stores 2.0.9 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/local-stores",
-  "version": "2.0.9",
+  "version": "3.0.0",
   "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": "3.1.1",
-    "@axiom-lattice/protocols": "3.0.4"
+    "@axiom-lattice/core": "4.0.0",
+    "@axiom-lattice/protocols": "4.0.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/LocalA2AApiKeyStore.test.ts

@@ -0,0 +1,119 @@
+/**
+ * LocalA2AApiKeyStore behavior tests
+ *
+ * Verifies the SQLite store aligns with the new A2A key scope model:
+ * projectId required, assistantIds persisted (JSON), workspaceId removed.
+ */
+
+import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
+import { tmpdir } from "os";
+import path from "path";
+
+jest.mock("@axiom-lattice/core", () => ({
+  encrypt: (value: string) => `enc:${value}`,
+  decrypt: (value: string) => value.replace(/^enc:/, ""),
+}));
+
+import { initDatabase, closeDatabase, type DatabaseWrapper } from "../database";
+import { LocalA2AApiKeyStore } from "../stores/LocalA2AApiKeyStore";
+
+const nextDbPath = () =>
+  path.join(tmpdir(), `lt-a2a-key-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+
+describe("LocalA2AApiKeyStore", () => {
+  let store: LocalA2AApiKeyStore;
+  let db: DatabaseWrapper;
+
+  beforeEach(async () => {
+    db = await initDatabase({ dbPath: nextDbPath() });
+    store = new LocalA2AApiKeyStore(db);
+  });
+
+  it("finds a key by its management id", async () => {
+    const record = await store.create({ tenantId: "t1", projectId: "p1" });
+
+    await expect(store.findById(record.id)).resolves.toMatchObject({
+      id: record.id,
+      tenantId: "t1",
+    });
+    await expect(store.findById("missing")).resolves.toBeNull();
+  });
+
+  it("repairs and preserves a legacy row management id on initialization", async () => {
+    const now = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO lt_a2a_api_keys
+        (key_value, tenant_id, project_id, label, enabled, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ).run("enc:a2a_legacy", "t1", "p1", "legacy", 1, now, now);
+
+    store = new LocalA2AApiKeyStore(db);
+    const [legacy] = await store.list({ tenantId: "t1" });
+
+    expect(legacy.id).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    );
+    await expect(store.findById(legacy.id)).resolves.toMatchObject({ id: legacy.id });
+    await expect(store.disable(legacy.id)).resolves.toMatchObject({ enabled: false });
+
+    store = new LocalA2AApiKeyStore(db);
+    await expect(store.findById(legacy.id)).resolves.toMatchObject({
+      id: legacy.id,
+      enabled: false,
+    });
+  });
+
+  it("repairs empty and malformed management ids only once", async () => {
+    const now = new Date().toISOString();
+    const insert = db.prepare(
+      `INSERT INTO lt_a2a_api_keys
+        (id, key_value, tenant_id, project_id, label, enabled, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    );
+    insert.run("", "enc:a2a_empty", "t1", "p1", "empty", 1, now, now);
+    insert.run("legacy-row-id", "enc:a2a_invalid", "t1", "p1", "invalid", 1, now, now);
+
+    store = new LocalA2AApiKeyStore(db);
+    const repaired = await store.list({ tenantId: "t1" });
+    const ids = new Map(repaired.map((record) => [record.label, record.id]));
+
+    expect(ids.get("empty")).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    );
+    expect(ids.get("invalid")).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    );
+
+    store = new LocalA2AApiKeyStore(db);
+    const reloaded = await store.list({ tenantId: "t1" });
+    expect(new Map(reloaded.map((record) => [record.label, record.id]))).toEqual(ids);
+  });
+
+  afterEach(() => {
+    closeDatabase();
+  });
+
+  it("create persists projectId and assistantIds, no workspaceId", async () => {
+    const record = await store.create({
+      tenantId: "t1",
+      projectId: "p1",
+      assistantIds: ["a1", "a2"],
+      label: "l",
+    });
+
+    expect(record.projectId).toBe("p1");
+    expect(record.assistantIds).toEqual(["a1", "a2"]);
+    expect("workspaceId" in record).toBe(false);
+  });
+
+  it("loadIntoMap returns assistantIds and omits workspaceId", async () => {
+    await store.create({ tenantId: "t1", projectId: "p1", assistantIds: ["a1"] });
+
+    const map = await store.loadIntoMap();
+    expect(map.size).toBe(1);
+    const entry = [...map.values()][0];
+    expect(entry.projectId).toBe("p1");
+    expect(entry.assistantIds).toEqual(["a1"]);
+    expect("workspaceId" in entry).toBe(false);
+  });
+});

package/src/__tests__/LocalChannelInstallationStore.test.ts

@@ -0,0 +1,38 @@
+import { tmpdir } from "os";
+import path from "path";
+import { closeDatabase, initDatabase, type DatabaseWrapper } from "../database";
+import { LocalChannelInstallationStore } from "../stores/LocalChannelInstallationStore";
+
+const nextDbPath = (): string =>
+  path.join(tmpdir(), `lt-channel-installation-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+
+describe("LocalChannelInstallationStore", () => {
+  let db: DatabaseWrapper;
+  let store: LocalChannelInstallationStore;
+
+  beforeEach(async () => {
+    db = await initDatabase({ dbPath: nextDbPath() });
+    store = new LocalChannelInstallationStore(db);
+  });
+
+  afterEach(() => {
+    closeDatabase();
+  });
+
+  it("rejects a duplicate id without changing the original installation", async () => {
+    const original = await store.createInstallation("tenant-a", "install-1", {
+      channel: "lark",
+      name: "Original",
+      config: { appId: "app-1", appSecret: "secret-1" },
+    });
+
+    await expect(
+      store.createInstallation("tenant-a", "install-1", {
+        channel: "lark",
+        name: "Replacement",
+        config: { appId: "app-2", appSecret: "secret-2" },
+      }),
+    ).rejects.toThrow();
+    await expect(store.getInstallationById("install-1")).resolves.toEqual(original);
+  });
+});

package/src/__tests__/LocalProjectStore.test.ts

@@ -0,0 +1,127 @@
+/**
+ * LocalProjectStore project kind tests
+ *
+ * Projects support an optional `kind` ('business' | 'training' | 'personal').
+ * Omitted kind defaults to 'business' for backward compatibility, and
+ * getProjectsByWorkspace supports an optional kind filter.
+ */
+
+import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
+import { tmpdir } from "os";
+import path from "path";
+import { initDatabase, closeDatabase } from "../database";
+import { LocalProjectStore } from "../stores/LocalProjectStore";
+
+// sql.js persists to disk via DatabaseWrapper.save(), so each test needs a
+// unique file path (":memory:" is treated as a plain relative path).
+const nextDbPath = () =>
+  path.join(tmpdir(), `lt-project-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+
+describe("LocalProjectStore project kind", () => {
+  let store: LocalProjectStore;
+  const tenantId = "t1";
+  const workspaceId = "ws1";
+
+  beforeEach(async () => {
+    const db = await initDatabase({ dbPath: nextDbPath() });
+    store = new LocalProjectStore(db);
+  });
+
+  afterEach(() => {
+    closeDatabase();
+  });
+
+  it("defaults kind to 'business' when omitted on create", async () => {
+    const project = await store.createProject(tenantId, workspaceId, "p1", {
+      name: "Default Kind",
+    });
+    expect(project.kind).toBe("business");
+
+    const fetched = await store.getProjectById(tenantId, "p1");
+    expect(fetched?.kind).toBe("business");
+  });
+
+  it("round-trips an explicit kind through create and get", async () => {
+    const project = await store.createProject(tenantId, workspaceId, "p2", {
+      name: "Training Project",
+      kind: "training",
+    });
+    expect(project.kind).toBe("training");
+
+    const fetched = await store.getProjectById(tenantId, "p2");
+    expect(fetched?.kind).toBe("training");
+  });
+
+  it("updates kind via updateProject", async () => {
+    await store.createProject(tenantId, workspaceId, "p3", {
+      name: "Reclassified",
+    });
+
+    const updated = await store.updateProject(tenantId, "p3", { kind: "personal" });
+    expect(updated?.kind).toBe("personal");
+
+    const fetched = await store.getProjectById(tenantId, "p3");
+    expect(fetched?.kind).toBe("personal");
+  });
+
+  it("filters projects by kind in getProjectsByWorkspace", async () => {
+    await store.createProject(tenantId, workspaceId, "p4", { name: "Biz", kind: "business" });
+    await store.createProject(tenantId, workspaceId, "p5", { name: "Train", kind: "training" });
+    await store.createProject(tenantId, workspaceId, "p6", { name: "Personal", kind: "personal" });
+
+    const training = await store.getProjectsByWorkspace(tenantId, workspaceId, { kind: "training" });
+    expect(training.map((p) => p.id)).toEqual(["p5"]);
+  });
+
+  it("returns all projects when kind filter is omitted", async () => {
+    await store.createProject(tenantId, workspaceId, "p7", { name: "Biz", kind: "business" });
+    await store.createProject(tenantId, workspaceId, "p8", { name: "Train", kind: "training" });
+
+    const all = await store.getProjectsByWorkspace(tenantId, workspaceId);
+    expect(all).toHaveLength(2);
+  });
+
+  describe("multiple training projects per tenant/workspace", () => {
+    it("allows multiple training projects in the same tenant/workspace", async () => {
+      await store.createProject(tenantId, workspaceId, "t1", {
+        name: "Training",
+        kind: "training",
+      });
+      await store.createProject(tenantId, workspaceId, "t2", {
+        name: "Training 2",
+        kind: "training",
+      });
+
+      const training = await store.getProjectsByWorkspace(tenantId, workspaceId, {
+        kind: "training",
+      });
+      expect(training.map((p) => p.id).sort()).toEqual(["t1", "t2"]);
+    });
+
+    it("allows training projects with the same workspace in different tenants", async () => {
+      await store.createProject("tenant-a", workspaceId, "ta", {
+        name: "Training",
+        kind: "training",
+      });
+      await store.createProject("tenant-b", workspaceId, "tb", {
+        name: "Training",
+        kind: "training",
+      });
+
+      const a = await store.getProjectsByWorkspace("tenant-a", workspaceId, { kind: "training" });
+      const b = await store.getProjectsByWorkspace("tenant-b", workspaceId, { kind: "training" });
+      expect(a).toHaveLength(1);
+      expect(b).toHaveLength(1);
+    });
+
+    it("allows duplicate non-training kinds in the same tenant/workspace", async () => {
+      await store.createProject(tenantId, workspaceId, "b1", { name: "Biz 1", kind: "business" });
+      await store.createProject(tenantId, workspaceId, "b2", { name: "Biz 2", kind: "business" });
+      await store.createProject(tenantId, workspaceId, "p1", { name: "Per 1", kind: "personal" });
+      await store.createProject(tenantId, workspaceId, "p2", { name: "Per 2", kind: "personal" });
+
+      const all = await store.getProjectsByWorkspace(tenantId, workspaceId);
+      expect(all).toHaveLength(4);
+    });
+  });
+});

package/src/__tests__/LocalTaskStore.test.ts

@@ -11,8 +11,17 @@
 import { describe, expect, it, beforeEach, afterEach } from "@jest/globals";
 import { tmpdir } from "os";
 import path from "path";
-import { initDatabase, closeDatabase } from "../database";
+import { initDatabase, closeDatabase, type DatabaseWrapper } from "../database";
 import { LocalTaskStore } from "../stores/LocalTaskStore";
+import { LocalTaskWorkItemStore } from "../stores/LocalTaskWorkItemStore";
+import { A2ATaskStoreAdapter } from "../../../gateway/src/services/a2a/A2ATaskStoreAdapter";
+import { createTaskLifecycleService } from "../../../core/src/services/TaskLifecycleService";
+import type { A2ATask } from "@axiom-lattice/protocols";
+
+jest.mock("uuid", () => {
+  let id = 0;
+  return { v4: jest.fn(() => `test-id-${++id}`) };
+});
 
 // sql.js persists to disk via DatabaseWrapper.save(), so each test needs a
 // unique file path (":memory:" is treated as a plain relative path).
@@ -21,9 +30,10 @@ const nextDbPath = () =>
 
 describe("LocalTaskStore metadata filter", () => {
   let store: LocalTaskStore;
+  let db: DatabaseWrapper;
 
   beforeEach(async () => {
-    const db = await initDatabase({ dbPath: nextDbPath() });
+    db = await initDatabase({ dbPath: nextDbPath() });
     store = new LocalTaskStore(db);
   });
 
@@ -49,6 +59,54 @@ describe("LocalTaskStore metadata filter", () => {
     expect(byBoolean).toHaveLength(1);
   });
 
+  it("rejects mutation at the maximum canonical task timestamp", async () => {
+    const task = await store.create({
+      tenantId: "t1",
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Maximum",
+    });
+    db.prepare("UPDATE lt_tasks SET updated_at = ? WHERE tenant_id = ? AND id = ?")
+      .run("9999-12-31T23:59:59.999Z", "t1", task.id);
+
+    await expect(store.update("t1", task.id, { title: "Cannot advance" })).resolves.toBeNull();
+    expect((await store.getById("t1", task.id))?.title).toBe("Maximum");
+  });
+
+  it("treats context undefined as a no-op and null as an explicit clear", async () => {
+    const task = await store.create({
+      tenantId: "t1",
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Context semantics",
+      context: { retained: true },
+    });
+
+    const unchanged = await store.update("t1", task.id, { context: undefined });
+    const cleared = await store.update("t1", task.id, { context: null });
+
+    expect(unchanged?.context).toEqual({ retained: true });
+    expect(unchanged?.updatedAt.getTime()).toBe(task.updatedAt.getTime());
+    expect(cleared?.context).toBeUndefined();
+    expect(cleared!.updatedAt.getTime()).toBeGreaterThan(task.updatedAt.getTime());
+  });
+
+  it("repairs malformed legacy updated_at text during an ordinary update", async () => {
+    const task = await store.create({
+      tenantId: "t1",
+      ownerType: "user",
+      ownerId: "user-1",
+      title: "Malformed timestamp",
+    });
+    db.prepare("UPDATE lt_tasks SET updated_at = ? WHERE tenant_id = ? AND id = ?")
+      .run("2026-99-99T00:00:00.000Z", "t1", task.id);
+
+    const repaired = await store.update("t1", task.id, { title: "Repaired" });
+
+    expect(repaired?.title).toBe("Repaired");
+    expect(repaired?.updatedAt.toISOString()).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+  });
+
   it("still matches string metadata values", async () => {
     await store.create({
       tenantId: "t1",
@@ -81,4 +139,228 @@ describe("LocalTaskStore metadata filter", () => {
     const rows = await store.list({ tenantId: "t1", metadata: { archived: "false" } } as never);
     expect(rows).toHaveLength(1);
   });
+
+  it("honors a caller-provided task id", async () => {
+    const task = await store.create({
+      id: "a2a-task-1",
+      tenantId: "t1",
+      ownerType: "agent",
+      ownerId: "a1",
+      title: "A2A",
+    });
+
+    expect(task.id).toBe("a2a-task-1");
+    expect(await store.getById("t1", "a2a-task-1")).not.toBeNull();
+  });
+
+  it("conditionally updates through independent store instances", async () => {
+    const secondStore = new LocalTaskStore(db);
+    await store.create({
+      id: "task-canceled",
+      tenantId: "t1",
+      ownerType: "agent",
+      ownerId: "a1",
+      title: "Canceled",
+      status: "cancelled",
+    });
+
+    const result = await secondStore.updateIfStatusNotIn(
+      "t1",
+      "task-canceled",
+      { status: "completed" },
+      ["cancelled"],
+    );
+
+    expect(result).toBeNull();
+    expect((await store.getById("t1", "task-canceled"))?.status).toBe("cancelled");
+  });
+
+  it("atomically updates only from an expected status", async () => {
+    const secondStore = new LocalTaskStore(db);
+    await store.create({
+      id: "task-cas", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Working", status: "in_progress",
+    });
+
+    const first = await store.updateIfStatusIn(
+      "t1", "task-cas", { status: "completed", result: "first" }, ["in_progress"],
+    );
+    const second = await secondStore.updateIfStatusIn(
+      "t1", "task-cas", { status: "cancelled", result: "second" }, ["in_progress"],
+    );
+
+    expect(first?.status).toBe("completed");
+    expect(second).toBeNull();
+    expect((await store.getById("t1", "task-cas"))?.result).toBe("first");
+  });
+
+  it("returns null for an unexpected status and a missing task", async () => {
+    await store.create({
+      id: "task-pending", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Pending", status: "pending",
+    });
+
+    await expect(store.updateIfStatusIn(
+      "t1", "task-pending", { status: "completed" }, ["in_progress", "interrupted"],
+    )).resolves.toBeNull();
+    await expect(store.updateIfStatusIn(
+      "t1", "missing", { status: "completed" }, ["in_progress"],
+    )).resolves.toBeNull();
+  });
+
+  it("atomically compares status and the normalized updatedAt snapshot", async () => {
+    const secondStore = new LocalTaskStore(db);
+    const created = await store.create({
+      id: "task-snapshot", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Working", status: "in_progress",
+    });
+
+    const [first, second] = await Promise.all([
+      store.updateIfStatusAndUpdatedAt(
+        "t1", created.id, { context: { winner: "first" } }, ["in_progress"], created.updatedAt.toISOString(),
+      ),
+      secondStore.updateIfStatusAndUpdatedAt(
+        "t1", created.id, { context: { winner: "second" } }, ["in_progress"], created.updatedAt,
+      ),
+    ]);
+
+    expect(first?.context).toEqual({ winner: "first" });
+    expect(first!.updatedAt.getTime()).toBeGreaterThan(created.updatedAt.getTime());
+    expect(second).toBeNull();
+  });
+
+  it("rejects a stale snapshot after a same-status description update", async () => {
+    const created = await store.create({
+      id: "task-stale-snapshot", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Working", status: "in_progress",
+    });
+    await store.update("t1", created.id, { description: "changed" });
+
+    await expect(store.updateIfStatusAndUpdatedAt(
+      "t1", created.id, { status: "completed" }, ["in_progress"], created.updatedAt,
+    )).resolves.toBeNull();
+    expect((await store.getById("t1", created.id))?.status).toBe("in_progress");
+  });
+
+  it("atomically matches both child and parent snapshots", async () => {
+    const parent = await store.create({
+      id: "parent-snapshot", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Parent",
+    });
+    const child = await store.create({
+      id: "child-snapshot", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Child",
+      status: "in_progress", parentId: parent.id,
+    });
+
+    const updated = await store.updateIfStatusUpdatedAtAndParentUpdatedAt(
+      "t1", child.id, { status: "completed" }, ["in_progress"], child.updatedAt,
+      parent.id, parent.updatedAt,
+    );
+
+    expect(updated?.status).toBe("completed");
+  });
+
+  it("does not update a child when its parent snapshot changed or is missing", async () => {
+    const parent = await store.create({
+      id: "parent-stale", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Parent",
+    });
+    const staleChild = await store.create({
+      id: "child-stale-parent", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Child",
+      status: "in_progress", parentId: parent.id,
+    });
+    await store.update("t1", parent.id, { description: "reconciled" });
+
+    await expect(store.updateIfStatusUpdatedAtAndParentUpdatedAt(
+      "t1", staleChild.id, { status: "completed" }, ["in_progress"], staleChild.updatedAt,
+      parent.id, parent.updatedAt,
+    )).resolves.toBeNull();
+    expect((await store.getById("t1", staleChild.id))?.status).toBe("in_progress");
+
+    const missingChild = await store.create({
+      id: "child-missing-parent", tenantId: "t1", ownerType: "agent", ownerId: "a1", title: "Child",
+      status: "in_progress", parentId: parent.id,
+    });
+    const currentParent = await store.getById("t1", parent.id);
+    await store.delete("t1", parent.id);
+
+    await expect(store.updateIfStatusUpdatedAtAndParentUpdatedAt(
+      "t1", missingChild.id, { status: "completed" }, ["in_progress"], missingChild.updatedAt,
+      parent.id, currentParent!.updatedAt,
+    )).resolves.toBeNull();
+    expect((await store.getById("t1", missingChild.id))?.status).toBe("in_progress");
+  });
+
+  it("stores nullable lifecycle output clearing as SQL NULL", async () => {
+    const created = await store.create({
+      id: "task-clear-output", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Failed", status: "failed", result: "partial", failureReason: "boom",
+    });
+
+    const updated = await store.updateIfStatusAndUpdatedAt(
+      "t1",
+      created.id,
+      { result: null, failureReason: null },
+      ["failed"],
+      created.updatedAt,
+    );
+
+    expect(updated?.result).toBeUndefined();
+    expect(updated?.failureReason).toBeUndefined();
+    const row = db.prepare("SELECT result, failure_reason FROM lt_tasks WHERE tenant_id = ? AND id = ?")
+      .get("t1", created.id) as { result: string | null; failure_reason: string | null };
+    expect(row).toEqual({ result: null, failure_reason: null });
+  });
+
+  it("removes a completion audit marker when it is the only task context", async () => {
+    const workItemStore = new LocalTaskWorkItemStore(db);
+    const lifecycle = createTaskLifecycleService({ taskStore: store, workItemStore });
+    await store.create({
+      id: "task-clean-audit", tenantId: "t1", ownerType: "agent", ownerId: "a1",
+      title: "Complete", status: "in_progress",
+      description: [
+        "## Belief State", "", "| Belief Key | Probability | Target | Basis |",
+        "|---|---:|---:|---|", "| `done` | 50% | 90% | pending |",
+      ].join("\n"),
+    });
+
+    const completed = await lifecycle.completeAgentTask({
+      tenantId: "t1", taskId: "task-clean-audit", result: "done",
+      beliefImpact: [{ key: "done", after: 95, basis: "verified" }], actor: "agent:a1",
+    });
+
+    expect(completed.success).toBe(true);
+    expect((await store.getById("t1", "task-clean-audit"))?.context).toBeUndefined();
+  });
+
+  it("keeps one A2A id without externally resuming canonical interruption state", async () => {
+    const workItemStore = new LocalTaskWorkItemStore(db);
+    const lifecycle = createTaskLifecycleService({ taskStore: store, workItemStore });
+    const adapter = new A2ATaskStoreAdapter({
+      taskStore: store,
+      workItemStore,
+      lifecycle,
+      scope: { tenantId: "t1", projectId: "p1", assistantId: "a1" },
+    });
+    const task = (status: A2ATask["status"]): A2ATask => ({
+      id: "a2a-single-id",
+      contextId: "ctx-1",
+      kind: "task",
+      status,
+      history: [{
+        kind: "message",
+        messageId: "m1",
+        role: "user",
+        parts: [{ kind: "text", text: "start" }],
+      }],
+      metadata: { threadId: "thread-1" },
+    });
+
+    await adapter.save(task({ state: "working" }));
+    expect((await adapter.load("a2a-single-id"))?.id).toBe("a2a-single-id");
+    await adapter.save(task({ state: "input-required" }));
+    expect((await adapter.load("a2a-single-id"))?.status.state).toBe("input-required");
+    await adapter.save(task({ state: "working" }));
+
+    expect((await adapter.load("a2a-single-id"))?.status.state).toBe("input-required");
+    expect((await store.list({ tenantId: "t1" }))).toHaveLength(1);
+  });
 });