@desplega.ai/agent-swarm 1.49.0 → 1.52.0

package/src/tests/artifact-sdk.test.ts

@@ -731,8 +731,8 @@ describe("artifact CLI command", () => {
 // ─── Base prompt tests ──────────────────────────────────────────────────
 
 describe("base prompt artifacts mention", () => {
-  test("includes artifacts mention when capability is set", () => {
-    const prompt = getBasePrompt({
+  test("includes artifacts mention when capability is set", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",
@@ -743,8 +743,8 @@ describe("base prompt artifacts mention", () => {
     expect(prompt).toContain("/workspace/personal/artifacts/");
   });
 
-  test("excludes artifacts mention without capability", () => {
-    const prompt = getBasePrompt({
+  test("excludes artifacts mention without capability", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",
@@ -754,8 +754,8 @@ describe("base prompt artifacts mention", () => {
     expect(prompt).not.toContain("/artifacts");
   });
 
-  test("includes artifacts mention when no capabilities specified (default)", () => {
-    const prompt = getBasePrompt({
+  test("includes artifacts mention when no capabilities specified (default)", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",
@@ -764,8 +764,8 @@ describe("base prompt artifacts mention", () => {
     expect(prompt).toContain("/artifacts");
   });
 
-  test("does NOT inline full artifact docs (those go in the skill)", () => {
-    const prompt = getBasePrompt({
+  test("does NOT inline full artifact docs (those go in the skill)", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",
@@ -776,8 +776,8 @@ describe("base prompt artifacts mention", () => {
     expect(prompt).not.toContain("SwarmSDK");
   });
 
-  test("mentions localtunnel concept", () => {
-    const prompt = getBasePrompt({
+  test("mentions localtunnel concept", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",
@@ -787,8 +787,8 @@ describe("base prompt artifacts mention", () => {
     expect(prompt).toContain("localtunnel");
   });
 
-  test("mentions artifact storage path", () => {
-    const prompt = getBasePrompt({
+  test("mentions artifact storage path", async () => {
+    const prompt = await getBasePrompt({
       role: "worker",
       agentId: "test-agent-id",
       swarmUrl: "https://test.swarm.example.com",

package/src/tests/base-prompt.test.ts

@@ -12,25 +12,25 @@ const minimalArgs: BasePromptArgs = {
 // Basic fields
 // ---------------------------------------------------------------------------
 describe("getBasePrompt — basic fields", () => {
-  test("includes role and agentId", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("includes role and agentId", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).toContain("worker");
     expect(result).toContain("agent-abc-123");
   });
 
-  test("lead role gets lead prompt", () => {
-    const result = getBasePrompt({ ...minimalArgs, role: "lead" });
+  test("lead role gets lead prompt", async () => {
+    const result = await getBasePrompt({ ...minimalArgs, role: "lead" });
     expect(result).toContain("lead agent");
     expect(result).toContain("coordinator");
   });
 
-  test("worker role gets worker prompt", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("worker role gets worker prompt", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).toContain("worker agent");
   });
 
-  test("includes swarmUrl and agentId in services section", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("includes swarmUrl and agentId in services section", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).toContain("swarm.example.com");
     expect(result).toContain(`https://agent-abc-123.swarm.example.com`);
   });
@@ -40,13 +40,13 @@ describe("getBasePrompt — basic fields", () => {
 // Identity fields (name, description, soulMd, identityMd)
 // ---------------------------------------------------------------------------
 describe("getBasePrompt — identity fields", () => {
-  test("includes name when provided", () => {
-    const result = getBasePrompt({ ...minimalArgs, name: "TestAgent" });
+  test("includes name when provided", async () => {
+    const result = await getBasePrompt({ ...minimalArgs, name: "TestAgent" });
     expect(result).toContain("**Name:** TestAgent");
   });
 
-  test("includes description when name provided", () => {
-    const result = getBasePrompt({
+  test("includes description when name provided", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       name: "TestAgent",
       description: "A helpful agent",
@@ -54,16 +54,16 @@ describe("getBasePrompt — identity fields", () => {
     expect(result).toContain("**Description:** A helpful agent");
   });
 
-  test("does not include description without name", () => {
-    const result = getBasePrompt({
+  test("does not include description without name", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       description: "A helpful agent",
     });
     expect(result).not.toContain("**Description:**");
   });
 
-  test("includes soulMd content", () => {
-    const result = getBasePrompt({
+  test("includes soulMd content", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       soulMd: "I am a creative soul.",
     });
@@ -71,8 +71,8 @@ describe("getBasePrompt — identity fields", () => {
     expect(result).toContain("I am a creative soul.");
   });
 
-  test("includes identityMd content", () => {
-    const result = getBasePrompt({
+  test("includes identityMd content", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       identityMd: "Identity content here.",
     });
@@ -80,8 +80,8 @@ describe("getBasePrompt — identity fields", () => {
     expect(result).toContain("Identity content here.");
   });
 
-  test("no identity section when none provided", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("no identity section when none provided", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).not.toContain("## Your Identity");
   });
 });
@@ -90,8 +90,8 @@ describe("getBasePrompt — identity fields", () => {
 // claudeMd and toolsMd injection
 // ---------------------------------------------------------------------------
 describe("getBasePrompt — claudeMd and toolsMd injection", () => {
-  test("includes claudeMd under Agent Instructions", () => {
-    const result = getBasePrompt({
+  test("includes claudeMd under Agent Instructions", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       claudeMd: "Follow these rules.",
     });
@@ -99,8 +99,8 @@ describe("getBasePrompt — claudeMd and toolsMd injection", () => {
     expect(result).toContain("Follow these rules.");
   });
 
-  test("includes toolsMd under Tools & Capabilities", () => {
-    const result = getBasePrompt({
+  test("includes toolsMd under Tools & Capabilities", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       toolsMd: "You can use curl.",
     });
@@ -108,8 +108,8 @@ describe("getBasePrompt — claudeMd and toolsMd injection", () => {
     expect(result).toContain("You can use curl.");
   });
 
-  test("both claudeMd and toolsMd coexist", () => {
-    const result = getBasePrompt({
+  test("both claudeMd and toolsMd coexist", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       claudeMd: "Agent instructions content",
       toolsMd: "Tools content",
@@ -120,8 +120,8 @@ describe("getBasePrompt — claudeMd and toolsMd injection", () => {
     expect(result).toContain("Tools content");
   });
 
-  test("neither present when not provided", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("neither present when not provided", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).not.toContain("## Agent Instructions");
     expect(result).not.toContain("## Your Tools & Capabilities");
   });
@@ -131,8 +131,8 @@ describe("getBasePrompt — claudeMd and toolsMd injection", () => {
 // repoContext
 // ---------------------------------------------------------------------------
 describe("getBasePrompt — repoContext", () => {
-  test("includes repo claudeMd with clone path", () => {
-    const result = getBasePrompt({
+  test("includes repo claudeMd with clone path", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       repoContext: {
         claudeMd: "Repo-specific rules here.",
@@ -144,8 +144,8 @@ describe("getBasePrompt — repoContext", () => {
     expect(result).toContain("Repo-specific rules here.");
   });
 
-  test("shows warning when provided", () => {
-    const result = getBasePrompt({
+  test("shows warning when provided", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       repoContext: {
         claudeMd: "Rules",
@@ -156,8 +156,8 @@ describe("getBasePrompt — repoContext", () => {
     expect(result).toContain("WARNING: Repo is stale");
   });
 
-  test("shows 'no CLAUDE.md' message when claudeMd is null and no warning", () => {
-    const result = getBasePrompt({
+  test("shows 'no CLAUDE.md' message when claudeMd is null and no warning", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       repoContext: {
         claudeMd: null,
@@ -172,21 +172,21 @@ describe("getBasePrompt — repoContext", () => {
 // Capabilities
 // ---------------------------------------------------------------------------
 describe("getBasePrompt — capabilities", () => {
-  test("services section included by default", () => {
-    const result = getBasePrompt(minimalArgs);
+  test("services section included by default", async () => {
+    const result = await getBasePrompt(minimalArgs);
     expect(result).toContain("Service Registry");
   });
 
-  test("services section excluded when capabilities don't include services", () => {
-    const result = getBasePrompt({
+  test("services section excluded when capabilities don't include services", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       capabilities: ["artifacts"],
     });
     expect(result).not.toContain("Service Registry");
   });
 
-  test("capabilities list rendered", () => {
-    const result = getBasePrompt({
+  test("capabilities list rendered", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       capabilities: ["services", "artifacts"],
     });
@@ -202,8 +202,8 @@ describe("getBasePrompt — capabilities", () => {
 describe("getBasePrompt — truncation", () => {
   const bigString = (n: number) => "x".repeat(n);
 
-  test("claudeMd truncated when exceeding per-section limit (20k chars)", () => {
-    const result = getBasePrompt({
+  test("claudeMd truncated when exceeding per-section limit (20k chars)", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       claudeMd: bigString(25_000),
     });
@@ -212,8 +212,8 @@ describe("getBasePrompt — truncation", () => {
     expect(result).not.toContain(bigString(25_000));
   });
 
-  test("toolsMd truncated when exceeding per-section limit", () => {
-    const result = getBasePrompt({
+  test("toolsMd truncated when exceeding per-section limit", async () => {
+    const result = await getBasePrompt({
       ...minimalArgs,
       toolsMd: bigString(25_000),
     });
@@ -221,18 +221,18 @@ describe("getBasePrompt — truncation", () => {
     expect(result).not.toContain(bigString(25_000));
   });
 
-  test("total budget respected — tools truncated before claudeMd", () => {
+  test("total budget respected — tools truncated before claudeMd", async () => {
     // Use soulMd to eat up most of the 150k total budget so that
     // truncatable sections (claudeMd, toolsMd) must compete for the remainder.
     // soulMd is part of `prompt` which counts toward protectedLength.
-    const baseResult = getBasePrompt(minimalArgs);
+    const baseResult = await getBasePrompt(minimalArgs);
     const staticLength = baseResult.length; // ~12-13k for static content
 
     // Leave exactly enough budget for claudeMd but not toolsMd.
     // Total budget = 150k - protectedLength.
     // We want: protectedLength ≈ 150k - 18k = 132k, so claudeMd (15k) fits but toolsMd doesn't.
     const soulSize = 132_000 - staticLength;
-    const result = getBasePrompt({
+    const result = await getBasePrompt({
       ...minimalArgs,
       soulMd: bigString(Math.max(0, soulSize)),
       claudeMd: bigString(15_000),
@@ -248,9 +248,9 @@ describe("getBasePrompt — truncation", () => {
     expect(hasToolsTruncation || !hasToolsHeader).toBe(true);
   });
 
-  test("repo context never truncated", () => {
+  test("repo context never truncated", async () => {
     const hugeRepoClaudeMd = bigString(30_000);
-    const result = getBasePrompt({
+    const result = await getBasePrompt({
       ...minimalArgs,
       repoContext: {
         claudeMd: hugeRepoClaudeMd,

package/src/tests/channel-activity.test.ts

@@ -0,0 +1,363 @@
+import { afterAll, beforeAll, describe, expect, mock, setDefaultTimeout, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { createServer as createHttpServer, type Server } from "node:http";
+
+// Migrations + mock.module + @slack/bolt resolution can take >5s on cold start
+setDefaultTimeout(30_000);
+
+// ─── Mock Slack client (must be before channel-activity import) ─────────────
+
+// Mutable mock implementation — changed per test via reassignment
+let historyImpl: (args: Record<string, unknown>) => Promise<{
+  messages?: Array<Record<string, unknown>>;
+}> = () => Promise.resolve({ messages: [] });
+
+mock.module("../slack/app", () => ({
+  getSlackApp: () => ({
+    client: {
+      auth: { test: () => Promise.resolve({ user_id: "UBOT123" }) },
+      conversations: {
+        history: (args: Record<string, unknown>) => historyImpl(args),
+        list: () =>
+          Promise.resolve({
+            channels: [
+              { id: "C001", name: "general", is_member: true },
+              { id: "C002", name: "random", is_member: true },
+              { id: "C003", name: "archived", is_member: false },
+            ],
+            response_metadata: {},
+          }),
+      },
+    },
+  }),
+}));
+
+import {
+  closeDb,
+  getAllChannelActivityCursors,
+  getChannelActivityCursor,
+  initDb,
+  upsertChannelActivityCursor,
+} from "../be/db";
+import { fetchChannelActivity } from "../slack/channel-activity";
+
+const TEST_DB_PATH = `./test-channel-activity-${process.pid}.sqlite`;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {
+      // ignore
+    }
+  }
+});
+
+// ─── DB Functions ──────────────────────────────────────────────────────────────
+
+describe("Channel Activity Cursors — DB functions", () => {
+  test("getChannelActivityCursor returns null for non-existent channel", () => {
+    const cursor = getChannelActivityCursor("C_NONEXISTENT");
+    expect(cursor).toBeNull();
+  });
+
+  test("getAllChannelActivityCursors returns an array", () => {
+    const cursors = getAllChannelActivityCursors();
+    expect(Array.isArray(cursors)).toBe(true);
+  });
+
+  test("upsertChannelActivityCursor inserts a new cursor", () => {
+    upsertChannelActivityCursor("C_INSERT_TEST", "1711111111.000001");
+    const cursor = getChannelActivityCursor("C_INSERT_TEST");
+    expect(cursor).not.toBeNull();
+    expect(cursor!.channelId).toBe("C_INSERT_TEST");
+    expect(cursor!.lastSeenTs).toBe("1711111111.000001");
+    expect(cursor!.updatedAt).toBeTruthy();
+  });
+
+  test("upsertChannelActivityCursor updates existing cursor", () => {
+    upsertChannelActivityCursor("C_UPDATE_TEST", "1711111111.000001");
+    upsertChannelActivityCursor("C_UPDATE_TEST", "1711111111.000099");
+    const after = getChannelActivityCursor("C_UPDATE_TEST");
+    expect(after!.lastSeenTs).toBe("1711111111.000099");
+  });
+
+  test("getAllChannelActivityCursors returns all inserted cursors", () => {
+    upsertChannelActivityCursor("C_ALL_1", "1711111111.000001");
+    upsertChannelActivityCursor("C_ALL_2", "1711111111.000002");
+    const ids = getAllChannelActivityCursors().map((c) => c.channelId);
+    expect(ids).toContain("C_ALL_1");
+    expect(ids).toContain("C_ALL_2");
+  });
+
+  test("channelId is primary key — no duplicates", () => {
+    upsertChannelActivityCursor("C_PK_TEST", "1711111111.000001");
+    upsertChannelActivityCursor("C_PK_TEST", "1711111111.000002");
+    upsertChannelActivityCursor("C_PK_TEST", "1711111111.000003");
+    const cursors = getAllChannelActivityCursors().filter((c) => c.channelId === "C_PK_TEST");
+    expect(cursors.length).toBe(1);
+    expect(cursors[0].lastSeenTs).toBe("1711111111.000003");
+  });
+});
+
+// ─── Cursor Commit Endpoint ─────────────────────────────────────────────────
+
+describe("Channel Activity — cursor commit endpoint", () => {
+  let server: Server;
+  const TEST_PORT = 13099;
+
+  beforeAll(async () => {
+    server = createHttpServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/api/channel-activity/commit-cursors") {
+        const body = await new Promise<string>((resolve) => {
+          let data = "";
+          req.on("data", (chunk: Buffer) => {
+            data += chunk.toString();
+          });
+          req.on("end", () => resolve(data));
+        });
+
+        try {
+          const parsed = JSON.parse(body) as {
+            cursorUpdates?: Array<{ channelId: string; ts: string }>;
+          };
+
+          if (!parsed.cursorUpdates || !Array.isArray(parsed.cursorUpdates)) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing cursorUpdates array" }));
+            return;
+          }
+
+          for (const { channelId, ts } of parsed.cursorUpdates) {
+            if (channelId && ts) {
+              upsertChannelActivityCursor(channelId, ts);
+            }
+          }
+
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true, committed: parsed.cursorUpdates.length }));
+        } catch (err) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: `Invalid request: ${err}` }));
+        }
+        return;
+      }
+
+      res.writeHead(404);
+      res.end("Not Found");
+    });
+
+    await new Promise<void>((resolve) => {
+      server.listen(TEST_PORT, () => resolve());
+    });
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  test("commits cursor updates successfully", async () => {
+    const resp = await fetch(`http://localhost:${TEST_PORT}/api/channel-activity/commit-cursors`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        cursorUpdates: [
+          { channelId: "C_COMMIT_1", ts: "1711222222.000001" },
+          { channelId: "C_COMMIT_2", ts: "1711222222.000002" },
+        ],
+      }),
+    });
+
+    expect(resp.status).toBe(200);
+    const data = (await resp.json()) as { success: boolean; committed: number };
+    expect(data.success).toBe(true);
+    expect(data.committed).toBe(2);
+
+    expect(getChannelActivityCursor("C_COMMIT_1")!.lastSeenTs).toBe("1711222222.000001");
+    expect(getChannelActivityCursor("C_COMMIT_2")!.lastSeenTs).toBe("1711222222.000002");
+  });
+
+  test("rejects request without cursorUpdates array", async () => {
+    const resp = await fetch(`http://localhost:${TEST_PORT}/api/channel-activity/commit-cursors`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ foo: "bar" }),
+    });
+    expect(resp.status).toBe(400);
+  });
+
+  test("rejects invalid JSON body", async () => {
+    const resp = await fetch(`http://localhost:${TEST_PORT}/api/channel-activity/commit-cursors`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "not json",
+    });
+    expect(resp.status).toBe(400);
+  });
+
+  test("skips entries with missing channelId or ts", async () => {
+    const resp = await fetch(`http://localhost:${TEST_PORT}/api/channel-activity/commit-cursors`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        cursorUpdates: [
+          { channelId: "C_VALID", ts: "1711333333.000001" },
+          { channelId: "", ts: "1711333333.000002" },
+          { channelId: "C_NO_TS", ts: "" },
+        ],
+      }),
+    });
+
+    expect(resp.status).toBe(200);
+    expect(getChannelActivityCursor("C_VALID")!.lastSeenTs).toBe("1711333333.000001");
+    expect(getChannelActivityCursor("C_NO_TS")).toBeNull();
+  });
+});
+
+// ─── fetchChannelActivity (mocked Slack) ─────────────────────────────────────
+
+describe("Channel Activity — fetchChannelActivity", () => {
+  test("cold-start: channels without cursor get seed cursors, no messages", async () => {
+    historyImpl = () =>
+      Promise.resolve({
+        messages: [{ ts: "1711000000.000100", user: "U123", text: "Latest" }],
+      });
+
+    const result = await fetchChannelActivity(new Map());
+
+    // Cold start should NOT return messages (prevents flood)
+    expect(result.messages).toHaveLength(0);
+    // Should have seed cursors for bot-member channels (C001 and C002; C003 is_member=false)
+    expect(result.seedCursors.size).toBe(2);
+    expect(result.seedCursors.get("C001")).toBe("1711000000.000100");
+    expect(result.seedCursors.get("C002")).toBe("1711000000.000100");
+  });
+
+  test("incremental: returns messages newer than cursor, sorted oldest-first", async () => {
+    historyImpl = () =>
+      Promise.resolve({
+        messages: [
+          { ts: "1711000000.000050", user: "U123", text: "At cursor" },
+          { ts: "1711000000.000060", user: "U456", text: "Newer 2" },
+          { ts: "1711000000.000055", user: "U789", text: "Newer 1" },
+        ],
+      });
+
+    const cursors = new Map([
+      ["C001", "1711000000.000050"],
+      ["C002", "1711000000.000050"],
+    ]);
+    const result = await fetchChannelActivity(cursors);
+
+    // Cursor message skipped, 2 newer per channel × 2 channels = 4
+    const c001msgs = result.messages.filter((m) => m.channelId === "C001");
+    expect(c001msgs).toHaveLength(2);
+    // Sorted oldest-first
+    expect(Number.parseFloat(result.messages[0].ts)).toBeLessThanOrEqual(
+      Number.parseFloat(result.messages[result.messages.length - 1].ts),
+    );
+  });
+
+  test("filters bot messages, thread replies, empty text, own bot user", async () => {
+    historyImpl = () =>
+      Promise.resolve({
+        messages: [
+          { ts: "1711000000.000051", user: "U123", text: "Valid message" },
+          { ts: "1711000000.000052", user: "U456", text: "Bot msg", bot_id: "B001" },
+          { ts: "1711000000.000053", user: "U789", text: "Bot subtype", subtype: "bot_message" },
+          { ts: "1711000000.000054", user: "UBOT123", text: "Own bot msg" },
+          { ts: "1711000000.000055", user: "U111", text: "" },
+          {
+            ts: "1711000000.000056",
+            user: "U222",
+            text: "Thread reply",
+            thread_ts: "1711000000.000001",
+          },
+          {
+            ts: "1711000000.000057",
+            user: "U333",
+            text: "Thread parent",
+            thread_ts: "1711000000.000057",
+          },
+          { ts: "1711000000.000058", user: undefined, text: "No user" },
+        ],
+      });
+
+    const cursors = new Map([["C001", "1711000000.000050"]]);
+    const result = await fetchChannelActivity(cursors, ["C001"]);
+
+    const texts = result.messages.map((m) => m.text);
+    expect(texts).toContain("Valid message");
+    expect(texts).toContain("Thread parent");
+    expect(texts).not.toContain("Bot msg");
+    expect(texts).not.toContain("Bot subtype");
+    expect(texts).not.toContain("Own bot msg");
+    expect(texts).not.toContain("Thread reply");
+    expect(texts).not.toContain("No user");
+  });
+
+  test("allowedChannelIds restricts which channels are processed", async () => {
+    historyImpl = () =>
+      Promise.resolve({
+        messages: [{ ts: "1711000000.000100", user: "U123", text: "Hello" }],
+      });
+
+    const cursors = new Map([
+      ["C001", "1711000000.000050"],
+      ["C002", "1711000000.000050"],
+    ]);
+    const result = await fetchChannelActivity(cursors, ["C001"]);
+
+    const channelIds = new Set(result.messages.map((m) => m.channelId));
+    expect(channelIds.has("C001")).toBe(true);
+    expect(channelIds.has("C002")).toBe(false);
+  });
+
+  test("gracefully handles errors from conversations.history", async () => {
+    historyImpl = () => Promise.reject(new Error("channel_not_found"));
+
+    const cursors = new Map([["C001", "1711000000.000050"]]);
+    const result = await fetchChannelActivity(cursors, ["C001"]);
+
+    // Should not throw — errors are caught and logged
+    expect(result.messages).toHaveLength(0);
+  });
+
+  test("includes channelName in returned messages", async () => {
+    historyImpl = () =>
+      Promise.resolve({
+        messages: [{ ts: "1711000000.000051", user: "U123", text: "Hi" }],
+      });
+
+    const cursors = new Map([["C001", "1711000000.000050"]]);
+    const result = await fetchChannelActivity(cursors, ["C001"]);
+
+    expect(result.messages[0].channelName).toBe("general");
+    expect(result.messages[0].channelId).toBe("C001");
+  });
+});
+
+// ─── Migration ──────────────────────────────────────────────────────────────
+
+describe("Channel Activity — migration 015", () => {
+  test("channel_activity_cursors table exists and has correct schema", () => {
+    upsertChannelActivityCursor("C_SCHEMA_TEST", "1711999999.000001");
+    const cursor = getChannelActivityCursor("C_SCHEMA_TEST");
+    expect(cursor).not.toBeNull();
+    expect(cursor!.channelId).toBe("C_SCHEMA_TEST");
+    expect(cursor!.lastSeenTs).toBe("1711999999.000001");
+    expect(cursor!.updatedAt).toBeTruthy();
+  });
+
+  test("channelId is PRIMARY KEY — duplicate insert updates instead of failing", () => {
+    upsertChannelActivityCursor("C_PK_MIG", "1711000000.000001");
+    upsertChannelActivityCursor("C_PK_MIG", "1711000000.000999");
+    const cursor = getChannelActivityCursor("C_PK_MIG");
+    expect(cursor!.lastSeenTs).toBe("1711000000.000999");
+  });
+});