@desplega.ai/agent-swarm 1.152.2 → 1.154.0

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

@@ -1,10 +1,11 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import { unlinkSync } from "node:fs";
 import {
   closeDb,
   completeTask,
   createAgent,
   createTaskExtended,
+  createUser,
   getChildTasks,
   getLatestActiveTaskInThread,
   getLogsByTaskId,
@@ -15,6 +16,8 @@ import {
 
 process.env.SLACK_RENDER_V2 = "false";
 
+import { linkIdentity } from "../be/users";
+import * as slackApp from "../slack/app";
 import { buildTreeBlocks } from "../slack/blocks";
 import { routeMessage } from "../slack/router";
 import { formatSlackSteeringAck, requestSlackThreadSteering } from "../slack/steering";
@@ -37,6 +40,7 @@ async function createRunningSlackTask(
   channelId: string,
   threadTs: string,
   task = "existing Slack task",
+  requestedByUserId?: string,
 ) {
   const created = await createTaskExtended(task, {
     agentId,
@@ -44,6 +48,7 @@ async function createRunningSlackTask(
     slackChannelId: channelId,
     slackThreadTs: threadTs,
     slackUserId: "U_REQUESTER",
+    requestedByUserId,
   });
   const started = await startTask(created.id);
   expect(started?.status).toBe("in_progress");
@@ -220,6 +225,69 @@ describe("Slack thread steering", () => {
     expect(await getChildTasks(leadTask.id)).toEqual([]);
   });
 
+  test("buffered replies resolve registered senders and keep mixed authors separate", async () => {
+    process.env.SLACK_THREAD_STEERING = "lead";
+    process.env.SLACK_THREAD_STEERING_MODE = "queue";
+    const channelId = "C_STEER_SENDERS";
+    const threadTs = "5100.0001";
+    const taras = await createUser({ name: "Taras", email: "taras-steering@example.com" });
+    const other = await createUser({ name: "Other", email: "other-steering@example.com" });
+    const task = await createRunningSlackTask(leadId, channelId, threadTs, undefined, other.id);
+    await linkIdentity(other.id, "slack", "U_OTHER_STEER", { kind: "system", id: "test" });
+    // Taras has no Slack alias yet: exercise the same email cascade as task creation.
+    const infoUsers: string[] = [];
+    const appSpy = spyOn(slackApp, "getSlackApp").mockReturnValue({
+      client: {
+        users: {
+          info: async ({ user }: { user: string }) => {
+            infoUsers.push(user);
+            return {
+              user: { profile: user === "U_TARAS_STEER" ? { email: taras.email } : {} },
+            };
+          },
+        },
+        chat: { postMessage: async () => ({ ok: true }) },
+      },
+    } as unknown as NonNullable<ReturnType<typeof slackApp.getSlackApp>>);
+    try {
+      bufferThreadMessage(channelId, threadTs, "first", "U_TARAS_STEER", "5100.0002");
+      bufferThreadMessage(channelId, threadTs, "second", "U_TARAS_STEER", "5100.0003");
+      bufferThreadMessage(channelId, threadTs, "other correction", "U_OTHER_STEER", "5100.0004");
+      bufferThreadMessage(
+        channelId,
+        threadTs,
+        "unmapped correction",
+        "U_UNKNOWN_STEER",
+        "5100.0005",
+      );
+      bufferThreadMessage(channelId, threadTs, "last", "U_TARAS_STEER", "5100.0006");
+      await instantFlush(`${channelId}:${threadTs}`);
+
+      const messages = await getSteeringMessagesForTask(task.id);
+      expect(messages).toHaveLength(4);
+      for (const [body, userId, label] of [
+        ["first\n---\nsecond", taras.id, "Taras (user)"],
+        ["other correction", other.id, "Other (user)"],
+        ["unmapped correction", undefined, "Unknown (user)"],
+        ["last", taras.id, "Taras (user)"],
+      ]) {
+        expect(messages.find((message) => message.body === body)).toMatchObject({
+          source: "slack",
+          createdByKind: "user",
+          createdByUserId: userId,
+          senderLabel: label,
+        });
+      }
+      expect(infoUsers).toEqual(["U_TARAS_STEER", "U_UNKNOWN_STEER"]);
+      expect(
+        (await getLogsByTaskId(task.id)).filter((log) => log.newValue === "slack_reaction"),
+      ).toHaveLength(5);
+      expect(await getChildTasks(task.id)).toEqual([]);
+    } finally {
+      appSpy.mockRestore();
+    }
+  });
+
   test("all mode targets the latest active task", async () => {
     process.env.SLACK_THREAD_STEERING = "all";
     const channelId = "C_STEER_ALL";

package/src/tests/slack-task-output.test.ts

@@ -1,25 +1,46 @@
 import { describe, expect, test } from "bun:test";
 import { slackTaskOutput } from "../slack/task-output";
 
+/** The shape `defer-task` writes today: the human card, already rendered. */
 const task = {
   status: "completed" as const,
   tags: ["deferred"],
+  output: "Waiting on Researcher — or tomorrow at 17:30 at the latest",
+};
+
+/** The shape written before defer-task stored the card directly. */
+const legacy = {
+  ...task,
   output:
     "Deferred until tomorrow 17:30 UTC ([12345678](https://example.com/schedules/12345678)) -> check the build",
 };
 
 describe("Slack deferral output", () => {
-  test("keeps the pending work without the ETA or schedule link", () => {
-    expect(slackTaskOutput(task)).toBe("Pending: check the build");
-    expect(task.output).toContain("tomorrow 17:30 UTC");
+  test("posts the stored deferral card verbatim", () => {
+    expect(slackTaskOutput(task)).toBe(
+      "Waiting on Researcher — or tomorrow at 17:30 at the latest",
+    );
+    expect(slackTaskOutput({ ...task, output: "Checking back today at 00:31" })).toBe(
+      "Checking back today at 00:31",
+    );
   });
 
-  test("removes an ETA-only line and preserves punctuation in the pending description", () => {
-    expect(slackTaskOutput({ ...task, output: task.output.replace("check the build", "") })).toBe(
-      "",
-    );
-    expect(slackTaskOutput({ ...task, output: `${task.output} (CI) -> deploy` })).toBe(
-      "Pending: check the build (CI) -> deploy",
+  test("rewrites a legacy notice to its ETA, dropping the note and the schedule link", () => {
+    const rendered = slackTaskOutput(legacy);
+    expect(rendered).toBe("Checking back tomorrow 17:30 UTC");
+    expect(rendered).not.toContain("check the build");
+    expect(rendered).not.toContain("schedules/12345678");
+  });
+
+  test("a legacy notice with no pending text still yields its ETA, not an empty card", () => {
+    expect(
+      slackTaskOutput({ ...legacy, output: legacy.output.replace("check the build", "") }),
+    ).toBe("Checking back tomorrow 17:30 UTC");
+  });
+
+  test("an arrow inside a legacy note does not extend the ETA", () => {
+    expect(slackTaskOutput({ ...legacy, output: `${legacy.output} (CI) -> deploy` })).toBe(
+      "Checking back tomorrow 17:30 UTC",
     );
   });
 
@@ -28,9 +49,9 @@ describe("Slack deferral output", () => {
   });
 
   test("preserves schema output and non-deferral output verbatim", () => {
-    expect(slackTaskOutput({ ...task, outputSchema: { type: "string" } })).toBe(task.output);
-    expect(slackTaskOutput({ ...task, tags: [] })).toBe(task.output);
-    expect(slackTaskOutput({ ...task, status: "in_progress" })).toBe(task.output);
+    expect(slackTaskOutput({ ...legacy, outputSchema: { type: "string" } })).toBe(legacy.output);
+    expect(slackTaskOutput({ ...legacy, tags: [] })).toBe(legacy.output);
+    expect(slackTaskOutput({ ...legacy, status: "in_progress" })).toBe(legacy.output);
     expect(slackTaskOutput({ ...task, output: undefined })).toBeUndefined();
   });
 });

package/src/tests/status.test.ts

@@ -96,6 +96,8 @@ const ENV_KEYS_TO_RESET = [
   "DEVIN_ORG_ID",
   "SLACK_BOT_TOKEN",
   "SLACK_APP_TOKEN",
+  "SLACK_SIGNING_SECRET",
+  "SLACK_MODE",
   "SLACK_DISABLE",
   "GITHUB_WEBHOOK_SECRET",
   "GITHUB_APP_ID",
@@ -409,20 +411,38 @@ describe("setup milestones", () => {
     });
   });
 
-  test("slack: needs both bot+app tokens AND not disabled", async () => {
+  test("slack: reports mode-aware credentials as configured, not live-verified", async () => {
     process.env.SLACK_BOT_TOKEN = "xoxb-test";
     const a = await buildStatusPayload();
     expect(getMilestone(a, "slack").state).toBe("unverified");
 
     process.env.SLACK_APP_TOKEN = "xapp-test";
     const b = await buildStatusPayload();
-    expect(getMilestone(b, "slack").state).toBe("verified");
+    expect(getMilestone(b, "slack").state).toBe("configured");
+    expect(getMilestone(b, "slack").hint).toContain("not been verified");
+
+    process.env.SLACK_MODE = "http";
+    delete process.env.SLACK_APP_TOKEN;
+    process.env.SLACK_SIGNING_SECRET = "synthetic-signing-secret";
+    const http = await buildStatusPayload();
+    expect(getMilestone(http, "slack").state).toBe("unverified");
+    expect(getMilestone(http, "slack").hint).toContain("unavailable");
 
     process.env.SLACK_DISABLE = "true";
     const c = await buildStatusPayload();
     expect(getMilestone(c, "slack").state).toBe("unverified");
   });
 
+  test("slack: invalid mode fails closed with a specific hint", async () => {
+    process.env.SLACK_MODE = "webhook";
+    process.env.SLACK_BOT_TOKEN = "xoxb-test";
+    process.env.SLACK_APP_TOKEN = "xapp-test";
+
+    const milestone = getMilestone(await buildStatusPayload(), "slack");
+    expect(milestone.state).toBe("unverified");
+    expect(milestone.hint).toContain("Invalid SLACK_MODE");
+  });
+
   test("github: needs webhook secret + app id + private key", async () => {
     process.env.GITHUB_WEBHOOK_SECRET = "secret";
     process.env.GITHUB_APP_ID = "12345";

package/src/tests/steering-core.test.ts

@@ -144,6 +144,41 @@ describe("task steering core", () => {
     return started!;
   }
 
+  test("sender labels resolve on task reads, worker polls, and lifecycle responses", async () => {
+    const task = await runningTask("pi", "sender labels");
+    const user = await createUser({ name: "Taras" });
+    const unnamed = await createUser({ name: " " });
+    for (const [creator, expected] of [
+      [{ createdByKind: "user", createdByUserId: user.id }, "Taras (user)"],
+      [
+        { createdByKind: "agent", createdByAgentId: agentIds.get("lead")! },
+        "Steering lead (agent)",
+      ],
+      [{ createdByKind: "system" }, "system"],
+      [{ createdByKind: "user", createdByUserId: unnamed.id }, `${unnamed.id} (user)`],
+      [{ createdByKind: "agent", createdByAgentId: "deleted-agent" }, "deleted-agent (agent)"],
+      [{ createdByKind: "user" }, "Unknown (user)"],
+    ] as const) {
+      const message = await createSteeringMessage({
+        taskId: task.id,
+        body: "sender test",
+        mode: "queue",
+        source: "api",
+        ...creator,
+      });
+      expect(message.senderLabel).toBe(expected);
+      expect((await getSteeringMessageById(message.id))?.senderLabel).toBe(expected);
+      const taskRead = await api("GET", `/api/tasks/${task.id}/steering-messages`);
+      expect(taskRead.status).toBe(200);
+      expect(taskRead.body.messages).toContainEqual(
+        expect.objectContaining({ id: message.id, senderLabel: expected }),
+      );
+      expect(await getPendingSteeringForAgent(agentIds.get("pi")!)).toContainEqual(message);
+      expect((await markSteeringDelivered(message.id, "queue"))?.senderLabel).toBe(expected);
+      expect((await markSteeringHandled(message.id))?.senderLabel).toBe(expected);
+    }
+  });
+
   test("row lifecycle transitions pending -> delivered -> handled", async () => {
     const task = await runningTask("pi", "lifecycle");
     const created = await createSteeringMessage({

package/src/tests/steering-delivery.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { configureDbResolver, resetDbResolver } from "../prompts/resolver";
+import { renderSteeringDelivery } from "../prompts/steering-delivery";
+
+afterEach(resetDbResolver);
+
+describe("steering delivery sender", () => {
+  test.each([
+    "Taras (user)",
+    "Lead (agent)",
+    "system",
+    "deleted-user (user)",
+  ])("renders %s and preserves the acknowledgement marker", async (sender) => {
+    const id = crypto.randomUUID();
+    expect(await renderSteeringDelivery(id, "change course", sender)).toContain(
+      `[steering ${id}] From ${sender}: change course`,
+    );
+  });
+
+  test("sender is a template variable and whitespace is flattened", async () => {
+    configureDbResolver(() => ({
+      template: { id: "custom", scope: "global", body: "{{sender}}: {{body}}" },
+    }));
+    expect(await renderSteeringDelivery("id", "body", "Taras\n(user)")).toBe("Taras (user): body");
+  });
+
+  test("falls back to the bare body on skipped, blank, and failing templates", async () => {
+    for (const resolver of [
+      () => ({ skip: true as const }),
+      () => ({ template: { id: "blank", scope: "global", body: " " } }),
+      () => {
+        throw new Error("unavailable");
+      },
+    ]) {
+      configureDbResolver(resolver);
+      expect(await renderSteeringDelivery("id", "body", "Taras (user)")).toBe("body");
+    }
+  });
+});

package/src/tests/steering-transport.test.ts

@@ -190,7 +190,7 @@ describe("steering worker transport", () => {
   });
 
   test("delivers pending rows once and reports the adapter's actual mode", async () => {
-    const pending = pendingMessage();
+    const pending = pendingMessage({ createdByKind: "agent", senderLabel: "Lead (agent)" });
     const nonPending = pendingMessage({ id: crypto.randomUUID(), status: "delivered" });
     const deliveries: Array<{ mode: string; text: string }> = [];
     const reports: Array<{ path: string; body: unknown }> = [];
@@ -220,7 +220,7 @@ describe("steering worker transport", () => {
     // The body is wrapped in the delivery envelope, which MUST carry the
     // steering message ID — `accept-steer` needs it, and it is the only route
     // to `handled`. Without it the agent obeys but can never acknowledge.
-    expect(deliveries[0]?.text).toContain("change course");
+    expect(deliveries[0]?.text).toContain("From Lead (agent): change course");
     expect(deliveries[0]?.text).toContain(pending.id);
     expect(deliveries[0]?.text).toContain("accept-steer");
     expect(state.dispatchedIds.has(pending.id)).toBe(true);

package/src/tests/task-tool-preload-mcp.test.ts

@@ -73,6 +73,8 @@ async function pins(client: Client): Promise<string[]> {
     .sort();
 }
 
+// Eight real MCP sessions approach the 10s CI default under parallel runner load.
+// Keep the session-lifetime assertions together with room for connection setup.
 test("wire response is default-on, per-task, additive, and fixed for one MCP session", async () => {
   const task = await createTaskExtended("review fixture", { agentId, taskType: "review" });
   const other = await createTaskExtended("other fixture", { agentId, taskType: "other" });
@@ -115,7 +117,7 @@ test("wire response is default-on, per-task, additive, and fixed for one MCP ses
   await configure("TASK_TOOL_PRELOAD_ENABLED", "true");
   await configure("TASK_TOOL_MANIFESTS", "invalid deployment JSON");
   expect(await pins(await connect(task.id))).toEqual([]);
-});
+}, 30_000);
 
 test("a manifest cannot expand the scripts-only capability surface", async () => {
   const task = await createTaskExtended("script fixture", { agentId, taskType: "script" });

package/src/tests/telemetry-init.test.ts

@@ -794,6 +794,24 @@ describe("initTelemetry", () => {
       ).toBe(false);
     });
 
+    test("Slack HTTP mode uses the signing secret instead of an app token", () => {
+      expect(
+        _hasSlackChannel({
+          SLACK_MODE: "http",
+          SLACK_BOT_TOKEN: "xoxb-1",
+          SLACK_SIGNING_SECRET: "synthetic-signing-secret",
+        }),
+      ).toBe(true);
+      expect(_hasSlackChannel({ SLACK_MODE: "http", SLACK_BOT_TOKEN: "xoxb-1" })).toBe(false);
+      expect(
+        _hasSlackChannel({
+          SLACK_MODE: "invalid",
+          SLACK_BOT_TOKEN: "xoxb-1",
+          SLACK_APP_TOKEN: "xapp-1",
+        }),
+      ).toBe(false);
+    });
+
     test("Email requires AGENTMAIL_WEBHOOK_SECRET", () => {
       expect(_hasEmailChannel({})).toBe(false);
       expect(_hasEmailChannel({ AGENTMAIL_WEBHOOK_SECRET: "whsec_1" })).toBe(true);

package/src/tests/workflow-live-recovery.test.ts

@@ -0,0 +1,126 @@
+import { afterAll, beforeAll, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createWorkflow,
+  createWorkflowRun,
+  deleteWorkflow,
+  getWorkflowRun,
+  getWorkflowRunStepsByRunId,
+  initDb,
+} from "../be/db";
+import { codeLevelTriage } from "../heartbeat/heartbeat";
+import { getExecutorRegistry } from "../workflows";
+import { isWorkflowRunActive, walkGraph } from "../workflows/engine";
+import { ScriptExecutor } from "../workflows/executors/script";
+import { recoverIncompleteRuns } from "../workflows/recovery";
+
+const dbPath = `./test-workflow-live-recovery-${crypto.randomUUID()}.sqlite`;
+const workflowIds: string[] = [];
+const output = { exitCode: 0, stdout: "done", stderr: "" };
+
+beforeAll(() => initDb(dbPath));
+afterAll(async () => {
+  for (const id of workflowIds) await deleteWorkflow(id);
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) await unlink(dbPath + suffix).catch(() => {});
+});
+
+test("periodic heartbeat leaves an in-flight long script owned and activates its successor once", async () => {
+  const workflow = await createWorkflow({
+    name: "live recovery regression",
+    definition: {
+      nodes: [
+        {
+          id: "long-script",
+          type: "script",
+          config: { runtime: "bash", script: "sleep 90", timeout: 120_000 },
+          next: "successor",
+        },
+        { id: "successor", type: "script", config: { runtime: "bash", script: "echo done" } },
+      ],
+    },
+  });
+  workflowIds.push(workflow.id);
+  const runId = crypto.randomUUID();
+  await createWorkflowRun({ id: runId, workflowId: workflow.id, triggerType: "manual" });
+  const entered = Promise.withResolvers<void>();
+  const release = Promise.withResolvers<void>();
+  const calls: string[] = [];
+  // Hold the executor at an explicit barrier instead of sleeping for 90 seconds.
+  // A duplicate invocation returns immediately so the broken recovery fails
+  // assertions rather than hanging the test.
+  const executor = spyOn(ScriptExecutor.prototype, "run").mockImplementation(async (input) => {
+    calls.push(input.meta.nodeId);
+    if (calls.length === 1) {
+      entered.resolve();
+      await release.promise;
+    }
+    return { status: "success", output };
+  });
+  const walking = walkGraph(
+    workflow.definition,
+    runId,
+    {},
+    [workflow.definition.nodes[0]!],
+    getExecutorRegistry(),
+    workflow.id,
+  );
+  try {
+    await entered.promise;
+    for (let sweep = 0; sweep < 2; sweep++) {
+      const findings = await codeLevelTriage();
+      expect(findings.staleCleanup.workflowRuns).toBe(0);
+      const run = await getWorkflowRun(runId);
+      expect(run?.status).toBe("running");
+      expect(run?.finishedAt).toBeFalsy();
+      expect(calls).toEqual(["long-script"]);
+    }
+    release.resolve();
+    await walking;
+    expect(calls).toEqual(["long-script", "successor"]);
+    expect((await getWorkflowRun(runId))?.status).toBe("completed");
+    expect((await getWorkflowRunStepsByRunId(runId)).map((step) => step.status)).toEqual([
+      "completed",
+      "completed",
+    ]);
+    expect(isWorkflowRunActive(runId)).toBe(false);
+  } finally {
+    release.resolve();
+    await walking;
+    executor.mockRestore();
+  }
+});
+
+test("an interrupted run without a live walk still recovers and executes its successor", async () => {
+  const workflow = await createWorkflow({
+    name: "interrupted recovery control",
+    definition: {
+      nodes: [
+        {
+          id: "first",
+          type: "script",
+          config: { runtime: "bash", script: "echo first" },
+          next: "last",
+        },
+        { id: "last", type: "script", config: { runtime: "bash", script: "echo last" } },
+      ],
+    },
+  });
+  workflowIds.push(workflow.id);
+  const runId = crypto.randomUUID();
+  await createWorkflowRun({ id: runId, workflowId: workflow.id, triggerType: "manual" });
+  const calls: string[] = [];
+  const executor = spyOn(ScriptExecutor.prototype, "run").mockImplementation(async (input) => {
+    calls.push(input.meta.nodeId);
+    return { status: "success", output };
+  });
+  try {
+    expect(await recoverIncompleteRuns(getExecutorRegistry())).toBe(1);
+    expect(calls).toEqual(["first", "last"]);
+    expect((await getWorkflowRun(runId))?.status).toBe("completed");
+    expect(isWorkflowRunActive(runId)).toBe(false);
+  } finally {
+    executor.mockRestore();
+  }
+});

package/src/tests/workflow-llm.test.ts

@@ -11,7 +11,7 @@ describe("resolveWorkflowLlmConfig", () => {
     expect(config).toEqual({
       apiKey: "sk-or-test",
       baseURL: "https://gateway.example.test/v1",
-      model: "google/gemini-3-flash-preview",
+      model: "deepseek/deepseek-v4.1-flash",
     });
   });
 
@@ -23,7 +23,7 @@ describe("resolveWorkflowLlmConfig", () => {
     expect(config).toEqual({
       apiKey: "example-sk-openai-test",
       baseURL: undefined,
-      model: "gpt-5.4-mini",
+      model: "gpt-6-luna",
     });
   });
 
@@ -34,7 +34,7 @@ describe("resolveWorkflowLlmConfig", () => {
       const config = await resolveWorkflowLlmConfig(undefined, {
         OPENAI_API_KEY: "example-sk-openai-test",
       });
-      expect(config.model).toBe("gpt-5.4-mini");
+      expect(config.model).toBe("gpt-6-luna");
     } finally {
       if (previous === undefined) delete process.env.MEMORY_RATER_MODEL;
       else process.env.MEMORY_RATER_MODEL = previous;