@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/chat-sdk-shutdown.test.ts

@@ -0,0 +1,220 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  startTelegramBotApiMock,
+  type TelegramBotApiMock,
+} from "../../scripts/dev/telegram-bot-api-mock";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getPendingChatRelayTasks,
+  initDb,
+} from "../be/db";
+import {
+  getChatInstance,
+  getChatSdkHealth,
+  isChatSdkStopping,
+  startChatSdk,
+  stopChatSdk,
+} from "../integrations/chat-sdk/runtime";
+import { chatSdkContextKey } from "../tasks/context-key";
+import type { Agent } from "../types";
+import {
+  postTelegramUpdate,
+  snapshotChatSdkEnv,
+  TELEGRAM_SECRET,
+  telegramUpdate,
+} from "./chat-sdk-harness";
+
+const TEST_DB_PATH = join(tmpdir(), `test-chat-sdk-shutdown-${crypto.randomUUID()}.sqlite`);
+const SEND_METHODS = /\/(sendMessage|sendRichMessage)$/;
+
+type ObligationRow = {
+  delivered_at: string | null;
+  attempt_count: number;
+  given_up_at: string | null;
+  last_error: string | null;
+};
+
+let lead: Agent;
+let mock: TelegramBotApiMock;
+let proxy: ReturnType<typeof Bun.serve>;
+/** While true, the proxy holds every send until `releaseHeld` answers it. */
+let holdSends = false;
+const held: Array<() => void> = [];
+let restoreEnv: () => void;
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+  }
+}
+
+function releaseHeld(): void {
+  for (const release of held.splice(0)) release();
+}
+
+async function waitFor(check: () => boolean | Promise<boolean>, what: string): Promise<void> {
+  const deadline = Date.now() + 10_000;
+  while (!(await check())) {
+    if (Date.now() > deadline) throw new Error(`timed out waiting for ${what}`);
+    await Bun.sleep(20);
+  }
+}
+
+async function obligation(taskId: string): Promise<ObligationRow | null> {
+  return getDbClient().get<ObligationRow>(
+    "SELECT delivered_at, attempt_count, given_up_at, last_error FROM chat_relay_obligations WHERE task_id = ?",
+    [taskId],
+  );
+}
+
+async function startChannel(): Promise<void> {
+  process.env.CHAT_SDK_ENABLED = "true";
+  process.env.CHAT_SDK_ADAPTERS = JSON.stringify({
+    telegram: { botToken: "t", secretToken: TELEGRAM_SECRET, mode: "webhook" },
+  });
+  process.env.CHAT_SDK_API_URL_OVERRIDES = JSON.stringify({
+    telegram: `http://127.0.0.1:${proxy.port}`,
+  });
+  process.env.CHAT_SDK_BUFFER_MS = "60000";
+  await startChatSdk();
+  expect(getChatInstance("telegram")).toBeDefined();
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  lead = await createAgent({
+    id: crypto.randomUUID(),
+    name: "ChatShutdownLead",
+    isLead: true,
+    status: "idle",
+    maxTasks: 10,
+  });
+  restoreEnv = snapshotChatSdkEnv();
+  mock = startTelegramBotApiMock();
+  // Forwards to the mock; a held send never answers until released.
+  proxy = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (holdSends && SEND_METHODS.test(url.pathname)) {
+        await new Promise<void>((resolve) => held.push(resolve));
+        return Response.json({ ok: false, error_code: 500, description: "held" }, { status: 500 });
+      }
+      return fetch(`${mock.url}${url.pathname}${url.search}`, {
+        method: req.method,
+        headers: req.headers,
+        body: req.method === "GET" ? undefined : await req.arrayBuffer(),
+      });
+    },
+  });
+});
+
+afterAll(async () => {
+  releaseHeld();
+  await stopChatSdk(1_000);
+  proxy.stop(true);
+  mock.stop();
+  restoreEnv();
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("stopChatSdk", () => {
+  test("a relay send that never answers cannot hold shutdown past the budget", async () => {
+    await startChannel();
+    holdSends = true;
+    const chatId = 991_001;
+    const task = await createTaskExtended("chat task", {
+      agentId: lead.id,
+      source: "chat",
+      contextKey: chatSdkContextKey(`telegram:${chatId}`),
+    });
+    await completeTask(task.id, "an answer the platform never acknowledges");
+    // The watcher claims the row and its send hangs in the proxy.
+    await waitFor(() => held.length > 0, "the held relay send");
+
+    const warn = spyOn(console, "warn");
+    const budgetMs = 300;
+    const started = performance.now();
+    await stopChatSdk(budgetMs);
+    const elapsed = performance.now() - started;
+    const warnings = warn.mock.calls.map((call) => String(call[0]));
+    warn.mockRestore();
+
+    // Margin for scheduler jitter; without the bound this never resolves.
+    expect(elapsed).toBeLessThan(budgetMs + 500);
+    expect(warnings.some((line) => line.includes("abandoned: in-flight relay send"))).toBe(true);
+    expect(getChatInstance("telegram")).toBeUndefined();
+
+    // The claimed row is still pending, and it is eligible again after the
+    // first backoff (3 s * 2^1), well inside the 24 h give-up age.
+    const row = await obligation(task.id);
+    expect(row?.delivered_at).toBeNull();
+    expect(row?.given_up_at).toBeNull();
+    expect(row?.attempt_count).toBe(1);
+    const pending = await getPendingChatRelayTasks(Date.now() + 7_000, 200, ["telegram"]);
+    expect(pending.map((entry) => entry.task.id)).toContain(task.id);
+
+    // Let the abandoned send fail so its tick settles before the next test.
+    holdSends = false;
+    releaseHeld();
+    await waitFor(
+      async () => (await obligation(task.id))?.last_error != null,
+      "the abandoned send to settle",
+    );
+    expect((await obligation(task.id))?.delivered_at).toBeNull();
+  });
+
+  test("with nothing in flight, shutdown flushes buffered threads and stops in order", async () => {
+    await startChannel();
+    const chatId = 991_002;
+    const contextKey = chatSdkContextKey(`telegram:${chatId}`);
+    await postTelegramUpdate(telegramUpdate({ id: chatId, type: "private" }, "please help"));
+    const tasksForThread = async (): Promise<number> =>
+      (
+        await getDbClient().get<{ n: number }>(
+          "SELECT COUNT(*) AS n FROM agent_tasks WHERE contextKey = ?",
+          [contextKey],
+        )
+      )?.n ?? 0;
+    // The 60 s buffer still holds the message.
+    expect(await tasksForThread()).toBe(0);
+    const sendsBefore = mock.calls.length;
+
+    const warn = spyOn(console, "warn");
+    await stopChatSdk(5_000);
+    const warnings = warn.mock.calls.map((call) => String(call[0]));
+    warn.mockRestore();
+
+    expect(warnings.filter((line) => line.includes("Shutdown budget spent"))).toEqual([]);
+    expect(isChatSdkStopping()).toBe(true);
+    // The flush ran while the DB and adapters were up: the message became a task.
+    expect(await tasksForThread()).toBe(1);
+    expect(getChatInstance("telegram")).toBeUndefined();
+    expect(getChatSdkHealth()).toEqual({});
+
+    // The relay watcher is stopped: a later terminal task posts nothing.
+    const late = await createTaskExtended("late", {
+      agentId: lead.id,
+      source: "chat",
+      contextKey,
+    });
+    await completeTask(late.id, "after shutdown");
+    await Bun.sleep(400);
+    expect(
+      mock.calls
+        .slice(sendsBefore)
+        // The typing action of the buffered DM may still be in flight when `sendsBefore` is read.
+        .filter((call) => /send/.test(call.method) && call.method !== "sendChatAction"),
+    ).toEqual([]);
+    expect((await obligation(late.id))?.attempt_count).toBe(0);
+  });
+});

package/src/tests/chat-sdk-slack.test.ts

@@ -0,0 +1,268 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { createHmac } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { unlink } from "node:fs/promises";
+import { SlackMock } from "@desplega.ai/slack-mock";
+import { closeDb, completeTask, createAgent, getDbClient, initDb } from "../be/db";
+import { watchSocketConnection } from "../integrations/chat-sdk/adapters";
+import { drainBackground } from "../integrations/chat-sdk/background";
+import { createScrubbingLogger } from "../integrations/chat-sdk/logger";
+import { processPendingChatRelays, stopChatRelayWatcher } from "../integrations/chat-sdk/relay";
+import { getChatSdkHealth, startChatSdk, stopChatSdk } from "../integrations/chat-sdk/runtime";
+import { isChatThreadBuffered } from "../integrations/chat-sdk/thread-buffer";
+import { getEnabledCapabilities } from "../server";
+import { chatSdkContextKey } from "../tasks/context-key";
+import { flushChatBuffers, postChatWebhook, snapshotChatSdkEnv } from "./chat-sdk-harness";
+
+const TEST_DB_PATH = "./test-chat-sdk-slack.sqlite";
+const SIGNING_SECRET = "mock-signing-secret";
+const CHANNEL_ID = "C0GENERAL0";
+
+let slack: SlackMock;
+let leadId: string;
+const restoreEnv = snapshotChatSdkEnv();
+
+type TaskRow = {
+  id: string;
+  source: string;
+  contextKey: string;
+  agentId: string | null;
+  task: string;
+  dependsOn: string | null;
+};
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+  }
+}
+
+async function chatTasks(contextKey: string): Promise<TaskRow[]> {
+  return getDbClient().query<TaskRow>(
+    "SELECT id, source, contextKey, agentId, task, dependsOn FROM agent_tasks WHERE contextKey = ? ORDER BY createdAt, rowid",
+    [contextKey],
+  );
+}
+
+/**
+ * Socket-mode events reach the handler after slack-mock has its ack, so poll
+ * the thread buffer (bounded) instead of sleeping a fixed time.
+ */
+async function waitForBuffered(threadId: string, timeoutMs = 5_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!isChatThreadBuffered(threadId)) {
+    if (Date.now() > deadline) throw new Error(`no buffered message for ${threadId}`);
+    await Bun.sleep(10);
+  }
+  expect(await drainBackground(5_000)).toBe(true);
+}
+
+async function startSlackAdapter(mode: "socket" | "webhook"): Promise<void> {
+  process.env.CHAT_SDK_ENABLED = "true";
+  process.env.CHAT_SDK_ADAPTERS = JSON.stringify({
+    slack: {
+      mode,
+      botToken: slack.env.SLACK_BOT_TOKEN,
+      ...(mode === "socket"
+        ? { appToken: slack.env.SLACK_APP_TOKEN }
+        : { signingSecret: SIGNING_SECRET }),
+    },
+  });
+  process.env.CHAT_SDK_API_URL_OVERRIDES = JSON.stringify({ slack: slack.env.SLACK_API_URL });
+  await startChatSdk();
+  // Relay ticks are driven by the tests.
+  await stopChatRelayWatcher();
+  expect(getChatSdkHealth().slack?.status).toBe("ok");
+}
+
+function signedHeaders(body: string, secret = SIGNING_SECRET): Record<string, string> {
+  const timestamp = String(Math.floor(Date.now() / 1000));
+  const signature = `v0=${createHmac("sha256", secret).update(`v0:${timestamp}:${body}`).digest("hex")}`;
+  return {
+    "content-type": "application/json",
+    "x-slack-request-timestamp": timestamp,
+    "x-slack-signature": signature,
+  };
+}
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  const lead = await createAgent({
+    id: crypto.randomUUID(),
+    name: "SlackChatLead",
+    isLead: true,
+    status: "idle",
+    capabilities: [],
+  });
+  leadId = lead.id;
+  slack = await SlackMock.start({
+    port: 0,
+    manifest: `${import.meta.dir}/../../slack-manifest.json`,
+  });
+  process.env.SLACK_DISABLE = "true";
+  process.env.CHAT_SDK_BUFFER_MS = "60000";
+});
+
+afterAll(async () => {
+  await stopChatSdk();
+  await slack.stop();
+  restoreEnv();
+  closeDb();
+  await removeDbFiles();
+});
+
+describe("socket connection watcher", () => {
+  test("reconnecting stays info; unable_to_socket_mode_start reaches the warning sink", () => {
+    const socketClient = new EventEmitter();
+    const issues: string[] = [];
+    const logger = createScrubbingLogger("slack", (level, message) =>
+      issues.push(`${level}: ${message}`),
+    );
+    const quiet = spyOn(console, "info").mockImplementation(() => {});
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      watchSocketConnection({ socketClient } as never, logger);
+      socketClient.emit("reconnecting");
+      expect(issues).toEqual([]);
+      socketClient.emit("unable_to_socket_mode_start");
+      expect(issues).toHaveLength(1);
+      expect(issues[0]).toContain("unable to start");
+    } finally {
+      quiet.mockRestore();
+      warn.mockRestore();
+    }
+  });
+});
+
+describe("clash guard", () => {
+  test("SLACK_DISABLE=true drops the built-in slack capability and keeps chat-sdk", () => {
+    process.env.CHAT_SDK_ENABLED = "true";
+    const capabilities = getEnabledCapabilities();
+    expect(capabilities).not.toContain("slack");
+    expect(capabilities).toContain("chat-sdk");
+  });
+});
+
+describe("Chat SDK Slack adapter, socket mode", () => {
+  let askTs: string;
+  let firstTaskId: string;
+  let contextKey: string;
+
+  beforeAll(async () => {
+    await startSlackAdapter("socket");
+    await slack.waitForConnection();
+  });
+
+  afterAll(async () => {
+    await stopChatSdk();
+  });
+
+  test("the webhook route answers the adapter's 405 in socket mode", async () => {
+    const body = JSON.stringify({ type: "url_verification", challenge: "c" });
+    const response = await postChatWebhook("slack", body, signedHeaders(body));
+    expect(response.status).toBe(405);
+  });
+
+  test("a mention creates one chat task with a slack contextKey", async () => {
+    const ask = await slack.postMessage({
+      channel: "general",
+      user: "alice",
+      text: `<@${slack.bot.userId}> summarize the open tasks`,
+    });
+    askTs = ask.ts;
+    const threadId = `slack:${CHANNEL_ID}:${askTs}`;
+    contextKey = chatSdkContextKey(threadId);
+    expect(contextKey.startsWith("task:chat-sdk:slack:")).toBe(true);
+
+    await waitForBuffered(threadId);
+    await flushChatBuffers();
+
+    const tasks = await chatTasks(contextKey);
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0]!.source).toBe("chat");
+    expect(tasks[0]!.agentId).toBe(leadId);
+    expect(tasks[0]!.task).toContain("summarize the open tasks");
+    firstTaskId = tasks[0]!.id;
+  });
+
+  test("a human reply while the task is pending becomes a follow-up with dependsOn", async () => {
+    await slack.postMessage({
+      channel: "general",
+      user: "bob",
+      thread_ts: askTs,
+      text: "also include the failed ones",
+    });
+    await waitForBuffered(`slack:${CHANNEL_ID}:${askTs}`);
+    await flushChatBuffers();
+
+    const tasks = await chatTasks(contextKey);
+    expect(tasks).toHaveLength(2);
+    const followUp = tasks[1]!;
+    expect(followUp.task).toContain("also include the failed ones");
+    expect(JSON.parse(followUp.dependsOn ?? "[]")).toEqual([firstTaskId]);
+  });
+
+  test("completing the task posts its output in the Slack thread", async () => {
+    await completeTask(firstTaskId, "Three tasks are open.");
+    await processPendingChatRelays();
+    const reply = await slack.waitForMessage(
+      { channel: "general", thread_ts: askTs, from: "bot" },
+      { timeoutMs: 5_000 },
+    );
+    expect(reply.text).toContain("Three tasks are open.");
+  });
+});
+
+describe("Chat SDK Slack adapter, webhook mode", () => {
+  beforeAll(async () => {
+    await startSlackAdapter("webhook");
+  });
+
+  afterAll(async () => {
+    await stopChatSdk();
+  });
+
+  test("a signed url_verification is answered with the challenge", async () => {
+    const body = JSON.stringify({ type: "url_verification", challenge: "challenge-123" });
+    const response = await postChatWebhook("slack", body, signedHeaders(body));
+    expect(response.status).toBe(200);
+    expect(JSON.parse(response.body)).toEqual({ challenge: "challenge-123" });
+  });
+
+  test("an unsigned or wrongly signed event_callback is rejected with 401", async () => {
+    const body = JSON.stringify({ type: "event_callback", event: { type: "app_mention" } });
+    const unsigned = await postChatWebhook("slack", body, { "content-type": "application/json" });
+    expect(unsigned.status).toBe(401);
+    const wrong = await postChatWebhook("slack", body, signedHeaders(body, "not-the-secret"));
+    expect(wrong.status).toBe(401);
+  });
+
+  test("a signed app_mention creates a chat task", async () => {
+    const ts = `${Math.floor(Date.now() / 1000)}.000777`;
+    const body = JSON.stringify({
+      type: "event_callback",
+      team_id: slack.team.id,
+      api_app_id: "A0MOCKAPP0",
+      event_id: `Ev${crypto.randomUUID().replaceAll("-", "").slice(0, 10)}`,
+      event_time: Math.floor(Date.now() / 1000),
+      event: {
+        type: "app_mention",
+        user: "U0ALICE000",
+        text: `<@${slack.bot.userId}> webhook hello`,
+        ts,
+        channel: CHANNEL_ID,
+        event_ts: ts,
+      },
+    });
+    const response = await postChatWebhook("slack", body, signedHeaders(body));
+    expect(response.status).toBe(200);
+    expect(await drainBackground(5_000)).toBe(true);
+    await flushChatBuffers();
+
+    const tasks = await chatTasks(chatSdkContextKey(`slack:${CHANNEL_ID}:${ts}`));
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0]!.source).toBe("chat");
+    expect(tasks[0]!.task).toContain("webhook hello");
+  });
+});

