@desplega.ai/agent-swarm 1.156.0 → 1.158.0

package/src/tests/extensions-pre-task.test.ts

@@ -20,6 +20,7 @@ import {
 import * as dbClient from "../be/db-client";
 import type { InstallExtensionArgs as ExtensionInstallBody } from "../be/extensions/db";
 import { installExtension, listExtensionRuns } from "../be/extensions/db";
+import { getCatalogEntry } from "../extensions/catalog";
 import { disableExtension, enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
 import { handleTasks } from "../http/tasks";
 import { dispatchScheduleTarget } from "../scheduler/scheduler";
@@ -168,6 +169,112 @@ describe("extension task boundaries", () => {
     expect(retried.status).toBe(201);
   });
 
+  test("GitHub sender allowlist separates internal and external senders", async () => {
+    const template = getCatalogEntry("github-sender-allowlist");
+    if (!template) throw new Error("github-sender-allowlist is missing from the catalog");
+    const installed = await installExtension({
+      manifest: template.manifest,
+      files: template.files,
+      config: {
+        internal: ["tarasyarema", "harlequinetcie"],
+        external: ["fuvidani", "capchase-bot"],
+        reviewBots: ["review-bot"],
+      },
+    });
+    await enableExtension(installed.extension.id);
+
+    const createFromGitHub = (
+      description: string,
+      vcsAuthor: string,
+      taskType: string,
+      vcsUrl: string,
+      source: "github" | "api" = "github",
+    ) =>
+      createTaskWithSiblingAwareness(
+        description,
+        { source, vcsAuthor, taskType, vcsUrl },
+        { origin: "webhook" },
+      );
+
+    await createFromGitHub(
+      "internal sender issue",
+      "HARLEQUINETCIE",
+      "github-issue",
+      "https://github.com/acme/project/issues/1",
+    );
+    await createFromGitHub(
+      "internal sender review",
+      "tarasyarema",
+      "github-review",
+      "https://github.com/acme/project/pull/2",
+    );
+    await createFromGitHub(
+      "external sender PR comment",
+      "FuViDaNi",
+      "github-comment",
+      "https://github.com/acme/project/pull/2",
+    );
+    await createFromGitHub(
+      "external sender PR assignment",
+      "capchase-bot",
+      "github-pr",
+      "https://github.com/acme/project/pull/3",
+    );
+    await createFromGitHub(
+      "external sender PR review",
+      "fuvidani",
+      "github-review",
+      "https://github.com/acme/project/pull/4",
+    );
+
+    await expect(
+      createFromGitHub(
+        "external sender issue comment",
+        "fuvidani",
+        "github-comment",
+        "https://github.com/acme/project/issues/5",
+      ),
+    ).rejects.toThrow('GitHub sender "fuvidani" is blocked: external senders are allowed only');
+    await expect(
+      createFromGitHub(
+        "unknown sender issue",
+        "unknown-user",
+        "github-issue",
+        "https://github.com/acme/project/issues/6",
+      ),
+    ).rejects.toThrow('GitHub sender "unknown-user" is blocked: sender is not on the internal');
+
+    await expect(
+      createFromGitHub(
+        "unknown sender review",
+        "unknown-user",
+        "github-review",
+        "https://github.com/acme/project/pull/7",
+      ),
+    ).rejects.toThrow('GitHub sender "unknown-user" is blocked: sender is not on the internal');
+    await createFromGitHub(
+      "review bot review",
+      "REVIEW-BOT",
+      "github-review",
+      "https://github.com/acme/project/pull/8",
+    );
+    await expect(
+      createFromGitHub(
+        "review bot PR comment",
+        "review-bot",
+        "github-comment",
+        "https://github.com/acme/project/pull/9",
+      ),
+    ).rejects.toThrow('GitHub sender "review-bot" is blocked: review bots are allowed only');
+    await createFromGitHub(
+      "non-GitHub source",
+      "unknown-user",
+      "github-issue",
+      "https://github.com/acme/project/issues/10",
+      "api",
+    );
+  });
+
   test("scheduler and workflow executor provide their task creation origins", async () => {
     const extension = await installSource(
       "record-task-origin",

package/src/tests/fixtures/kibo-blocks-definition.json.txt

@@ -0,0 +1,105 @@
+{
+  "models": {
+    "deal": {
+      "columns": {
+        "title": { "kind": "string", "required": true },
+        "stage": { "kind": "enum", "enum": ["lead", "qualified", "won", "lost"], "default": "lead" },
+        "owner": { "kind": "string" },
+        "value": { "kind": "number" },
+        "closeDate": { "kind": "date" }
+      }
+    }
+  },
+  "queries": {
+    "deals": { "model": "deal", "sort": { "column": "createdAt", "dir": "desc" } },
+    "dealById": { "model": "deal", "filter": { "id": { "$param": "deal" } } }
+  },
+  "pages": {
+    "main": {
+      "params": { "deal": { "kind": "string" } },
+      "root": "root",
+      "elements": {
+        "root": {
+          "type": "Stack",
+          "props": { "gap": "lg" },
+          "children": ["board", "calendars", "activity", "dealDrawer"]
+        },
+        "board": {
+          "type": "Kanban",
+          "props": {
+            "data": { "$state": "/queries/deals/data" },
+            "loading": { "$state": "/queries/deals/loading" },
+            "columnField": "stage",
+            "columns": ["lead", "qualified", { "id": "won", "label": "Won" }, { "id": "lost", "label": "Lost" }],
+            "titleField": "title",
+            "cardFields": [
+              { "key": "owner", "label": "Owner" },
+              { "key": "value", "label": "Value", "kind": "number" }
+            ],
+            "onMove": [
+              {
+                "action": "app.mutate",
+                "params": {
+                  "model": "deal",
+                  "op": "update",
+                  "rowId": { "$row": "id" },
+                  "values": { "stage": { "$row": "stage" } }
+                }
+              }
+            ],
+            "onCardClick": [
+              { "action": "app.navigate", "params": { "page": "main", "params": { "deal": { "$row": "id" } } } }
+            ]
+          }
+        },
+        "calendars": { "type": "Grid", "props": { "columns": 2 }, "children": ["closeCalendar", "createdCalendar"] },
+        "closeCalendar": {
+          "type": "Calendar",
+          "props": {
+            "data": { "$state": "/queries/deals/data" },
+            "startField": "closeDate",
+            "titleField": "title",
+            "onSelect": [
+              { "action": "app.navigate", "params": { "page": "main", "params": { "deal": { "$row": "id" } } } }
+            ]
+          }
+        },
+        "createdCalendar": {
+          "type": "Calendar",
+          "props": {
+            "data": { "$state": "/queries/deals/data" },
+            "startField": "createdAt",
+            "endField": "closeDate",
+            "titleField": "title"
+          }
+        },
+        "activity": {
+          "type": "ContributionGraph",
+          "props": {
+            "data": { "$state": "/queries/deals/data" },
+            "dateField": "createdAt",
+            "countField": "value",
+            "days": 180
+          }
+        },
+        "dealDrawer": {
+          "type": "Drawer",
+          "props": { "param": "deal", "title": "Deal" },
+          "children": ["dealDetail"]
+        },
+        "dealDetail": {
+          "type": "DetailList",
+          "props": {
+            "data": { "$state": "/queries/dealById/data/0" },
+            "fields": [
+              { "key": "title" },
+              { "key": "stage", "kind": "badge" },
+              { "key": "closeDate", "kind": "date" }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "defaultPage": "main"
+}

package/src/tests/follow-up-config-inheritance.test.ts

@@ -0,0 +1,260 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  getDbClient,
+  getScheduledTaskById,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { getRebootAffectedTasks, runRebootSweep } from "../heartbeat/heartbeat";
+import { createStandaloneScheduleTask } from "../scheduler/schedule-task";
+import { createResumeFollowUp, createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
+import { registerDeferTaskTool } from "../tools/defer-task";
+import { registerSendTaskTool } from "../tools/send-task";
+import type { FollowUpConfig } from "../types";
+
+// followUpConfig follows one piece of work, not the thread: continuations of
+// the same work inherit it, new work created with a parentTaskId does not.
+
+type Tool = { handler: (args: unknown, extra: unknown) => Promise<CallToolResult> };
+
+const ON_COMPLETED: FollowUpConfig = { onCompleted: "Switch the cron and DM the requester." };
+
+let leadId: string;
+let workerId: string;
+let sendTask: Tool;
+let deferTask: Tool;
+
+function callTool(tool: Tool, args: Record<string, unknown>, agentId: string) {
+  return tool.handler(args, {
+    sessionId: crypto.randomUUID(),
+    requestInfo: { headers: { "x-agent-id": agentId } },
+  });
+}
+
+function sentTaskId(result: CallToolResult): string {
+  const structured = result.structuredContent as { success: boolean; task?: { id: string } };
+  expect(structured.success).toBe(true);
+  return structured.task!.id;
+}
+
+async function followUpConfigOf(taskId: string) {
+  return (await getTaskById(taskId))?.followUpConfig;
+}
+
+async function workerTaskWithOnCompleted(description: string) {
+  const task = await createTaskExtended(description, {
+    agentId: workerId,
+    followUpConfig: ON_COMPLETED,
+  });
+  await startTask(task.id);
+  return task;
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  const server = new McpServer({ name: "follow-up-config-inheritance", version: "1.0.0" });
+  registerSendTaskTool(server);
+  registerDeferTaskTool(server);
+  const tools = (server as unknown as { _registeredTools: Record<string, Tool> })._registeredTools;
+  sendTask = tools["send-task"]!;
+  deferTask = tools["defer-task"]!;
+});
+
+beforeEach(async () => {
+  const db = getDbClient();
+  await db.run("DELETE FROM agent_tasks");
+  await db.run("DELETE FROM agents");
+  await db.run("DELETE FROM active_sessions");
+  leadId = (
+    await createAgent({
+      name: "Lead",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+      maxTasks: 50,
+    })
+  ).id;
+  workerId = (
+    await createAgent({
+      name: "Worker",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+      maxTasks: 50,
+    })
+  ).id;
+});
+
+afterAll(() => closeDb());
+
+describe("createTaskExtended followUpConfig inheritance", () => {
+  test("a plain child with parentTaskId does not inherit", async () => {
+    const parent = await workerTaskWithOnCompleted("parent work");
+    const child = await createTaskExtended("unrelated child", { parentTaskId: parent.id });
+    expect(child.followUpConfig).toBeUndefined();
+  });
+
+  test("an explicit followUpConfig wins over the parent's", async () => {
+    const parent = await workerTaskWithOnCompleted("parent work");
+    const own: FollowUpConfig = { onFailed: "Retry once." };
+    const child = await createTaskExtended("continuation", {
+      parentTaskId: parent.id,
+      inheritParentFollowUpConfig: true,
+      followUpConfig: own,
+    });
+    expect(child.followUpConfig).toEqual(own);
+  });
+});
+
+describe("kept: continuations of the same work inherit followUpConfig", () => {
+  test("interrupted-task resume (createResumeFollowUp)", async () => {
+    const parent = await workerTaskWithOnCompleted("interrupted work");
+    const resume = await createResumeFollowUp({ parentId: parent.id, reason: "crash_recovery" });
+    expect(resume.kind).toBe("created");
+    if (resume.kind !== "created") return;
+    expect(resume.task.followUpConfig).toEqual(ON_COMPLETED);
+  });
+
+  test("reboot-sweep retry", async () => {
+    const parent = await workerTaskWithOnCompleted("work cut by a reboot");
+    await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+      new Date(Date.now() - 1000).toISOString(),
+      parent.id,
+    ]);
+
+    await runRebootSweep();
+
+    const retryTaskId = getRebootAffectedTasks().find(
+      (a) => a.original.id === parent.id,
+    )?.retryTaskId;
+    expect(retryTaskId).toBeTruthy();
+    expect(await followUpConfigOf(retryTaskId!)).toEqual(ON_COMPLETED);
+  });
+
+  test("defer-task wake-up continuation", async () => {
+    const parent = await workerTaskWithOnCompleted("work that waits");
+    const result = await callTool(
+      deferTask,
+      { taskId: parent.id, delayMs: 3_600_000, summary: "Waiting", note: "Check back" },
+      workerId,
+    );
+    const { success, scheduleId } = result.structuredContent as {
+      success: boolean;
+      scheduleId?: string;
+    };
+    expect(success).toBe(true);
+    const schedule = await getScheduledTaskById(scheduleId!);
+
+    const wake = await createStandaloneScheduleTask(schedule!);
+    expect(wake.parentTaskId).toBe(parent.id);
+    expect(wake.followUpConfig).toEqual(ON_COMPLETED);
+  });
+
+  test("send-task resume re-delegation (reroute-decision template)", async () => {
+    const parent = await workerTaskWithOnCompleted("crashed work");
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "resume the crashed work",
+          agentId: workerId,
+          routingReason: "reroute_fault",
+          routingNote: "same specialization as the crashed worker",
+          taskType: "resume",
+          parentTaskId: parent.id,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toEqual(ON_COMPLETED);
+  });
+});
+
+describe("stopped: new work does not inherit followUpConfig", () => {
+  test("Lead follow-up from createWorkerTaskFollowUp", async () => {
+    const task = await workerTaskWithOnCompleted("worker build task");
+    const completed = await completeTask(task.id, "done");
+    const followUp = await createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "done",
+    });
+    expect(followUp).not.toBeNull();
+    // The instruction is delivered in the follow-up's text, once.
+    expect(followUp!.task).toContain(ON_COMPLETED.onCompleted!);
+    expect(followUp!.followUpConfig).toBeUndefined();
+  });
+
+  test("send-task child with parentTaskId", async () => {
+    const parent = await workerTaskWithOnCompleted("original request");
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "a new delegation in the same thread",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns this area of the codebase",
+          parentTaskId: parent.id,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toBeUndefined();
+  });
+
+  test("send-task child keeps an explicit followUpConfig", async () => {
+    const parent = await workerTaskWithOnCompleted("original request 2");
+    const own: FollowUpConfig = { disabled: true };
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "delegation that is awaited inline",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns this area of the codebase",
+          parentTaskId: parent.id,
+          followUpConfig: own,
+        },
+        leadId,
+      ),
+    );
+    expect(await followUpConfigOf(childId)).toEqual(own);
+  });
+
+  test("chain regression: worker task -> Lead follow-up -> send-task child", async () => {
+    const task = await workerTaskWithOnCompleted("tla-spec-sync build");
+    const completed = await completeTask(task.id, "built");
+    const followUp = await createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "built",
+    });
+    expect(followUp).not.toBeNull();
+
+    const childId = sentTaskId(
+      await callTool(
+        sendTask,
+        {
+          task: "render the launch video",
+          agentId: workerId,
+          routingReason: "skill",
+          routingNote: "worker owns the video pipeline",
+          parentTaskId: followUp!.id,
+        },
+        leadId,
+      ),
+    );
+
+    expect(await followUpConfigOf(followUp!.id)).toBeUndefined();
+    expect(await followUpConfigOf(childId)).toBeUndefined();
+  });
+});

package/src/tests/heartbeat-orphan-resume.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getChildTasks,
+  getDbClient,
+  getTaskById,
+  initDb,
+  startTask,
+  supersedeTask,
+} from "../be/db";
+import {
+  codeLevelTriage,
+  runRebootSweep,
+  setBeforeHeartbeatSupersedeForTests,
+} from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-orphan-resume.sqlite";
+
+describe("Heartbeat orphaned supersede repair (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> Age -> HbRead -> HbWrite -> ApiCrash -> ApiBoot (SupersededGetsResume).
+  test("a task superseded without a resume (crash before resume creation) gets a resume on the next sweep", async () => {
+    const agent = await createAgent({ name: "crashed-worker", isLead: false, status: "idle" });
+    const task = await createTaskExtended("Work interrupted mid-recovery", { agentId: agent.id });
+    await startTask(task.id);
+
+    // State the API process leaves behind if it dies between supersedeTask
+    // and createResumeFollowUp in remediateCrashedWorkerTask.
+    await supersedeTask(task.id, {
+      reason: "Auto-superseded by heartbeat: worker session not found (no active session for task)",
+      resumeTaskId: null,
+    });
+    await getDbClient().run("UPDATE agent_tasks SET finishedAt = ? WHERE id = ?", [
+      new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+      task.id,
+    ]);
+
+    // Restarted API: boot sweep, then a regular sweep.
+    await runRebootSweep();
+    await codeLevelTriage();
+
+    expect((await getTaskById(task.id))?.status).toBe("superseded");
+    expect(await getChildTasks(task.id)).toHaveLength(1);
+  });
+});

