@desplega.ai/agent-swarm 1.87.0 → 1.89.0

package/src/tests/runner-repo-autostash.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { ensureRepoForTask } from "../commands/runner";
+
+const execFileAsync = promisify(execFile);
+
+let tempRoot = "";
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["-C", cwd, ...args]);
+  return stdout;
+}
+
+async function gitRaw(args: string[]): Promise<void> {
+  await execFileAsync("git", args);
+}
+
+async function commitAll(cwd: string, message: string): Promise<void> {
+  await git(cwd, ["add", "."]);
+  await git(cwd, ["commit", "-m", message]);
+}
+
+async function configureIdentity(cwd: string): Promise<void> {
+  await git(cwd, ["config", "user.email", "test@example.com"]);
+  await git(cwd, ["config", "user.name", "Test User"]);
+}
+
+describe("ensureRepoForTask auto-stash refresh", () => {
+  beforeEach(async () => {
+    tempRoot = await mkdtemp(join(tmpdir(), "swarm-runner-autostash-"));
+  });
+
+  afterEach(async () => {
+    if (tempRoot) {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("stashes dirty work with a swarm-autostash name before refreshing from origin", async () => {
+    const remotePath = join(tempRoot, "remote.git");
+    const upstreamPath = join(tempRoot, "upstream");
+    const clonePath = join(tempRoot, "clone");
+
+    await gitRaw(["init", "--bare", remotePath]);
+    await mkdir(upstreamPath);
+    await git(upstreamPath, ["init", "-b", "main"]);
+    await configureIdentity(upstreamPath);
+    await writeFile(join(upstreamPath, "README.md"), "initial\n");
+    await commitAll(upstreamPath, "initial commit");
+    await git(upstreamPath, ["remote", "add", "origin", remotePath]);
+    await git(upstreamPath, ["push", "-u", "origin", "main"]);
+
+    await gitRaw(["clone", "--branch", "main", remotePath, clonePath]);
+    await configureIdentity(clonePath);
+    await writeFile(join(clonePath, "README.md"), "local dirty change\n");
+    await writeFile(join(clonePath, "untracked.txt"), "local untracked\n");
+
+    await writeFile(join(upstreamPath, "remote.txt"), "remote change\n");
+    await commitAll(upstreamPath, "remote update");
+    await git(upstreamPath, ["push", "origin", "main"]);
+
+    const result = await ensureRepoForTask(
+      { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+      "test",
+    );
+
+    expect(result.warning).toBeNull();
+    expect(result.autoStashes).toHaveLength(1);
+    expect(result.autoStashes[0]?.ref).toMatch(/^stash@\{\d+\}$/);
+    expect(result.autoStashes[0]?.message).toContain("swarm-autostash main ");
+    expect(await readFile(join(clonePath, "remote.txt"), "utf8")).toBe("remote change\n");
+    expect((await git(clonePath, ["status", "--porcelain"])).trim()).toBe("");
+
+    const stashList = await git(clonePath, ["stash", "list"]);
+    expect(stashList).toContain("swarm-autostash main ");
+    expect(stashList).toContain("On main:");
+  });
+
+  test("merges a clean divergent checkout with origin without hard reset", async () => {
+    const remotePath = join(tempRoot, "remote.git");
+    const upstreamPath = join(tempRoot, "upstream");
+    const clonePath = join(tempRoot, "clone");
+
+    await gitRaw(["init", "--bare", remotePath]);
+    await mkdir(upstreamPath);
+    await git(upstreamPath, ["init", "-b", "main"]);
+    await configureIdentity(upstreamPath);
+    await writeFile(join(upstreamPath, "README.md"), "initial\n");
+    await commitAll(upstreamPath, "initial commit");
+    await git(upstreamPath, ["remote", "add", "origin", remotePath]);
+    await git(upstreamPath, ["push", "-u", "origin", "main"]);
+
+    await gitRaw(["clone", "--branch", "main", remotePath, clonePath]);
+    await configureIdentity(clonePath);
+    await writeFile(join(clonePath, "local.txt"), "local commit\n");
+    await commitAll(clonePath, "local commit");
+
+    await writeFile(join(upstreamPath, "remote.txt"), "remote commit\n");
+    await commitAll(upstreamPath, "remote commit");
+    await git(upstreamPath, ["push", "origin", "main"]);
+
+    const result = await ensureRepoForTask(
+      { url: remotePath, name: "repo", clonePath, defaultBranch: "main" },
+      "test",
+    );
+
+    expect(result.warning).toBeNull();
+    expect(result.autoStashes).toEqual([]);
+    expect(await readFile(join(clonePath, "local.txt"), "utf8")).toBe("local commit\n");
+    expect(await readFile(join(clonePath, "remote.txt"), "utf8")).toBe("remote commit\n");
+    expect((await git(clonePath, ["status", "--porcelain"])).trim()).toBe("");
+  });
+});

package/src/tests/runner-requester-profile.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { buildRequesterProfilePrompt } from "../commands/runner";
+
+describe("runner requester profile prompt", () => {
+  test("omits requester profile when no role or notes are set", async () => {
+    await expect(
+      buildRequesterProfilePrompt({ name: "Taras", email: "t@example.com" }),
+    ).resolves.toBe("");
+  });
+
+  test("formats requester role and free-text notes", async () => {
+    const prompt = await buildRequesterProfilePrompt({
+      name: "Taras",
+      email: "t@example.com",
+      role: "CEO",
+      notes: "Lead with the answer; keep updates terse.",
+    });
+
+    expect(prompt).toContain("## Requester Profile");
+    expect(prompt).toContain("This task was requested by Taras (CEO).");
+    expect(prompt).toContain("Their stated notes for how you should respond and act:");
+    expect(prompt).toContain("Lead with the answer; keep updates terse.");
+    expect(prompt).toContain("where it doesn't conflict with correctness or your operating rules");
+  });
+});

package/src/tests/runner-skills-refresh.test.ts

@@ -83,7 +83,7 @@ describe("refreshSkillsIfChanged", () => {
   function makeCtx(): SkillsRefreshContext {
     return {
       apiUrl: baseUrl,
-      swarmUrl: baseUrl,
+      swarmUrl: "app.agent-swarm.dev",
       apiKey: "test-key",
       agentId: "agent-1",
       role: "worker",

package/src/tests/self-improvement.test.ts

@@ -10,6 +10,11 @@ import {
   initDb,
 } from "../be/db";
 import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
+import {
+  isAutomaticOrRecurringTaskCompletion,
+  isScheduledTaskCompletion,
+  shouldPersistTaskCompletionMemory,
+} from "../memory/automatic-task-gate";
 import { getBasePrompt } from "../prompts/base-prompt";
 
 const TEST_DB_PATH = "./test-self-improvement.sqlite";
@@ -143,6 +148,90 @@ describe("Self-Improvement Mechanisms", () => {
       expect(shortContent.length).toBeLessThan(30);
       // In store-progress, this would return early without creating memory
     });
+
+    test("manual task completions persist memory by default", () => {
+      const task = createTaskExtended("Manual implementation task", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 50,
+        tags: ["memory", "bug-fix"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(false);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(true);
+    });
+
+    test("scheduled task completions skip memory by default", () => {
+      const task = createTaskExtended("Run heartbeat checklist", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:heartbeat-checklist"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(true);
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("heartbeat checklist completions skip memory without schedule tags", () => {
+      const task = createTaskExtended("Run heartbeat checklist", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 60,
+        taskType: "heartbeat-checklist",
+        tags: ["checklist", "auto-generated"],
+      });
+
+      expect(isScheduledTaskCompletion(task)).toBe(false);
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("boot triage completions skip memory by default", () => {
+      const task = createTaskExtended("Triage reboot-interrupted work", {
+        agentId: workerId,
+        source: "mcp",
+        priority: 80,
+        taskType: "boot-triage",
+        tags: ["boot", "triage", "auto-generated"],
+      });
+
+      expect(isAutomaticOrRecurringTaskCompletion(task)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(task)).toBe(false);
+    });
+
+    test("monitor and digest completions skip memory by default", () => {
+      const monitorTask = createTaskExtended("Check Claude Code changelog", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        taskType: "monitoring",
+        tags: ["health", "schedule:claude-code-changelog-monitor"],
+      });
+      const digestTask = createTaskExtended("Compile daily blocker digest", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:daily-blocker-digest"],
+      });
+
+      expect(isAutomaticOrRecurringTaskCompletion(monitorTask)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(monitorTask)).toBe(false);
+      expect(isAutomaticOrRecurringTaskCompletion(digestTask)).toBe(true);
+      expect(shouldPersistTaskCompletionMemory(digestTask)).toBe(false);
+    });
+
+    test("scheduled task completions can opt in to memory persistence", () => {
+      const task = createTaskExtended("Daily digest found reusable incident pattern", {
+        agentId: workerId,
+        source: "schedule",
+        priority: 50,
+        tags: ["scheduled", "schedule:daily-blocker-digest"],
+      });
+
+      expect(shouldPersistTaskCompletionMemory(task, true)).toBe(true);
+    });
   });
 
   // ==========================================================================

package/src/tests/skill-update-scope.test.ts

@@ -2,6 +2,7 @@ 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, createAgent, createSkill, getSkillById, initDb } from "../be/db";
+import { registerSkillDeleteTool } from "../tools/skills/skill-delete";
 import { registerSkillUpdateTool } from "../tools/skills/skill-update";
 
 const TEST_DB_PATH = "./test-skill-update-scope.sqlite";
@@ -39,7 +40,30 @@ async function callSkillUpdate(
   return result as { structuredContent: StructuredContent };
 }
 
-describe("skill-update scope promotion", () => {
+async function callSkillDelete(
+  server: McpServer,
+  callerAgentId: string | undefined,
+  args: Record<string, unknown>,
+): Promise<{ structuredContent: StructuredContent }> {
+  // 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-delete"].handler;
+
+  const extra = {
+    sessionId: "test-session",
+    requestInfo: {
+      headers: {
+        "x-agent-id": callerAgentId ?? "",
+      },
+    },
+  };
+
+  const result = await handler(args, extra);
+  return result as { structuredContent: StructuredContent };
+}
+
+describe("skill mutation tools", () => {
   let server: McpServer;
 
   beforeAll(async () => {
@@ -59,6 +83,7 @@ describe("skill-update scope promotion", () => {
 
     server = new McpServer({ name: "test-skill-update-scope", version: "1.0.0" });
     registerSkillUpdateTool(server);
+    registerSkillDeleteTool(server);
   });
 
   afterAll(async () => {
@@ -162,4 +187,66 @@ describe("skill-update scope promotion", () => {
     expect(stored?.scope).toBe("agent");
     expect(stored?.isEnabled).toBe(false);
   });
+
+  test("system-default skill content updates are rejected", async () => {
+    const skill = createSkill({
+      name: "system-content-locked",
+      description: "System content lock",
+      content: "---\nname: system-content-locked\ndescription: System content lock\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      content: "---\nname: system-content-locked\ndescription: Changed\n---\n\nChanged.",
+    });
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("system-managed");
+
+    const stored = getSkillById(skill.id);
+    expect(stored?.description).toBe("System content lock");
+    expect(stored?.version).toBe(1);
+  });
+
+  test("system-default skill enable toggle remains allowed", async () => {
+    const skill = createSkill({
+      name: "system-toggle-allowed",
+      description: "System toggle",
+      content: "---\nname: system-toggle-allowed\ndescription: System toggle\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillUpdate(server, LEAD_ID, {
+      skillId: skill.id,
+      isEnabled: false,
+    });
+
+    expect(result.structuredContent.success).toBe(true);
+    expect(getSkillById(skill.id)?.isEnabled).toBe(false);
+  });
+
+  test("system-default skill deletes are rejected", async () => {
+    const skill = createSkill({
+      name: "system-delete-locked",
+      description: "System delete lock",
+      content: "---\nname: system-delete-locked\ndescription: System delete lock\n---\n\nBody.",
+      type: "personal",
+      scope: "swarm",
+      ownerAgentId: WORKER_ID,
+      systemDefault: true,
+    });
+
+    const result = await callSkillDelete(server, LEAD_ID, { skillId: skill.id });
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toContain("system-managed");
+    expect(getSkillById(skill.id)).not.toBeNull();
+  });
 });

package/src/tests/slack-blocks.test.ts

@@ -821,6 +821,21 @@ describe("buildTreeBlocks", () => {
     expect(blocks.length).toBe(2);
   });
 
+  test("offered root shows offered icon without undefined text", () => {
+    const root: TreeNode = {
+      taskId: makeTaskId("loff0001"),
+      agentName: "OfferedAgent",
+      status: "offered",
+      children: [],
+    };
+
+    const blocks = buildTreeBlocks([root]);
+    const text = blocks[0].text.text;
+
+    expect(text).toContain("📨 *OfferedAgent*");
+    expect(text).not.toContain("undefined");
+  });
+
   test("cancelled root shows cancel icon with no cancel button", () => {
     const root: TreeNode = {
       taskId: makeTaskId("mmmm0001"),

package/src/tests/swarm-x-tool.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerSwarmXTool } from "../tools/swarm-x";
+import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
+
+type RegisteredTool = {
+  handler: (args: unknown, extra: unknown) => Promise<unknown>;
+};
+
+const originalFetch = globalThis.fetch;
+const originalComposioKey = process.env.COMPOSIO_API_KEY;
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function buildTool() {
+  const server = new McpServer({ name: "swarm-x-test", version: "1.0.0" });
+  registerSwarmXTool(server);
+  const registered = (server as unknown as { _registeredTools: Record<string, RegisteredTool> })
+    ._registeredTools;
+  const tool = registered.swarm_x;
+  if (!tool) throw new Error("swarm_x tool not registered");
+  return tool;
+}
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  if (originalComposioKey === undefined) delete process.env.COMPOSIO_API_KEY;
+  else process.env.COMPOSIO_API_KEY = originalComposioKey;
+  clearVolatileSecretsForTesting();
+});
+
+describe("swarm_x MCP tool", () => {
+  test("routes composio requests with server-side auth and scrubbed output", async () => {
+    process.env.COMPOSIO_API_KEY = "ck_tool_secret_value";
+    const fetchMock = mock(async (url: string | URL | Request, init?: RequestInit) => {
+      expect(String(url)).toBe("https://backend.composio.dev/api/v3.1/tools?limit=1");
+      expect(init?.method).toBe("GET");
+      expect((init?.headers as Record<string, string>)["x-api-key"]).toBe("ck_tool_secret_value");
+      return jsonResponse({ ok: true, token: "ck_tool_secret_value" });
+    });
+    globalThis.fetch = fetchMock;
+
+    const tool = buildTool();
+    const result = (await tool.handler(
+      {
+        target: "composio",
+        method: "GET",
+        path: "/tools",
+        query: { limit: 1 },
+      },
+      { sessionId: "s", requestInfo: { headers: {} } },
+    )) as {
+      isError?: boolean;
+      structuredContent: { ok: boolean; response: unknown; responseText: string };
+    };
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(result.isError).toBe(false);
+    expect(result.structuredContent.ok).toBe(true);
+    expect(JSON.stringify(result.structuredContent.response)).toContain(
+      "[REDACTED:COMPOSIO_API_KEY]",
+    );
+    expect(result.structuredContent.responseText).not.toContain("ck_tool_secret_value");
+  });
+
+  test("rejects absolute composio paths", async () => {
+    process.env.COMPOSIO_API_KEY = "ck_tool_secret_value";
+    const fetchMock = mock(async () => jsonResponse({ ok: true }));
+    globalThis.fetch = fetchMock;
+
+    const tool = buildTool();
+    const result = (await tool.handler(
+      {
+        target: "composio",
+        method: "GET",
+        path: "https://evil.example/tools",
+      },
+      { sessionId: "s", requestInfo: { headers: {} } },
+    )) as { isError?: boolean; structuredContent: { message: string } };
+
+    expect(result.isError).toBe(true);
+    expect(result.structuredContent.message).toContain("endpoint must be a Composio API path");
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,122 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createSkill,
+  getAgentSkills,
+  getDb,
+  getSystemDefaultSkills,
+  initDb,
+  toggleAgentSkill,
+} from "../be/db";
+import { runSeeder } from "../be/seed";
+import { loadSeedSkills, skillsSeeder } from "../be/seed-skills";
+
+const TEST_DB_PATH = `./test-system-default-skills-${process.pid}.sqlite`;
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(path + suffix).catch(() => {});
+  }
+}
+
+describe("system-default skills", () => {
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("seed catalog includes swarm-scripts and marks built-in defaults", async () => {
+    const skills = loadSeedSkills();
+    const names = skills.map((skill) => skill.name);
+
+    expect(names).toContain("attio-interaction");
+    expect(names).toContain("swarm-scripts");
+    expect(skills.find((skill) => skill.name === "attio-interaction")?.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);
+
+    const result = await runSeeder(skillsSeeder, { quiet: true });
+    expect(result.failed).toEqual([]);
+
+    const defaults = getSystemDefaultSkills().map((skill) => skill.name);
+    expect(defaults).toContain("attio-interaction");
+    expect(defaults).toContain("swarm-scripts");
+    expect(defaults).toContain("kv-storage");
+    expect(defaults).toContain("pages");
+  });
+
+  test("existing agents see system-default skills through the self-healing view", () => {
+    const existingAgent = createAgent({
+      name: "Existing Default Skill Worker",
+      description: "Created after seeded defaults",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+
+    const manualDefault = createSkill({
+      name: "manual-system-default",
+      description: "Manual default",
+      content: "---\nname: manual-system-default\ndescription: Manual default\n---\nBody.",
+      type: "personal",
+      scope: "swarm",
+      systemDefault: true,
+    });
+
+    const skills = getAgentSkills(existingAgent.id);
+    expect(skills.map((skill) => skill.name)).toContain("manual-system-default");
+    expect(skills.find((skill) => skill.id === manualDefault.id)?.isActive).toBe(true);
+  });
+
+  test("new agents get concrete agent_skills rows for system defaults", () => {
+    const beforeAgent = createAgent({
+      name: "Concrete Install Worker",
+      description: "Created with defaults present",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+
+    const row = getDb()
+      .prepare<{ count: number }, [string]>(
+        `SELECT COUNT(*) AS count
+         FROM agent_skills
+         WHERE agentId = ?
+           AND skillId IN (SELECT id FROM skills WHERE systemDefault = 1)`,
+      )
+      .get(beforeAgent.id);
+
+    expect(row?.count ?? 0).toBeGreaterThan(0);
+  });
+
+  test("system-default skills remain visible even if an install row is toggled inactive", () => {
+    const agent = createAgent({
+      name: "Inactive Default Worker",
+      description: "Tests self-healing union",
+      role: "worker",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+      capabilities: [],
+    });
+    const skill = getSystemDefaultSkills().find((entry) => entry.name === "swarm-scripts");
+    expect(skill).toBeDefined();
+
+    toggleAgentSkill(agent.id, skill!.id, false);
+    const skills = getAgentSkills(agent.id);
+
+    expect(skills.find((entry) => entry.id === skill!.id)?.isActive).toBe(true);
+  });
+});