package/src/tests/chat-sdk-state.test.ts

@@ -0,0 +1,163 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type { QueueEntry } from "chat";
+import { closeDb, getDbClient, initDb } from "../be/db";
+import { SqliteChatState, sweepExpired } from "../integrations/chat-sdk/state";
+
+const TEST_DB_PATH = "./test-chat-sdk-state.sqlite";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+  }
+}
+
+const state = new SqliteChatState();
+
+beforeAll(async () => {
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+  await state.connect();
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles();
+});
+
+function entry(id: string, expiresAt = Date.now() + 60_000): QueueEntry {
+  return { enqueuedAt: Date.now(), expiresAt, message: { id } as unknown as QueueEntry["message"] };
+}
+
+describe("SqliteChatState locks", () => {
+  test("acquire is exclusive until release", async () => {
+    const lock = await state.acquireLock("telegram:1", 60_000);
+    expect(lock).not.toBeNull();
+    expect(await state.acquireLock("telegram:1", 60_000)).toBeNull();
+    await state.releaseLock(lock!);
+    expect(await state.acquireLock("telegram:1", 60_000)).not.toBeNull();
+    await state.forceReleaseLock("telegram:1");
+  });
+
+  test("release with a stale token keeps the current holder", async () => {
+    const lock = await state.acquireLock("telegram:2", 60_000);
+    await state.releaseLock({ ...lock!, token: "other" });
+    expect(await state.acquireLock("telegram:2", 60_000)).toBeNull();
+    await state.forceReleaseLock("telegram:2");
+    expect(await state.acquireLock("telegram:2", 60_000)).not.toBeNull();
+    await state.forceReleaseLock("telegram:2");
+  });
+
+  test("an expired lock can be taken over and no longer extends", async () => {
+    const first = await state.acquireLock("telegram:3", 1);
+    await Bun.sleep(5);
+    const second = await state.acquireLock("telegram:3", 60_000);
+    expect(second).not.toBeNull();
+    expect(second!.token).not.toBe(first!.token);
+    expect(await state.extendLock(first!, 60_000)).toBe(false);
+    expect(await state.extendLock(second!, 60_000)).toBe(true);
+    await state.releaseLock(second!);
+  });
+});
+
+describe("SqliteChatState key-value", () => {
+  test("get/set/delete round trip JSON values", async () => {
+    await state.set("k:obj", { a: 1, b: ["x"] });
+    expect(await state.get<{ a: number; b: string[] }>("k:obj")).toEqual({ a: 1, b: ["x"] });
+    await state.delete("k:obj");
+    expect(await state.get("k:obj")).toBeNull();
+  });
+
+  test("ttl expires values and 0 means no expiry", async () => {
+    await state.set("k:short", "v", 1);
+    await state.set("k:forever", "v", 0);
+    await Bun.sleep(5);
+    expect(await state.get("k:short")).toBeNull();
+    expect(await state.get("k:forever")).toBe("v");
+  });
+
+  test("setIfNotExists claims once and reclaims after expiry", async () => {
+    expect(await state.setIfNotExists("dedupe:telegram:1", true, 60_000)).toBe(true);
+    expect(await state.setIfNotExists("dedupe:telegram:1", true, 60_000)).toBe(false);
+    expect(await state.setIfNotExists("dedupe:telegram:2", true, 1)).toBe(true);
+    await Bun.sleep(5);
+    expect(await state.setIfNotExists("dedupe:telegram:2", true, 60_000)).toBe(true);
+  });
+});
+
+describe("SqliteChatState lists", () => {
+  test("append keeps the newest maxLength in order", async () => {
+    for (let i = 1; i <= 5; i++) await state.appendToList("list:a", i, { maxLength: 3 });
+    expect(await state.getList<number>("list:a")).toEqual([3, 4, 5]);
+  });
+
+  test("ttl is reset on every append and an expired list starts over", async () => {
+    await state.appendToList("list:b", "one", { ttlMs: 1 });
+    await Bun.sleep(5);
+    expect(await state.getList("list:b")).toEqual([]);
+    await state.appendToList("list:b", "two", { ttlMs: 60_000 });
+    expect(await state.getList("list:b")).toEqual(["two"]);
+
+    // The second append moves every row of the list to the new expiry. A short
+    // first TTL would race the second append under CI load, so read the
+    // stored expiries instead of sleeping past them.
+    await state.appendToList("list:c", "x", { ttlMs: 30_000 });
+    const before = Date.now();
+    await state.appendToList("list:c", "y", { ttlMs: 60_000 });
+    const row = await getDbClient().get<{ lo: number; hi: number }>(
+      "SELECT MIN(expires_at) AS lo, MAX(expires_at) AS hi FROM chat_lists WHERE key = ?",
+      ["list:c"],
+    );
+    expect(row?.lo).toBe(row?.hi);
+    expect(row?.lo).toBeGreaterThanOrEqual(before + 60_000);
+    expect(await state.getList("list:c")).toEqual(["x", "y"]);
+  });
+});
+
+describe("SqliteChatState queue", () => {
+  test("FIFO with maxSize dropping the oldest", async () => {
+    expect(await state.enqueue("telegram:q", entry("m1"), 2)).toBe(1);
+    expect(await state.enqueue("telegram:q", entry("m2"), 2)).toBe(2);
+    expect(await state.enqueue("telegram:q", entry("m3"), 2)).toBe(2);
+    expect(await state.queueDepth("telegram:q")).toBe(2);
+    expect((await state.dequeue("telegram:q"))?.message.id).toBe("m2");
+    expect((await state.dequeue("telegram:q"))?.message.id).toBe("m3");
+    expect(await state.dequeue("telegram:q")).toBeNull();
+  });
+
+  test("dequeue returns expired entries (the core filters them)", async () => {
+    await state.enqueue("telegram:q2", entry("old", Date.now() - 1), 5);
+    expect((await state.dequeue("telegram:q2"))?.message.id).toBe("old");
+  });
+});
+
+describe("SqliteChatState subscriptions", () => {
+  test("subscriptions survive disconnect", async () => {
+    await state.subscribe("telegram:sub");
+    await state.subscribe("telegram:sub");
+    expect(await state.isSubscribed("telegram:sub")).toBe(true);
+    await state.disconnect();
+    await state.connect();
+    expect(await state.isSubscribed("telegram:sub")).toBe(true);
+    await state.unsubscribe("telegram:sub");
+    expect(await state.isSubscribed("telegram:sub")).toBe(false);
+  });
+});
+
+describe("sweepExpired", () => {
+  test("removes expired kv, list and lock rows only", async () => {
+    await state.set("sweep:old", 1, 1);
+    await state.set("sweep:new", 1, 60_000);
+    await state.appendToList("sweep:list", 1, { ttlMs: 1 });
+    await state.acquireLock("telegram:sweep", 1);
+    await Bun.sleep(5);
+    await sweepExpired();
+    const db = getDbClient();
+    expect(await db.get("SELECT key FROM chat_state_kv WHERE key = 'sweep:old'")).toBeNull();
+    expect(await db.get("SELECT key FROM chat_state_kv WHERE key = 'sweep:new'")).not.toBeNull();
+    expect(await db.get("SELECT key FROM chat_lists WHERE key = 'sweep:list'")).toBeNull();
+    expect(
+      await db.get("SELECT thread_id FROM chat_locks WHERE thread_id = 'telegram:sweep'"),
+    ).toBeNull();
+  });
+});