package/src/tests/heartbeat-reboot-live.test.ts

@@ -0,0 +1,95 @@
+/**
+ * Counterexamples from the TLA+ heartbeat model (specs/tla/heartbeat/).
+ *
+ * Each test replays one TLC trace against a real temp SQLite DB, calling the
+ * functions ACTIONS.md maps each trace step to. A test that passes on main
+ * means the trace was model drift, not a bug.
+ */
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getActiveSessionForTask,
+  getDbClient,
+  getTaskById,
+  initDb,
+  insertActiveSession,
+  startTask,
+} from "../be/db";
+import { runRebootSweep, setBeforeHeartbeatSupersedeForTests } from "../heartbeat/heartbeat";
+
+const TEST_DB_PATH = "./test-heartbeat-reboot-live.sqlite";
+
+async function backdateTask(taskId: string, isoTime: string): Promise<void> {
+  await getDbClient().run("UPDATE agent_tasks SET lastUpdatedAt = ? WHERE id = ?", [
+    isoTime,
+    taskId,
+  ]);
+}
+
+describe("Reboot sweep live sessions (TLA+ counterexample)", () => {
+  beforeAll(async () => {
+    try {
+      await unlink(TEST_DB_PATH);
+    } catch {
+      // File doesn't exist
+    }
+    closeDb();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const path of [TEST_DB_PATH, `${TEST_DB_PATH}-wal`, `${TEST_DB_PATH}-shm`]) {
+      try {
+        await unlink(path);
+      } catch {
+        // Files may not exist
+      }
+    }
+  });
+
+  beforeEach(async () => {
+    setBeforeHeartbeatSupersedeForTests(null);
+    const db = getDbClient();
+    await db.run("DELETE FROM agent_tasks");
+    await db.run("DELETE FROM agents");
+    await db.run("DELETE FROM active_sessions");
+  });
+
+  // Trace: PollStart -> RegisterSession -> ApiCrash -> ApiBoot -> RebootFail (NoLiveKill).
+  test("reboot sweep does not fail a live worker whose last tool call was shortly before the API restart", async () => {
+    const gs = globalThis as typeof globalThis & { __runId?: string };
+    const original = gs.__runId;
+    const bootTime = Date.now();
+    gs.__runId = `run_${bootTime}`;
+    try {
+      const agent = await createAgent({ name: "live-worker", isLead: false, status: "busy" });
+      const task = await createTaskExtended("Long model call", { agentId: agent.id });
+      await startTask(task.id);
+      await backdateTask(task.id, new Date(bootTime - 60_000).toISOString());
+
+      // Worker container kept running through the API deploy. Its last
+      // PostToolUse heartbeat landed 30s before the new API process booted.
+      await insertActiveSession({
+        agentId: agent.id,
+        taskId: task.id,
+        triggerType: "task_assigned",
+      });
+      await getDbClient().run("UPDATE active_sessions SET lastHeartbeatAt = ? WHERE taskId = ?", [
+        new Date(bootTime - 30_000).toISOString(),
+        task.id,
+      ]);
+
+      await runRebootSweep();
+
+      expect((await getTaskById(task.id))?.status).toBe("in_progress");
+      expect(await getActiveSessionForTask(task.id)).not.toBeNull();
+    } finally {
+      gs.__runId = original;
+    }
+  });
+});