@desplega.ai/agent-swarm 1.92.0 → 1.92.2

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

@@ -8,6 +8,7 @@ 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,
@@ -52,8 +53,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 16 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(16);
+  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) {
@@ -96,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) {
@@ -189,6 +192,7 @@ describe("seed-scripts catalog", () => {
         includeScheduleHealth: false,
         includeScriptCandidates: false,
         includeByAgent: false,
+        publishPage: false,
       },
       ctx,
     );
@@ -204,6 +208,211 @@ describe("seed-scripts catalog", () => {
     ).toBeGreaterThan(0.99);
   });
 
+  test("compound-insights reports script usage and cost honesty rails", async () => {
+    const queries: string[] = [];
+    const ctx = {
+      swarm: {
+        async db_query({ sql }: { sql: string }) {
+          queries.push(sql);
+          if (sql.includes("FROM script_runs sr")) {
+            return {
+              columns: ["scriptName", "kind", "status", "startedAt", "finishedAt", "durationMs"],
+              rows: [
+                [
+                  "compound-insights",
+                  "inline",
+                  "completed",
+                  "2026-06-08T00:00:00.000Z",
+                  "2026-06-08T00:00:01.000Z",
+                  1000,
+                ],
+                [
+                  "daily-dashboard",
+                  "workflow",
+                  "failed",
+                  "2026-06-08T01:00:00.000Z",
+                  "2026-06-08T01:00:03.000Z",
+                  3000,
+                ],
+              ],
+            };
+          }
+          if (sql.includes("FROM scripts") && sql.includes("GROUP BY scope, isScratch")) {
+            return {
+              columns: ["scope", "isScratch", "count"],
+              rows: [
+                ["global", 0, 2],
+                ["agent", 1, 1],
+              ],
+            };
+          }
+          if (sql.includes("FROM script_versions sv")) {
+            return {
+              columns: ["scope", "count"],
+              rows: [["global", 3]],
+            };
+          }
+          if (sql.includes("FROM session_logs") && sql.includes("%script-run%")) {
+            return {
+              columns: ["tool", "calls"],
+              rows: [["mcp__agent_swarm__script-run", 5]],
+            };
+          }
+          if (sql.includes("FROM session_costs sc")) {
+            return {
+              columns: [
+                "taskId",
+                "agentId",
+                "agentName",
+                "provider",
+                "totalCostUsd",
+                "inputTokens",
+                "outputTokens",
+                "cacheReadTokens",
+                "cacheWriteTokens",
+                "reasoningOutputTokens",
+                "thinkingTokens",
+                "numTurns",
+                "model",
+                "costSource",
+              ],
+              rows: [
+                [
+                  "task-a",
+                  "agent-a",
+                  "Picateclas",
+                  "codex",
+                  0.3,
+                  100,
+                  20,
+                  10,
+                  null,
+                  3,
+                  4,
+                  null,
+                  "gpt-5.5",
+                  "harness",
+                ],
+                [
+                  "task-b",
+                  "agent-a",
+                  "Picateclas",
+                  "codex",
+                  0.5,
+                  200,
+                  40,
+                  20,
+                  2,
+                  0,
+                  0,
+                  2,
+                  "gpt-5.5",
+                  "pricing-table",
+                ],
+                [
+                  "task-c",
+                  "agent-b",
+                  "Worker",
+                  "claude",
+                  9.9,
+                  300,
+                  60,
+                  30,
+                  3,
+                  0,
+                  0,
+                  3,
+                  "unknown",
+                  "unpriced",
+                ],
+                [
+                  null,
+                  "agent-a",
+                  "Picateclas",
+                  "codex",
+                  0.2,
+                  50,
+                  10,
+                  5,
+                  null,
+                  1,
+                  1,
+                  null,
+                  "gpt-5.5",
+                  "harness",
+                ],
+              ],
+            };
+          }
+          return { columns: [], rows: [] };
+        },
+      },
+    };
+
+    const result = await compoundInsights(
+      {
+        days: 7,
+        includeToolUsage: false,
+        includeScheduleHealth: false,
+        includeMemoryHealth: false,
+        includeScriptCandidates: false,
+        includeByAgent: false,
+        publishPage: false,
+      },
+      ctx,
+    );
+
+    expect(queries.some((sql) => sql.includes("FROM script_runs sr"))).toBe(true);
+    expect(queries.some((sql) => sql.includes("FROM session_costs sc"))).toBe(true);
+    expect(result.scriptUsage.runs).toMatchObject({
+      total: 2,
+      inline: 1,
+      workflow: 1,
+      completed: 1,
+      failed: 1,
+      successRate: 50,
+      durationP50Ms: 1000,
+      durationP95Ms: 3000,
+    });
+    expect(result.scriptUsage.creations).toMatchObject({
+      totalNonScratch: 2,
+      scratch: 1,
+      byScope: { global: 2 },
+    });
+    expect(result.scriptUsage.edits).toMatchObject({
+      total: 3,
+      byScope: { global: 3 },
+    });
+    expect(result.scriptUsage.mcpToolCalls).toEqual([
+      { tool: "mcp__agent_swarm__script-run", calls: 5 },
+    ]);
+    expect(result.costAndTokens).toMatchObject({
+      rows: 4,
+      taskCountForHeadlineAvg: 2,
+      avgCostPerTaskUsd: 0.4,
+      totalSpendUsd: 10.9,
+      trustedSpendUsd: 1,
+      trustedRows: 3,
+      trustedRowPercent: 75,
+      unpricedRows: 1,
+      unpricedSpendUsd: 9.9,
+      nonTaskSessionRows: 1,
+      nonTaskSessionSpendUsd: 0.2,
+      unknownCounts: {
+        cacheWriteTokens: 2,
+        numTurns: 2,
+      },
+    });
+    expect(result.costAndTokens.tokenTotals).toMatchObject({
+      inputTokens: 650,
+      outputTokens: 130,
+      cacheReadTokens: 65,
+      cacheWriteTokens: 5,
+      reasoningOutputTokens: 4,
+      thinkingTokens: 5,
+    });
+  });
+
   test("ops-catalog-audit clusters schedule, workflow, and prompt findings by goal", async () => {
     const queries: string[] = [];
     const result = await opsCatalogAudit(
@@ -488,6 +697,122 @@ describe("seed-scripts catalog", () => {
     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);
+  });
+});

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