@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/tests/skill-files.test.ts

@@ -0,0 +1,162 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createSkill,
+  deleteSkill,
+  deleteSkillFile,
+  getDb,
+  getSkillFile,
+  initDb,
+  listSkillFileManifest,
+  normalizeSkillFilePath,
+  upsertSkillFile,
+  upsertSkillFiles,
+} from "../be/db";
+
+const TEST_DB_PATH = `./test-skill-files-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+describe("skill_files storage", () => {
+  let skillId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+  });
+
+  beforeEach(() => {
+    getDb().run("DELETE FROM skill_files");
+    getDb().run("DELETE FROM skills");
+    const skill = createSkill({
+      name: `file-skill-${crypto.randomUUID()}`,
+      description: "Skill with bundled files",
+      content: "---\nname: file-skill\ndescription: Skill with bundled files\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      isComplex: true,
+    });
+    skillId = skill.id;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("migration creates skill_files on a fresh DB", () => {
+    const table = getDb()
+      .prepare<{ name: string }, []>(
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'skill_files'",
+      )
+      .get();
+    expect(table?.name).toBe("skill_files");
+
+    const migration = getDb()
+      .prepare<{ version: number; name: string }, []>(
+        "SELECT version, name FROM _migrations WHERE version = 87",
+      )
+      .get();
+    expect(migration?.name).toBe("087_skill_files");
+  });
+
+  test("re-opening an existing DB keeps skill_files available", () => {
+    closeDb();
+    initDb(TEST_DB_PATH);
+
+    const columns = getDb().prepare<{ name: string }, []>("PRAGMA table_info(skill_files)").all();
+    expect(columns.map((column) => column.name)).toEqual([
+      "id",
+      "skillId",
+      "path",
+      "content",
+      "mimeType",
+      "isBinary",
+      "size",
+      "createdAt",
+      "lastUpdatedAt",
+      "created_by",
+      "updated_by",
+    ]);
+  });
+
+  test("upserts, lists manifest without content, fetches, and deletes files", () => {
+    const beforeVersion = getDb()
+      .prepare<{ version: number }, [string]>("SELECT version FROM skills WHERE id = ?")
+      .get(skillId)!.version;
+
+    const file = upsertSkillFile(skillId, {
+      path: "references/guide.md",
+      content: "# Guide",
+      mimeType: "text/markdown",
+    });
+    expect(file.path).toBe("references/guide.md");
+    expect(file.size).toBe(Buffer.byteLength("# Guide"));
+
+    const manifest = listSkillFileManifest(skillId);
+    expect(manifest).toHaveLength(1);
+    expect(manifest[0]).not.toHaveProperty("content");
+
+    expect(getSkillFile(skillId, "references/guide.md")?.content).toBe("# Guide");
+
+    const afterVersion = getDb()
+      .prepare<{ version: number }, [string]>("SELECT version FROM skills WHERE id = ?")
+      .get(skillId)!.version;
+    expect(afterVersion).toBeGreaterThan(beforeVersion);
+
+    expect(deleteSkillFile(skillId, "references/guide.md")).toBe(true);
+    expect(getSkillFile(skillId, "references/guide.md")).toBeNull();
+  });
+
+  test("bulk upsert enforces path normalization and stores binary placeholders", () => {
+    const files = upsertSkillFiles(skillId, [
+      {
+        path: "references//nested.md",
+        content: "nested",
+      },
+      {
+        path: "assets/logo.png",
+        content: "",
+        mimeType: "image/png",
+        isBinary: true,
+        size: 1234,
+      },
+    ]);
+
+    expect(files.map((file) => file.path)).toEqual(["references/nested.md", "assets/logo.png"]);
+    const binary = getSkillFile(skillId, "assets/logo.png");
+    expect(binary?.isBinary).toBe(true);
+    expect(binary?.content).toBe("[binary file - not synced]");
+  });
+
+  test("rejects traversal and SKILL.md rows", () => {
+    expect(() => normalizeSkillFilePath("../secret.md")).toThrow("traversal");
+    expect(() =>
+      upsertSkillFile(skillId, {
+        path: "SKILL.md",
+        content: "nope",
+      }),
+    ).toThrow("SKILL.md");
+  });
+
+  test("deleting a skill cascades bundled files", () => {
+    const skill = createSkill({
+      name: "cascade-file-skill",
+      description: "Cascade test",
+      content: "---\nname: cascade-file-skill\ndescription: Cascade test\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      isComplex: true,
+    });
+    upsertSkillFile(skill.id, { path: "references/a.md", content: "a" });
+
+    expect(listSkillFileManifest(skill.id)).toHaveLength(1);
+    expect(deleteSkill(skill.id)).toBe(true);
+    expect(listSkillFileManifest(skill.id)).toHaveLength(0);
+  });
+});

package/src/tests/skill-get-file-tool.test.ts

@@ -0,0 +1,110 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { closeDb, createSkill, initDb, upsertSkillFile } from "../be/db";
+import { registerSkillGetFileTool } from "../tools/skills/skill-get-file";
+
+const TEST_DB_PATH = `./test-skill-get-file-tool-${process.pid}.sqlite`;
+const CALLER_AGENT_ID = "bbbb0000-0000-4000-8000-000000000020";
+
+type StructuredContent = {
+  yourAgentId?: string;
+  success: boolean;
+  message: string;
+  file?: { skillId: string; path: string; content: string };
+};
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+async function callSkillGetFile(
+  server: McpServer,
+  args: Record<string, unknown>,
+): Promise<{
+  structuredContent: StructuredContent;
+  content: Array<{ type: string; text: string }>;
+}> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
+  const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
+    ._registeredTools;
+  const handler = tools["skill-get-file"].handler;
+
+  const result = await handler(args, {
+    sessionId: "test-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": CALLER_AGENT_ID,
+      },
+    },
+  });
+  return result as {
+    structuredContent: StructuredContent;
+    content: Array<{ type: string; text: string }>;
+  };
+}
+
+describe("skill-get-file tool", () => {
+  let server: McpServer;
+  let skillId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+
+    server = new McpServer({ name: "skill-get-file-test", version: "1.0.0" });
+    registerSkillGetFileTool(server);
+
+    const skill = createSkill({
+      name: "tool-file-skill",
+      description: "Tool file skill",
+      content: "---\nname: tool-file-skill\ndescription: Tool file skill\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      isComplex: true,
+    });
+    skillId = skill.id;
+    upsertSkillFile(skill.id, {
+      path: "references/guide.md",
+      content: "# Guide",
+      mimeType: "text/markdown",
+    });
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("fetches a bundled skill file by skillId and path", async () => {
+    const result = await callSkillGetFile(server, {
+      skillId,
+      path: "references/guide.md",
+    });
+
+    expect(result.structuredContent).toMatchObject({
+      yourAgentId: CALLER_AGENT_ID,
+      success: true,
+      file: {
+        skillId,
+        path: "references/guide.md",
+        content: "# Guide",
+      },
+    });
+    expect(result.content[0].text).toContain("# Guide");
+  });
+
+  test("returns structured failure for missing file", async () => {
+    const result = await callSkillGetFile(server, {
+      skillId,
+      path: "references/missing.md",
+    });
+
+    expect(result.structuredContent).toMatchObject({
+      success: false,
+      message: "Skill file not found.",
+    });
+  });
+});

package/src/tests/skill-sync.test.ts

@@ -2,8 +2,8 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { closeDb, createAgent, createSkill, initDb, installSkill } from "../be/db";
+import { dirname, join } from "node:path";
+import { closeDb, createAgent, createSkill, initDb, installSkill, upsertSkillFile } from "../be/db";
 import { syncSkillsToFilesystem } from "../be/skill-sync";
 
 const SWARM_MARKER = ".swarm-managed";
@@ -38,7 +38,7 @@ describe("syncSkillsToFilesystem", () => {
     });
     installSkill(agentId, skill.id);
 
-    // Create a complex skill (should be skipped)
+    // Create a legacy complex skill with no stored files (should be skipped)
     const complexSkill = createSkill({
       name: "complex-skill",
       description: "A complex skill",
@@ -49,6 +49,28 @@ describe("syncSkillsToFilesystem", () => {
     });
     installSkill(agentId, complexSkill.id);
 
+    const dbBackedComplexSkill = createSkill({
+      name: "complex-db-skill",
+      description: "A DB-backed complex skill",
+      content: "---\nname: complex-db-skill\ndescription: A DB-backed complex skill\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, dbBackedComplexSkill.id);
+    upsertSkillFile(dbBackedComplexSkill.id, {
+      path: "references/guide.md",
+      content: "# Guide\n\nBundled reference.",
+      mimeType: "text/markdown",
+    });
+    upsertSkillFile(dbBackedComplexSkill.id, {
+      path: "assets/logo.png",
+      content: "[binary file - not synced]",
+      mimeType: "image/png",
+      isBinary: true,
+      size: 2048,
+    });
+
     mkdirSync(FAKE_HOME, { recursive: true });
   });
 
@@ -108,7 +130,7 @@ describe("syncSkillsToFilesystem", () => {
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBe(3); // 1 skill × 3 dirs
+    expect(result.synced).toBe(6); // 2 DB-backed skills × 3 dirs
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");
@@ -118,13 +140,110 @@ describe("syncSkillsToFilesystem", () => {
     expect(existsSync(codexFile)).toBe(true);
   });
 
-  test("skips complex skills", () => {
+  test("syncs DB-backed complex skill files and skips binary placeholders", () => {
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors).toHaveLength(0);
+
+    const skillFile = join(FAKE_HOME, ".claude", "skills", "complex-db-skill", "SKILL.md");
+    const bundledFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-db-skill",
+      "references",
+      "guide.md",
+    );
+    const binaryFile = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-db-skill",
+      "assets",
+      "logo.png",
+    );
+    expect(existsSync(skillFile)).toBe(true);
+    expect(readFileSync(bundledFile, "utf-8")).toContain("Bundled reference.");
+    expect(existsSync(binaryFile)).toBe(false);
+  });
+
+  test("removes stale bundled files from swarm-managed skill directories", () => {
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+    expect(result.errors).toHaveLength(0);
+
+    const skillDir = join(FAKE_HOME, ".claude", "skills", "complex-db-skill");
+    const staleFile = join(skillDir, "references", "old-guide.md");
+    const currentFile = join(skillDir, "references", "guide.md");
+    const staleBinary = join(skillDir, "assets", "logo.png");
+    mkdirSync(dirname(staleFile), { recursive: true });
+    mkdirSync(dirname(staleBinary), { recursive: true });
+    writeFileSync(staleFile, "stale");
+    writeFileSync(staleBinary, "previous binary payload");
+
+    const nextResult = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(nextResult.errors).toHaveLength(0);
+    expect(nextResult.removed).toBeGreaterThanOrEqual(2);
+    expect(existsSync(staleFile)).toBe(false);
+    expect(existsSync(staleBinary)).toBe(false);
+    expect(readFileSync(currentFile, "utf-8")).toContain("Bundled reference.");
+  });
+
+  test("skips legacy complex skills without stored files", () => {
     const _result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
 
     const complexDir = join(FAKE_HOME, ".claude", "skills", "complex-skill");
     expect(existsSync(complexDir)).toBe(false);
   });
 
+  test("continues syncing bundled files after one file write fails", () => {
+    const failSkill = createSkill({
+      name: "complex-fail-safe",
+      description: "Complex skill with one blocked file",
+      content:
+        "---\nname: complex-fail-safe\ndescription: Complex skill with one blocked file\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+    });
+    installSkill(agentId, failSkill.id);
+    upsertSkillFile(failSkill.id, {
+      path: "references/blocked.md",
+      content: "blocked",
+    });
+    upsertSkillFile(failSkill.id, {
+      path: "references/ok.md",
+      content: "ok",
+    });
+
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+    const blockedTarget = join(
+      FAKE_HOME,
+      ".claude",
+      "skills",
+      "complex-fail-safe",
+      "references",
+      "blocked.md",
+    );
+    mkdirSync(blockedTarget, { recursive: true });
+
+    const result = syncSkillsToFilesystem(agentId, "claude", FAKE_HOME);
+
+    expect(result.errors.some((error) => error.includes("references/blocked.md"))).toBe(true);
+    expect(
+      readFileSync(
+        join(FAKE_HOME, ".claude", "skills", "complex-fail-safe", "references", "ok.md"),
+        "utf-8",
+      ),
+    ).toBe("ok");
+
+    rmSync(join(FAKE_HOME, ".claude"), { recursive: true, force: true });
+  });
+
   test("removes stale swarm-managed skill directories", () => {
     // Mark this stale dir as swarm-managed (mirrors what an earlier sync would have done)
     const staleDir = join(FAKE_HOME, ".claude", "skills", "old-removed-skill");
@@ -185,7 +304,7 @@ describe("syncSkillsToFilesystem", () => {
     const result = syncSkillsToFilesystem(agentId, "all", FAKE_HOME);
 
     expect(result.errors).toHaveLength(0);
-    expect(result.synced).toBe(3);
+    expect(result.synced).toBeGreaterThanOrEqual(6);
 
     const claudeFile = join(FAKE_HOME, ".claude", "skills", "test-skill", "SKILL.md");
     const piFile = join(FAKE_HOME, ".pi", "agent", "skills", "test-skill", "SKILL.md");

package/src/tests/slack-message-text.test.ts

@@ -0,0 +1,250 @@
+import { describe, expect, test } from "bun:test";
+import { extractSlackMessageText } from "../slack/message-text";
+
+describe("extractSlackMessageText", () => {
+  test("returns top-level text when present", () => {
+    expect(extractSlackMessageText({ text: "hello world" })).toBe("hello world");
+  });
+
+  test("returns empty string when all fields are absent", () => {
+    expect(extractSlackMessageText({})).toBe("");
+  });
+
+  test("returns empty string when text is empty and no attachments/blocks", () => {
+    expect(extractSlackMessageText({ text: "" })).toBe("");
+    expect(extractSlackMessageText({ text: "   " })).toBe("");
+  });
+
+  describe("legacy attachments fallback (Datadog / PagerDuty / GitHub alert shape)", () => {
+    test("uses fallback when text is empty", () => {
+      const msg = {
+        text: "",
+        attachments: [{ fallback: "Triggered: [P3] A Bull job process-inscribe-webhook failed" }],
+      };
+      expect(extractSlackMessageText(msg)).toBe(
+        "Triggered: [P3] A Bull job process-inscribe-webhook failed",
+      );
+    });
+
+    test("uses attachment text when fallback is absent", () => {
+      const msg = {
+        text: "",
+        attachments: [{ text: "Job failed in queue document_fraud_check" }],
+      };
+      expect(extractSlackMessageText(msg)).toBe("Job failed in queue document_fraud_check");
+    });
+
+    test("uses attachment title as tertiary fallback", () => {
+      const msg = { text: "", attachments: [{ title: "Alert Title" }] };
+      expect(extractSlackMessageText(msg)).toBe("Alert Title");
+    });
+
+    test("uses pretext as last attachment fallback", () => {
+      const msg = { text: "", attachments: [{ pretext: "Some pretext" }] };
+      expect(extractSlackMessageText(msg)).toBe("Some pretext");
+    });
+
+    test("joins multiple attachment texts with newline", () => {
+      const msg = {
+        text: "",
+        attachments: [{ fallback: "Alert 1" }, { fallback: "Alert 2" }],
+      };
+      expect(extractSlackMessageText(msg)).toBe("Alert 1\nAlert 2");
+    });
+
+    test("skips empty attachments, uses non-empty ones", () => {
+      const msg = {
+        text: "",
+        attachments: [{}, { fallback: "real content" }, {}],
+      };
+      expect(extractSlackMessageText(msg)).toBe("real content");
+    });
+
+    test("top-level text wins over attachments", () => {
+      const msg = { text: "top text", attachments: [{ fallback: "ignored" }] };
+      expect(extractSlackMessageText(msg)).toBe("top text");
+    });
+  });
+
+  describe("Block Kit blocks fallback", () => {
+    test("extracts text from a section block", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          { type: "section", text: { type: "mrkdwn", text: "*Alert*: CPU spike detected" } },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("*Alert*: CPU spike detected");
+    });
+
+    test("extracts text from section.fields when section has no top-level text", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          {
+            type: "section",
+            fields: [
+              { type: "mrkdwn", text: "*Status:* resolved" },
+              { type: "mrkdwn", text: "*Priority:* P2" },
+            ],
+          },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("*Status:* resolved\n*Priority:* P2");
+    });
+
+    test("extracts text from rich_text block elements", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [
+              {
+                type: "rich_text_section",
+                elements: [{ type: "text", text: "Rich text content" }],
+              },
+            ],
+          },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("Rich text content");
+    });
+
+    test("extracts text from rich_text_list -> rich_text_section -> text (nested list)", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [
+              {
+                type: "rich_text_list",
+                style: "bullet",
+                elements: [
+                  {
+                    type: "rich_text_section",
+                    elements: [{ type: "text", text: "item one" }],
+                  },
+                  {
+                    type: "rich_text_section",
+                    elements: [{ type: "text", text: "item two" }],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("item one\nitem two");
+    });
+
+    test("joins multiple section blocks with newline", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          { type: "section", text: { type: "plain_text", text: "Line 1" } },
+          { type: "section", text: { type: "plain_text", text: "Line 2" } },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("Line 1\nLine 2");
+    });
+
+    test("attachments take priority over blocks", () => {
+      const msg = {
+        text: "",
+        attachments: [{ fallback: "from attachment" }],
+        blocks: [{ type: "section", text: { type: "plain_text", text: "from block" } }],
+      };
+      expect(extractSlackMessageText(msg)).toBe("from attachment");
+    });
+
+    test("returns empty string when blocks have no extractable text", () => {
+      const msg = {
+        text: "",
+        blocks: [{ type: "divider" }, { type: "image" }],
+      };
+      expect(extractSlackMessageText(msg)).toBe("");
+    });
+  });
+
+  describe("malformed input — never throws", () => {
+    test("blocks: [null] — skips null entry, returns empty string", () => {
+      expect(() => extractSlackMessageText({ text: "", blocks: [null] } as any)).not.toThrow();
+      expect(extractSlackMessageText({ text: "", blocks: [null] } as any)).toBe("");
+    });
+
+    test("attachments: [null] — skips null entry, returns empty string", () => {
+      expect(() => extractSlackMessageText({ text: "", attachments: [null] } as any)).not.toThrow();
+      expect(extractSlackMessageText({ text: "", attachments: [null] } as any)).toBe("");
+    });
+
+    test("attachments: 'oops' (non-array) — returns empty string without throwing", () => {
+      expect(() => extractSlackMessageText({ text: "", attachments: "oops" } as any)).not.toThrow();
+      expect(extractSlackMessageText({ text: "", attachments: "oops" } as any)).toBe("");
+    });
+
+    test("blocks: 'x' (non-array) — returns empty string without throwing", () => {
+      expect(() => extractSlackMessageText({ text: "", blocks: "x" } as any)).not.toThrow();
+      expect(extractSlackMessageText({ text: "", blocks: "x" } as any)).toBe("");
+    });
+
+    test("blocks: [null, { type: 'section', text: { text: 'ok' } }] — skips null, returns valid text", () => {
+      const msg = {
+        text: "",
+        blocks: [null, { type: "section", text: { type: "plain_text", text: "ok" } }],
+      } as any;
+      expect(() => extractSlackMessageText(msg)).not.toThrow();
+      expect(extractSlackMessageText(msg)).toBe("ok");
+    });
+
+    test("rich_text block with null element in elements array — skips null inner", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [
+              null,
+              { type: "rich_text_section", elements: [{ type: "text", text: "hi" }] },
+            ],
+          },
+        ],
+      } as any;
+      expect(() => extractSlackMessageText(msg)).not.toThrow();
+      expect(extractSlackMessageText(msg)).toBe("hi");
+    });
+
+    test("rich_text block where elements is not an array — skips block", () => {
+      const msg = {
+        text: "",
+        blocks: [{ type: "rich_text", elements: "not-an-array" }],
+      } as any;
+      expect(() => extractSlackMessageText(msg)).not.toThrow();
+      expect(extractSlackMessageText(msg)).toBe("");
+    });
+
+    test("rich_text inner elements non-array — skips safely", () => {
+      const msg = {
+        text: "",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [{ type: "rich_text_section", elements: "oops" }],
+          },
+        ],
+      } as any;
+      expect(() => extractSlackMessageText(msg)).not.toThrow();
+      expect(extractSlackMessageText(msg)).toBe("");
+    });
+
+    test("attachments mixed null and valid entries — returns valid text only", () => {
+      const msg = {
+        text: "",
+        attachments: [null, { fallback: "real" }, null],
+      } as any;
+      expect(() => extractSlackMessageText(msg)).not.toThrow();
+      expect(extractSlackMessageText(msg)).toBe("real");
+    });
+  });
+});