@desplega.ai/agent-swarm 1.91.0 → 1.92.1

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

@@ -8,6 +8,11 @@ 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 bootTriage from "../be/seed-scripts/catalog/boot-triage";
+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 +53,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 14 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(14);
+  test("manifest holds 17 unique, well-described scripts", () => {
+    expect(SEED_SCRIPTS.length).toBe(18);
     const names = SEED_SCRIPTS.map((s) => s.name);
     expect(new Set(names).size).toBe(names.length);
     for (const s of SEED_SCRIPTS) {
@@ -92,7 +97,9 @@ describe("seed-scripts catalog", () => {
   test("scriptsSeeder seeds the whole catalog at global scope", async () => {
     const result = await runSeeder(scriptsSeeder, { quiet: true });
     expect(result.failed).toEqual([]);
-    expect(result.created).toBe(SEED_SCRIPTS.length);
+    expect(
+      result.created + result.updated + result.skippedUnchanged + result.skippedUserModified,
+    ).toBe(SEED_SCRIPTS.length);
 
     const globals = listScripts({ scope: "global" });
     for (const s of SEED_SCRIPTS) {
@@ -143,6 +150,464 @@ 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,
+        publishPage: 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>");
+  });
+
+  test("boot-triage returns one read-only post-restart snapshot", async () => {
+    const queries: Array<{ sql: string; params?: unknown[] }> = [];
+    const result: any = await bootTriage(
+      { nowIso: "2026-06-05T10:15:00.000Z", repo: "owner/repo" },
+      {
+        stdlib: {
+          fetch: async () =>
+            new Response(
+              JSON.stringify([
+                {
+                  number: 669,
+                  title: "release: v1.92.0",
+                  html_url: "https://github.com/desplega-ai/agent-swarm/pull/669",
+                  merged_at: "2026-06-05T10:08:00.000Z",
+                },
+              ]),
+              { status: 200 },
+            ),
+        },
+        swarm: {
+          db_query: async (args: { sql: string; params?: unknown[] }) => {
+            queries.push(args);
+            if (args.sql.includes("t.status = 'failed'")) {
+              return {
+                columns: [
+                  "id",
+                  "task",
+                  "status",
+                  "taskType",
+                  "agentId",
+                  "agentName",
+                  "scheduleId",
+                  "parentTaskId",
+                  "failureReason",
+                  "createdAt",
+                  "lastUpdatedAt",
+                ],
+                rows: [
+                  [
+                    "failed-real",
+                    "Investigate deploy",
+                    "failed",
+                    "feature",
+                    "agent-1",
+                    "Worker",
+                    null,
+                    null,
+                    "Typecheck failed",
+                    "2026-06-05T10:00:00.000Z",
+                    "2026-06-05T10:02:00.000Z",
+                  ],
+                  [
+                    "failed-benign",
+                    "Superseded task",
+                    "failed",
+                    "task",
+                    "agent-1",
+                    "Worker",
+                    null,
+                    null,
+                    "cancelled",
+                    "2026-06-05T10:00:00.000Z",
+                    "2026-06-05T10:02:00.000Z",
+                  ],
+                ],
+              };
+            }
+            if (args.sql.includes("t.status = 'in_progress'")) {
+              return {
+                columns: [
+                  "id",
+                  "task",
+                  "status",
+                  "taskType",
+                  "agentId",
+                  "agentName",
+                  "scheduleId",
+                  "parentTaskId",
+                  "failureReason",
+                  "createdAt",
+                  "lastUpdatedAt",
+                ],
+                rows: [
+                  [
+                    "stuck-1",
+                    "Stuck work",
+                    "in_progress",
+                    "feature",
+                    "agent-offline",
+                    "Offline",
+                    null,
+                    null,
+                    null,
+                    "2026-06-05T10:00:00.000Z",
+                    "2026-06-05T10:01:00.000Z",
+                  ],
+                ],
+              };
+            }
+            return { columns: [], rows: [] };
+          },
+        },
+      },
+    );
+
+    expect(queries.length).toBe(4);
+    expect(result.deployRestartDetection.mergedPrsWithinWindow).toHaveLength(1);
+    expect(result.recentlyFailedTasks.map((task: any) => task.id)).toEqual(["failed-real"]);
+    expect(result.stuckInProgressOnOfflineAgents.map((task: any) => task.id)).toEqual(["stuck-1"]);
+    expect(result.summary).toMatchObject({
+      mergedPrsWithinWindow: 1,
+      recentlyFailedTasks: 1,
+      stuckInProgressOnOfflineAgents: 1,
+    });
+  });
 });
 
 /**

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

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { closeDb, createSkill, getDb, initDb } from "../be/db";
+import { handleSkills } from "../http/skills";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB_PATH = `./test-skill-files-http-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+type TestResponse = {
+  status: number;
+  text: string;
+  json: () => Promise<unknown>;
+};
+
+async function dispatch(path: string, init: RequestInit = {}): Promise<TestResponse> {
+  const req = Readable.from(init.body ? [Buffer.from(String(init.body))] : []) as IncomingMessage;
+  req.method = init.method ?? "GET";
+  req.url = path;
+  req.headers = { "content-type": "application/json" };
+
+  let status = 200;
+  let text = "";
+  const res = {
+    headersSent: false,
+    writableEnded: false,
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+      this.headersSent = true;
+      return this;
+    },
+    end(chunk?: unknown) {
+      if (chunk !== undefined) text += String(chunk);
+      this.writableEnded = true;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  const pathSegments = getPathSegments(req.url || "");
+  const queryParams = parseQueryParams(req.url || "");
+  if (!(await handleSkills(req, res, pathSegments, queryParams, undefined))) {
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+
+  return {
+    status,
+    text,
+    json: async () => JSON.parse(text),
+  };
+}
+
+describe("/api/skills/:id/files", () => {
+  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: `http-file-skill-${crypto.randomUUID()}`,
+      description: "HTTP file skill",
+      content: "---\nname: http-file-skill\ndescription: HTTP file skill\n---\n\nBody.",
+      type: "personal",
+      scope: "agent",
+      isComplex: true,
+    });
+    skillId = skill.id;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("POST bulk upserts files and GET manifest omits content", async () => {
+    const post = await dispatch(`/api/skills/${skillId}/files`, {
+      method: "POST",
+      body: JSON.stringify({
+        files: [
+          { path: "references/guide.md", content: "# Guide", mimeType: "text/markdown" },
+          { path: "scripts/setup.sh", content: "echo ok", mimeType: "text/x-shellscript" },
+        ],
+      }),
+    });
+    expect(post.status).toBe(200);
+    expect((await post.json()) as { total: number }).toMatchObject({ total: 2 });
+
+    const list = await dispatch(`/api/skills/${skillId}/files`);
+    const body = (await list.json()) as { files: Array<Record<string, unknown>>; total: number };
+    expect(body.total).toBe(2);
+    expect(body.files[0]).not.toHaveProperty("content");
+  });
+
+  test("GET, PUT, and DELETE a nested file path", async () => {
+    const put = await dispatch(`/api/skills/${skillId}/files/references/deep/guide.md`, {
+      method: "PUT",
+      body: JSON.stringify({ content: "deep guide", mimeType: "text/markdown" }),
+    });
+    expect(put.status).toBe(200);
+
+    const get = await dispatch(`/api/skills/${skillId}/files/references/deep/guide.md`);
+    const got = (await get.json()) as { file: { path: string; content: string } };
+    expect(got.file).toMatchObject({
+      path: "references/deep/guide.md",
+      content: "deep guide",
+    });
+
+    const del = await dispatch(`/api/skills/${skillId}/files/references/deep/guide.md`, {
+      method: "DELETE",
+    });
+    expect(del.status).toBe(200);
+
+    const missing = await dispatch(`/api/skills/${skillId}/files/references/deep/guide.md`);
+    expect(missing.status).toBe(404);
+  });
+
+  test("rejects invalid paths and unknown skills", async () => {
+    const traversal = await dispatch(`/api/skills/${skillId}/files/references/../secret.md`, {
+      method: "PUT",
+      body: JSON.stringify({ content: "nope" }),
+    });
+    expect(traversal.status).toBe(400);
+
+    const missingSkill = await dispatch(`/api/skills/no-such-skill/files/references/a.md`);
+    expect(missingSkill.status).toBe(404);
+  });
+
+  test("rejects file mutations for system-managed skills", async () => {
+    const systemSkill = createSkill({
+      name: `system-file-skill-${crypto.randomUUID()}`,
+      description: "System file skill",
+      content: "---\nname: system-file-skill\ndescription: System file skill\n---\n\nBody.",
+      type: "remote",
+      scope: "global",
+      isComplex: true,
+      systemDefault: true,
+    });
+
+    const post = await dispatch(`/api/skills/${systemSkill.id}/files`, {
+      method: "POST",
+      body: JSON.stringify({
+        files: [{ path: "references/guide.md", content: "# Guide" }],
+      }),
+    });
+    expect(post.status).toBe(403);
+
+    const put = await dispatch(`/api/skills/${systemSkill.id}/files/references/guide.md`, {
+      method: "PUT",
+      body: JSON.stringify({ content: "# Guide" }),
+    });
+    expect(put.status).toBe(403);
+
+    const del = await dispatch(`/api/skills/${systemSkill.id}/files/references/guide.md`, {
+      method: "DELETE",
+    });
+    expect(del.status).toBe(403);
+  });
+});