@desplega.ai/agent-swarm 1.90.0 → 1.92.0

package/src/tests/seed-scripts.test.ts

@@ -8,6 +8,10 @@ import { setScriptEmbeddingProviderForTests } from "../be/scripts/embeddings";
 import { typecheckScript } from "../be/scripts/typecheck";
 import { runSeeder } from "../be/seed";
 import { SEED_SCRIPTS, scriptsSeeder } from "../be/seed-scripts";
+import compoundInsights from "../be/seed-scripts/catalog/compound-insights";
+import opsCatalogAudit, {
+  renderPage as renderOpsCatalogAuditPage,
+} from "../be/seed-scripts/catalog/ops-catalog-audit";
 import { extractScriptSignature } from "../scripts-runtime/extract-signature";
 import { validateScriptImports } from "../scripts-runtime/import-allowlist";
 
@@ -48,8 +52,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 10 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(10);
+  test("manifest holds 16 unique, well-described scripts", () => {
+    expect(SEED_SCRIPTS.length).toBe(16);
     const names = SEED_SCRIPTS.map((s) => s.name);
     expect(new Set(names).size).toBe(names.length);
     for (const s of SEED_SCRIPTS) {
@@ -143,6 +147,347 @@ describe("seed-scripts catalog", () => {
     const row = getScript({ name: target.name, scope: "global" });
     expect(row?.source).toBe(userSource);
   });
+
+  test("compound-insights decodes numeric-key SQLite blob objects for similarity checks", async () => {
+    function encodedVector(values: number[]): Record<string, number> {
+      const bytes = new Uint8Array(new Float32Array(values).buffer);
+      return Object.fromEntries(Array.from(bytes.entries()).map(([i, byte]) => [String(i), byte]));
+    }
+
+    const queries: string[] = [];
+    const ctx = {
+      swarm: {
+        async db_query({ sql }: { sql: string }) {
+          queries.push(sql);
+          if (sql.includes("SELECT scope, source, count(*) as cnt")) {
+            return {
+              columns: ["scope", "source", "cnt", "zeroAccess"],
+              rows: [["agent", "session_summary", 2, 0]],
+            };
+          }
+          if (sql.includes("SELECT id, name, source, accessCount, embedding")) {
+            return {
+              columns: ["id", "name", "source", "accessCount", "embedding"],
+              rows: [
+                ["a", "first", "session_summary", 3, encodedVector([1, 0, 0, 0])],
+                ["b", "second", "task_completion", 2, encodedVector([0.9, 0.1, 0, 0])],
+              ],
+            };
+          }
+          if (sql.includes("SELECT source, count(*) as count")) {
+            return { columns: ["source", "count"], rows: [] };
+          }
+          return { columns: [], rows: [] };
+        },
+      },
+    };
+
+    const result = await compoundInsights(
+      {
+        days: 7,
+        includeToolUsage: false,
+        includeScheduleHealth: false,
+        includeScriptCandidates: false,
+        includeByAgent: false,
+      },
+      ctx,
+    );
+
+    expect(queries.some((sql) => sql.includes("embedding IS NOT NULL"))).toBe(true);
+    expect(result.memoryHealth.pollution.similarityCheck.sampledAutoSnapshots).toBe(2);
+    expect(result.memoryHealth.pollution.similarityCheck.strongestAutoSnapshotPair).toMatchObject({
+      a: { id: "a", name: "first", source: "session_summary" },
+      b: { id: "b", name: "second", source: "task_completion" },
+    });
+    expect(
+      result.memoryHealth.pollution.similarityCheck.strongestAutoSnapshotPair.similarity,
+    ).toBeGreaterThan(0.99);
+  });
+
+  test("ops-catalog-audit clusters schedule, workflow, and prompt findings by goal", async () => {
+    const queries: string[] = [];
+    const result = await opsCatalogAudit(
+      { nowIso: "2026-06-04T12:00:00.000Z", publishPage: false },
+      {
+        swarm: {
+          async db_query({ sql }: { sql: string }) {
+            queries.push(sql);
+            if (sql.includes("FROM scheduled_tasks")) {
+              return {
+                columns: [
+                  "id",
+                  "name",
+                  "description",
+                  "cronExpression",
+                  "intervalMs",
+                  "taskTemplate",
+                  "taskType",
+                  "tags",
+                  "priority",
+                  "targetAgentId",
+                  "enabled",
+                  "lastRunAt",
+                  "nextRunAt",
+                  "createdByAgentId",
+                  "timezone",
+                  "consecutiveErrors",
+                  "scheduleType",
+                  "targetAgentName",
+                  "targetAgentRole",
+                  "targetAgentDescription",
+                  "targetAgentCapabilities",
+                  "targetAgentProvider",
+                  "targetAgentHarnessProvider",
+                ],
+                rows: [
+                  [
+                    "sched-a",
+                    "repo-ci-audit",
+                    "",
+                    "0 * * * *",
+                    null,
+                    "Run gh pr checks and bun test in the repo",
+                    "feature",
+                    "[]",
+                    50,
+                    null,
+                    1,
+                    "2026-05-01T00:00:00.000Z",
+                    null,
+                    null,
+                    "UTC",
+                    0,
+                    "recurring",
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                    null,
+                  ],
+                  [
+                    "sched-b",
+                    "memory-gate-597",
+                    "temporary monitor until 2026-06-01",
+                    "0 * * * *",
+                    null,
+                    "Check memory gate",
+                    "monitor",
+                    "[]",
+                    50,
+                    "agent-ops",
+                    1,
+                    "2026-06-04T00:00:00.000Z",
+                    "2026-06-04T13:00:00.000Z",
+                    null,
+                    "UTC",
+                    0,
+                    "recurring",
+                    "Ops Reviewer",
+                    "ops",
+                    "operations reviewer",
+                    '["ops"]',
+                    "opencode",
+                    "opencode",
+                  ],
+                ],
+              };
+            }
+            if (sql.includes("FROM workflows")) {
+              return {
+                columns: [
+                  "id",
+                  "name",
+                  "description",
+                  "enabled",
+                  "definition",
+                  "triggers",
+                  "input",
+                  "triggerSchema",
+                  "createdAt",
+                  "lastUpdatedAt",
+                ],
+                rows: [
+                  [
+                    "wf-smoke",
+                    "gsc-runtime-smoke",
+                    "temporary smoke fixture",
+                    1,
+                    JSON.stringify({ nodes: [{ id: "a", type: "swarm-script" }] }),
+                    "[]",
+                    null,
+                    null,
+                    "2026-06-01T00:00:00.000Z",
+                    "2026-06-01T00:00:00.000Z",
+                  ],
+                  [
+                    "wf-gate",
+                    "content-litmus-gate",
+                    "quality gate",
+                    1,
+                    JSON.stringify({ nodes: [{ id: "judge", type: "raw-llm" }] }),
+                    "[]",
+                    null,
+                    null,
+                    "2026-06-01T00:00:00.000Z",
+                    "2026-06-01T00:00:00.000Z",
+                  ],
+                ],
+              };
+            }
+            if (sql.includes("FROM prompt_templates")) {
+              return {
+                columns: [
+                  "id",
+                  "eventType",
+                  "scope",
+                  "scopeId",
+                  "state",
+                  "body",
+                  "isDefault",
+                  "version",
+                  "createdBy",
+                  "updatedAt",
+                ],
+                rows: [
+                  [
+                    "prompt-a",
+                    "system.agent.role",
+                    "global",
+                    null,
+                    "enabled",
+                    "Use https://api.example-swarm.dev and do not browse. You must browse.",
+                    1,
+                    1,
+                    "system",
+                    "2026-06-01T00:00:00.000Z",
+                  ],
+                  [
+                    "prompt-b",
+                    "legacy.only",
+                    "global",
+                    null,
+                    "enabled",
+                    "Duplicate body",
+                    1,
+                    1,
+                    "system",
+                    "2026-06-01T00:00:00.000Z",
+                  ],
+                  [
+                    "prompt-c",
+                    "slack.assistant.greeting",
+                    "global",
+                    null,
+                    "enabled",
+                    "Duplicate body",
+                    1,
+                    1,
+                    "system",
+                    "2026-06-01T00:00:00.000Z",
+                  ],
+                ],
+              };
+            }
+            if (sql.includes("FROM skills")) {
+              return {
+                columns: ["name", "count", "locations"],
+                rows: [["pages", 2, "global:global, swarm:global"]],
+              };
+            }
+            return { columns: [], rows: [] };
+          },
+        },
+      },
+    );
+
+    const findingIds = (items: Array<{ id: string }>) => items.map((finding) => finding.id);
+
+    expect(queries.length).toBe(4);
+    expect(result.summary.findingsTotal).toBeGreaterThanOrEqual(8);
+    expect(findingIds(result.goals.schedules.findings)).toEqual(
+      expect.arrayContaining([
+        "schedules.duplicate-crons",
+        "schedules.dead-or-stale",
+        "schedules.temporary-self-lift",
+        "schedules.rule-13-15-routing",
+      ]),
+    );
+    expect(findingIds(result.goals.workflows.findings)).toEqual(
+      expect.arrayContaining(["workflows.enabled-fixtures", "workflows.structured-output-gaps"]),
+    );
+    expect(findingIds(result.goals.promptsTemplates.findings)).toEqual(
+      expect.arrayContaining([
+        "prompts.registry-drift",
+        "prompts.redundant-bodies",
+        "prompts.stale-urls-hosts",
+        "prompts.contradictory-instructions",
+        "prompts.system-default-skill-duplicates",
+      ]),
+    );
+  });
+
+  test("ops-catalog-audit renders a summary-first designed HTML report", () => {
+    const html = renderOpsCatalogAuditPage({
+      generatedAt: "2026-06-04T12:00:00.000Z",
+      summary: {
+        schedulesEnabled: 40,
+        workflowsTotal: 33,
+        workflowsEnabled: 28,
+        promptTemplates: 76,
+        findingsTotal: 2,
+      },
+      goals: {
+        schedules: {
+          goal: "Reduce schedule cost/context waste and prevent misrouted code work.",
+          findingCount: 1,
+          checks: { duplicateCronGroups: 1, routingRisks: 1 },
+          findings: [
+            {
+              id: "schedules.rule-13-15-routing",
+              severity: "critical",
+              summary: "1 enabled code-work schedule is not pinned to a code-capable worker.",
+              action: "Set targetAgentId to a code-capable worker.",
+              samples: [
+                { id: "sched-a", name: "repo-ci-audit", reason: "pool-targeted code work" },
+              ],
+            },
+          ],
+        },
+        workflows: {
+          goal: "Separate load-bearing workflows from fixtures and enforce deterministic gate outputs.",
+          findingCount: 0,
+          checks: { enabledFixtures: 0, structuredOutputGaps: 0 },
+          findings: [],
+        },
+        promptsTemplates: {
+          goal: "Keep prompt registry, runtime defaults, host guidance, and skill seed blocks aligned.",
+          findingCount: 1,
+          checks: { staleUrlPrompts: 1 },
+          findings: [
+            {
+              id: "prompts.stale-urls-hosts",
+              severity: "high",
+              summary: "1 prompt template contains stale/local/example hosts.",
+              action: "Replace hardcoded hosts with runtime env-var guidance.",
+              samples: [{ id: "prompt-a", eventType: "system.agent.role", match: "localhost" }],
+            },
+          ],
+        },
+      },
+    });
+
+    expect(html).toContain("<main>");
+    expect(html).toContain('class="metrics"');
+    expect(html).toContain("<strong>40</strong><span>Schedules enabled</span>");
+    expect(html).toContain("schedules.rule-13-15-routing");
+    expect(html).toContain('class="finding danger"');
+    expect(html).toContain("<details>");
+    expect(html).toContain("Compressed JSON appendix");
+    expect(html).toContain('<div class="sample-table"');
+    expect(html).toContain("@media (max-width: 860px)");
+    expect(html).not.toContain("<ul>");
+  });
 });
 
 /**

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");
+    });
+  });
+});

package/src/tests/system-default-skills.test.ts

@@ -37,8 +37,10 @@ describe("system-default skills", () => {
     const names = skills.map((skill) => skill.name);
 
     expect(names).toContain("attio-interaction");
+    expect(names).toContain("script-workflows");
     expect(names).toContain("swarm-scripts");
     expect(skills.find((skill) => skill.name === "attio-interaction")?.systemDefault).toBe(true);
+    expect(skills.find((skill) => skill.name === "script-workflows")?.systemDefault).toBe(true);
     expect(skills.find((skill) => skill.name === "swarm-scripts")?.systemDefault).toBe(true);
     expect(skills.find((skill) => skill.name === "kv-storage")?.systemDefault).toBe(true);
     expect(skills.find((skill) => skill.name === "pages")?.systemDefault).toBe(true);
@@ -48,6 +50,7 @@ describe("system-default skills", () => {
 
     const defaults = getSystemDefaultSkills().map((skill) => skill.name);
     expect(defaults).toContain("attio-interaction");
+    expect(defaults).toContain("script-workflows");
     expect(defaults).toContain("swarm-scripts");
     expect(defaults).toContain("kv-storage");
     expect(defaults).toContain("pages");
@@ -78,6 +81,43 @@ describe("system-default skills", () => {
     expect(skills.find((skill) => skill.id === manualDefault.id)?.isActive).toBe(true);
   });
 
+  test("existing agents see swarm-scope skills without explicit install rows", () => {
+    const existingAgent = createAgent({
+      name: "Existing Swarm Skill Worker",
+      description: "Created before a swarm-scope skill",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+
+    const swarmSkill = createSkill({
+      name: "manual-swarm-scope-skill",
+      description: "Manual swarm scope skill",
+      content:
+        "---\nname: manual-swarm-scope-skill\ndescription: Manual swarm scope skill\n---\nBody.",
+      type: "personal",
+      scope: "swarm",
+      systemDefault: false,
+    });
+
+    const installRow = getDb()
+      .prepare<{ count: number }, [string, string]>(
+        `SELECT COUNT(*) AS count
+         FROM agent_skills
+         WHERE agentId = ?
+           AND skillId = ?`,
+      )
+      .get(existingAgent.id, swarmSkill.id);
+
+    expect(installRow?.count ?? 0).toBe(0);
+
+    const skills = getAgentSkills(existingAgent.id);
+    expect(skills.map((skill) => skill.name)).toContain("manual-swarm-scope-skill");
+    expect(skills.find((skill) => skill.id === swarmSkill.id)?.isActive).toBe(true);
+  });
+
   test("new agents get concrete agent_skills rows for system defaults", () => {
     const beforeAgent = createAgent({
       name: "Concrete Install Worker",