@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/src/tests/session-costs.test.ts

@@ -1691,32 +1691,35 @@ describe("Session Costs API", () => {
       try {
         await getAttributionByPerson({ startDate: "2026-08-19", endDate: "2026-08-19" });
         const call = querySpy.mock.calls.find(([sql]) =>
-          String(sql).includes("task_tree(rootId, taskId, output)"),
+          String(sql).includes("task_tree(rootId, taskId)"),
         );
         const sql = String(call?.[0] ?? "");
-        const seed = sql.slice(0, sql.indexOf("task_tree(rootId, taskId, output)"));
+        const seed = sql.slice(0, sql.indexOf("task_tree(rootId, taskId)"));
 
         expect(seed).toContain("selected_roots");
         expect(seed).toContain("t.requestedByUserId IS NOT NULL");
         expect(seed).toContain("t.createdAt >= ?");
         expect(seed).toContain("t.createdAt < ?");
         expect(seed).toContain("t.parentTaskId IS NULL");
+        expect(seed).toContain("t.isHumanFree = 0");
         expect(seed).not.toContain("human_free_tasks");
         expect(sql).toMatch(
-          /task_tree\(rootId, taskId, output\) AS \(\s*SELECT id, id, output\s*FROM selected_roots/,
+          /task_tree\(rootId, taskId\) AS \(\s*SELECT id, id\s*FROM selected_roots/,
         );
+        // The recursion carries ids only; a task's output is read by id afterwards.
+        expect(sql).not.toContain("task_tree(rootId, taskId, output)");
         expect(sql.match(/\?/g)).toHaveLength(2);
 
+        // Reach reads the stored human-free flag; it walks no ancestry.
         const reachCall = querySpy.mock.calls.find(([preparedSql]) =>
-          String(preparedSql).includes("task_ancestry("),
+          String(preparedSql).includes("COUNT(DISTINCT t.agentId)"),
         );
         const reachSql = String(reachCall?.[0] ?? "");
-        const reachSeed = reachSql.slice(0, reachSql.indexOf("task_ancestry("));
-        expect(reachSeed).toContain("report_tasks");
-        expect(reachSeed).toContain("t.requestedByUserId IS NOT NULL");
-        expect(reachSeed).toContain("t.createdAt >= ?");
-        expect(reachSeed).toContain("t.createdAt < ?");
-        expect(reachSql).toContain("JOIN task_ancestry child ON parent.id = child.parentTaskId");
+        expect(reachSql).toContain("t.requestedByUserId IS NOT NULL");
+        expect(reachSql).toContain("t.createdAt >= ?");
+        expect(reachSql).toContain("t.createdAt < ?");
+        expect(reachSql).toContain("t.isHumanFree = 0");
+        expect(reachSql).not.toContain("RECURSIVE");
         expect(reachSql.match(/\?/g)).toHaveLength(2);
       } finally {
         querySpy.mockRestore();
@@ -2107,7 +2110,7 @@ describe("Session Costs API", () => {
       try {
         await getAttributionByPerson({});
         const call = querySpy.mock.calls.find(([sql]) =>
-          String(sql).includes("task_tree(rootId, taskId, output)"),
+          String(sql).includes("task_tree(rootId, taskId)"),
         );
         const sql = String(call?.[0] ?? "");
 

package/src/tests/slack-message-text.test.ts

@@ -240,6 +240,107 @@ describe("extractSlackMessageText", () => {
       expect(result).toContain("Details here");
     });
 
+    // Shape of a real multi-line human message: Slack sends mrkdwn `text` and a
+    // rich_text block with one element per styled run, mention and link.
+    const multiLineHumanMessage = {
+      text: "<@U0A1B2C3D> can you check the deploy?\n*It failed* twice &amp; the logs say:\n• timeout on <https://ci.example.com/run/42|run 42>\n• retry :fire:",
+      blocks: [
+        {
+          type: "rich_text",
+          elements: [
+            {
+              type: "rich_text_section",
+              elements: [
+                { type: "user", user_id: "U0A1B2C3D" },
+                { type: "text", text: " can you check the deploy?\n" },
+                { type: "text", text: "It failed", style: { bold: true } },
+                { type: "text", text: " twice & the logs say:\n" },
+              ],
+            },
+            {
+              type: "rich_text_list",
+              style: "bullet",
+              elements: [
+                {
+                  type: "rich_text_section",
+                  elements: [
+                    { type: "text", text: "timeout on " },
+                    { type: "link", url: "https://ci.example.com/run/42", text: "run 42" },
+                  ],
+                },
+                {
+                  type: "rich_text_section",
+                  elements: [
+                    { type: "text", text: "retry " },
+                    { type: "emoji", name: "fire" },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    };
+
+    test("multi-line rich_text human message renders once, as the top-level text", () => {
+      const result = extractSlackMessageText(multiLineHumanMessage);
+      expect(result).toBe(multiLineHumanMessage.text);
+      expect(result.split("can you check the deploy?").length - 1).toBe(1);
+    });
+
+    test("single-line rich_text with a mention renders once and keeps the mention", () => {
+      const msg = {
+        text: "hey <@U0A1B2C3D> ship it",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [
+              {
+                type: "rich_text_section",
+                elements: [
+                  { type: "text", text: "hey " },
+                  { type: "user", user_id: "U0A1B2C3D" },
+                  { type: "text", text: " ship it" },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe("hey <@U0A1B2C3D> ship it");
+    });
+
+    test("negative control: rich_text that differs from top-level text keeps both", () => {
+      const msg = {
+        text: "Deploy summary",
+        blocks: [
+          {
+            type: "rich_text",
+            elements: [
+              {
+                type: "rich_text_section",
+                elements: [{ type: "text", text: "Deploy failed on step 3\nRolled back to v1.2" }],
+              },
+            ],
+          },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe(
+        "Deploy summary\nDeploy failed on step 3\nRolled back to v1.2",
+      );
+    });
+
+    test("negative control: rich_text dedupe leaves non-rich_text blocks in place", () => {
+      const msg = {
+        ...multiLineHumanMessage,
+        blocks: [
+          ...multiLineHumanMessage.blocks,
+          { type: "context", elements: [{ type: "mrkdwn", text: "Sent from CI bot" }] },
+        ],
+      };
+      expect(extractSlackMessageText(msg)).toBe(`${multiLineHumanMessage.text}\nSent from CI bot`);
+    });
+
     test("context block elements are captured", () => {
       const msg = {
         text: "",

package/src/tests/slack-thread-buffer-context.test.ts

@@ -0,0 +1,93 @@
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { closeDb, createAgent, getLatestActiveTaskInThread, initDb } from "../be/db";
+
+process.env.SLACK_RENDER_V2 = "false";
+process.env.STEERING_ENABLED = "false";
+
+const TEST_DB_PATH = "./test-slack-thread-buffer-context.sqlite";
+
+// Replies Slack returns for the thread: the root, one earlier human reply, and
+// the buffered follow-up itself (conversations.replies includes it by the time
+// the buffer flushes).
+const threadMessages = [
+  { ts: "7000.0001", user: "U0ROOT", text: "original request" },
+  { ts: "7000.0005", user: "U0EARLIER", text: "earlier reply that is only context" },
+  {
+    ts: "7000.0010",
+    user: "U0FOLLOWUP",
+    text: "please also fix the retry\nand add a test for it",
+    blocks: [
+      {
+        type: "rich_text",
+        elements: [
+          {
+            type: "rich_text_section",
+            elements: [{ type: "text", text: "please also fix the retry\nand add a test for it" }],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const realSlackApp = await import("../slack/app");
+mock.module("../slack/app", () => ({
+  ...realSlackApp,
+  getSlackApp: () => ({
+    client: {
+      conversations: { replies: async () => ({ ok: true, messages: threadMessages }) },
+      users: { info: async () => ({ ok: true, user: { profile: {} } }) },
+      chat: { postMessage: async () => ({ ok: true, ts: "7000.0099" }) },
+    },
+  }),
+}));
+
+const { instantFlush, bufferThreadMessage } = await import("../slack/thread-buffer");
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  await createAgent({ name: "lead-agent", isLead: true, status: "idle", capabilities: [] });
+});
+
+afterAll(() => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+describe("buffered follow-up task description", () => {
+  test("carries each buffered message once, outside <thread_context>", async () => {
+    const channelId = "C700";
+    const threadTs = "7000.0001";
+    bufferThreadMessage(
+      channelId,
+      threadTs,
+      "please also fix the retry\nand add a test for it",
+      "U0FOLLOWUP",
+      "7000.0010",
+    );
+
+    await instantFlush(`${channelId}:${threadTs}`);
+
+    const task = await getLatestActiveTaskInThread(channelId, threadTs);
+    expect(task).not.toBeNull();
+    const description = task!.task;
+    const context = description.slice(
+      description.indexOf("<thread_context>"),
+      description.indexOf("</thread_context>"),
+    );
+
+    // The follow-up appears exactly once, in the buffered section.
+    expect(description.split("please also fix the retry").length - 1).toBe(1);
+    expect(context).not.toContain("please also fix the retry");
+    expect(description).toContain("1 message(s) buffered");
+
+    // Negative control: messages that are not buffered stay in the context.
+    expect(context).toContain("original request");
+    expect(context).toContain("earlier reply that is only context");
+  });
+});

package/src/tests/task-cascade-fail.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlinkSync } from "node:fs";
 import {
+  backfillSupersedeTaskResumeTaskId,
   cancelTask,
   cascadeFailDependents,
   closeDb,
@@ -230,7 +231,7 @@ describe("cascadeFailDependents", () => {
     expect(childAfter!.failureReason).toContain("was cancelled");
   });
 
-  test("supersedeTask cascades to dependents", async () => {
+  test("supersedeTask with a resume id re-points never-started dependents", async () => {
     const agent = await createAgent({
       name: "cascade-worker-6",
       isLead: false,
@@ -239,19 +240,164 @@ describe("cascadeFailDependents", () => {
     });
 
     const parent = await createTaskExtended("Parent supersede", { agentId: agent.id });
+    const other = await createTaskExtended("Other dependency", { agentId: agent.id });
     const child = await createTaskExtended("Child of superseded", {
+      agentId: agent.id,
+      dependsOn: [parent.id, other.id],
+    });
+    const resume = await createTaskExtended("Resume of parent", { agentId: agent.id });
+
+    await startTask(parent.id);
+    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: resume.id });
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([resume.id, other.id]);
+
+    const log = await getDbClient().get<{ oldValue: string; newValue: string; metadata: string }>(
+      "SELECT oldValue, newValue, metadata FROM agent_log WHERE taskId = ? AND eventType = 'task_dependency_repointed'",
+      [child.id],
+    );
+    expect(log?.oldValue).toBe(parent.id);
+    expect(log?.newValue).toBe(resume.id);
+    expect(JSON.parse(log!.metadata).reason).toBe("supersede_resume");
+  });
+
+  test("supersedeTask without a resume id defers dependents until the backfill", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6b",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = await createTaskExtended("Parent supersede late resume", { agentId: agent.id });
+    const child = await createTaskExtended("Child of late-resumed", {
+      agentId: agent.id,
+      dependsOn: [parent.id],
+    });
+
+    await startTask(parent.id);
+    await supersedeTask(parent.id, { reason: "graceful_shutdown", resumeTaskId: null });
+
+    // The window between supersede and resume creation must not fail it.
+    expect((await getTaskById(child.id))!.status).toBe("pending");
+
+    const resume = await createTaskExtended("Late resume", { agentId: agent.id });
+    await backfillSupersedeTaskResumeTaskId(parent.id, resume.id);
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([resume.id]);
+  });
+
+  test("supersede settle does not rewrite a dependent that already started", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6c",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const parent = await createTaskExtended("Parent supersede started dep", {
+      agentId: agent.id,
+    });
+    const child = await createTaskExtended("Started child", {
       agentId: agent.id,
       dependsOn: [parent.id],
     });
+    const resume = await createTaskExtended("Resume for started dep", { agentId: agent.id });
 
     await startTask(parent.id);
-    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: null });
+    await startTask(child.id);
+    await supersedeTask(parent.id, { reason: "context limit", resumeTaskId: resume.id });
 
     const childAfter = await getTaskById(child.id);
+    expect(childAfter!.dependsOn).toEqual([parent.id]);
     expect(childAfter!.status).toBe("failed");
     expect(childAfter!.failureReason).toContain("was superseded");
   });
 
+  test("concurrent settlements of a shared dependent keep both replacements", async () => {
+    const agent = await createAgent({
+      name: "cascade-worker-6d",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const a = await createTaskExtended("Shared parent A", { agentId: agent.id });
+    const b = await createTaskExtended("Shared parent B", { agentId: agent.id });
+    const child = await createTaskExtended("Depends on A and B", {
+      agentId: agent.id,
+      dependsOn: [a.id, b.id],
+    });
+    const ra = await createTaskExtended("Resume of A", { agentId: agent.id });
+    const rb = await createTaskExtended("Resume of B", { agentId: agent.id });
+
+    for (const parent of [a, b]) {
+      await startTask(parent.id);
+      await supersedeTask(parent.id, { reason: "crash_recovery", resumeTaskId: null });
+    }
+    await Promise.all([
+      backfillSupersedeTaskResumeTaskId(a.id, ra.id),
+      backfillSupersedeTaskResumeTaskId(b.id, rb.id),
+    ]);
+
+    const childAfter = await getTaskById(child.id);
+    expect(childAfter!.status).toBe("pending");
+    expect(childAfter!.dependsOn).toEqual([ra.id, rb.id]);
+  });
+
+  // A dependent's status changes right after any read the settlement makes.
+  // An accept out of `offered` is still never-started and must be re-pointed;
+  // the claim-into-in_progress guard is covered by the started-dependent test.
+  for (const moveTo of ["reviewing", "pending"] as const) {
+    test(`settlement racing offered -> ${moveTo} still re-points the dependent`, async () => {
+      const agent = await createAgent({
+        name: `cascade-worker-6e-${moveTo}`,
+        isLead: false,
+        status: "idle",
+        capabilities: [],
+      });
+
+      const parent = await createTaskExtended("Parent of offered dep", { agentId: agent.id });
+      const child = await createTaskExtended("Offered child", {
+        agentId: agent.id,
+        dependsOn: [parent.id],
+      });
+      const resume = await createTaskExtended("Resume for offered dep", { agentId: agent.id });
+      const client = getDbClient();
+      await client.run("UPDATE agent_tasks SET status = 'offered' WHERE id = ?", [child.id]);
+      await startTask(parent.id);
+      await supersedeTask(parent.id, { reason: "crash_recovery", resumeTaskId: null });
+
+      const query = client.query.bind(client);
+      let raced = false;
+      client.query = (async (sql: string, params?: unknown[]) => {
+        const rows = (await query(sql, params as never)) as { id?: string; status?: string }[];
+        if (!raced && rows.some((r) => r.id === child.id && r.status === "offered")) {
+          raced = true;
+          await client.run("UPDATE agent_tasks SET status = ? WHERE id = ?", [moveTo, child.id]);
+        }
+        return rows;
+      }) as typeof client.query;
+      try {
+        await backfillSupersedeTaskResumeTaskId(parent.id, resume.id);
+      } finally {
+        client.query = query;
+      }
+      // No read to race (single-statement settlement): the accept lands after.
+      if (!raced) {
+        await client.run("UPDATE agent_tasks SET status = ? WHERE id = ?", [moveTo, child.id]);
+      }
+
+      const childAfter = await getTaskById(child.id);
+      expect(childAfter!.status).toBe(moveTo);
+      expect(childAfter!.dependsOn).toEqual([resume.id]);
+    });
+  }
+
   test("wide fan-out: multiple dependents all cascade-failed", async () => {
     const agent = await createAgent({
       name: "cascade-worker-7",

package/src/tests/tool-annotations.test.ts

@@ -378,7 +378,7 @@ describe("Tool Annotations & Classification", () => {
     // Includes 11 skill tools, 7 MCP server tools, reusable script tools, and the
     // native Kapso/WhatsApp tools (register/unregister number + send/reply message).
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(149);
+    expect(count).toBeLessThanOrEqual(151);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/usage-cache.test.ts

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, setSystemTime, test } from "bun:test";
+import {
+  cachedUsageReport,
+  clearUsageCache,
+  USAGE_CACHE_MAX_STALE_MS,
+  USAGE_CACHE_TTL_MS,
+} from "../http/usage-cache";
+
+const T0 = new Date("2026-09-29T12:00:00.000Z");
+
+function loader(values: unknown[]) {
+  let calls = 0;
+  const load = async () => {
+    const value = values[Math.min(calls, values.length - 1)];
+    calls++;
+    return value;
+  };
+  return { load, calls: () => calls };
+}
+
+// The background refresh is a promise chain; let it settle.
+const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe("cachedUsageReport", () => {
+  beforeEach(() => {
+    clearUsageCache();
+    setSystemTime(T0);
+  });
+  afterEach(() => {
+    clearUsageCache();
+    setSystemTime();
+  });
+
+  test("serves a fresh entry without loading again", async () => {
+    const source = loader(["a", "b"]);
+    expect(await cachedUsageReport("k", source.load)).toBe("a");
+    setSystemTime(new Date(T0.getTime() + USAGE_CACHE_TTL_MS - 1));
+    expect(await cachedUsageReport("k", source.load)).toBe("a");
+    expect(source.calls()).toBe(1);
+  });
+
+  test("keeps keys apart", async () => {
+    const source = loader(["a", "b"]);
+    expect(await cachedUsageReport("one", source.load)).toBe("a");
+    expect(await cachedUsageReport("two", source.load)).toBe("b");
+    expect(source.calls()).toBe(2);
+  });
+
+  test("past the bucket it answers with the stale value and refreshes once in the background", async () => {
+    const source = loader(["old", "new"]);
+    await cachedUsageReport("k", source.load);
+
+    setSystemTime(new Date(T0.getTime() + USAGE_CACHE_TTL_MS + 1));
+    expect(await cachedUsageReport("k", source.load)).toBe("old");
+    expect(await cachedUsageReport("k", source.load)).toBe("old");
+    await settle();
+    // One refresh served both stale reads.
+    expect(source.calls()).toBe(2);
+    expect(await cachedUsageReport("k", source.load)).toBe("new");
+    expect(source.calls()).toBe(2);
+  });
+
+  test("a stale read does not wait for the refresh", async () => {
+    let release: (value: string) => void = () => {};
+    const slow = new Promise<string>((resolve) => {
+      release = resolve;
+    });
+    await cachedUsageReport("k", async () => "old");
+
+    setSystemTime(new Date(T0.getTime() + USAGE_CACHE_TTL_MS + 1));
+    expect(await cachedUsageReport("k", () => slow)).toBe("old");
+    release("new");
+    await settle();
+    expect(await cachedUsageReport("k", async () => "unused")).toBe("new");
+  });
+
+  test("blocks on a load once an entry is older than the stale limit", async () => {
+    const source = loader(["old", "new"]);
+    await cachedUsageReport("k", source.load);
+
+    setSystemTime(new Date(T0.getTime() + USAGE_CACHE_MAX_STALE_MS + 1));
+    expect(await cachedUsageReport("k", source.load)).toBe("new");
+    expect(source.calls()).toBe(2);
+  });
+
+  test("concurrent misses share one load", async () => {
+    let calls = 0;
+    const load = async () => {
+      calls++;
+      await settle();
+      return "shared";
+    };
+    const results = await Promise.all([
+      cachedUsageReport("k", load),
+      cachedUsageReport("k", load),
+      cachedUsageReport("k", load),
+    ]);
+    expect(results).toEqual(["shared", "shared", "shared"]);
+    expect(calls).toBe(1);
+  });
+
+  test("a failed background refresh keeps the stale value and the next read retries", async () => {
+    await cachedUsageReport("k", async () => "old");
+    setSystemTime(new Date(T0.getTime() + USAGE_CACHE_TTL_MS + 1));
+
+    const original = console.error;
+    console.error = () => {};
+    try {
+      expect(
+        await cachedUsageReport("k", async () => {
+          throw new Error("db busy");
+        }),
+      ).toBe("old");
+      await settle();
+    } finally {
+      console.error = original;
+    }
+
+    expect(await cachedUsageReport("k", async () => "retried")).toBe("old");
+    await settle();
+    expect(await cachedUsageReport("k", async () => "unused")).toBe("retried");
+  });
+
+  test("a load with no stale value to fall back on rejects to the caller", async () => {
+    await expect(
+      cachedUsageReport("k", async () => {
+        throw new Error("db busy");
+      }),
+    ).rejects.toThrow("db busy");
+    // The failure is not cached.
+    expect(await cachedUsageReport("k", async () => "ok")).toBe("ok");
+  });
+
+  test("clearing drops entries, and a load already running cannot write back", async () => {
+    let release: (value: string) => void = () => {};
+    const inFlight = new Promise<string>((resolve) => {
+      release = resolve;
+    });
+    const pending = cachedUsageReport("k", () => inFlight);
+
+    clearUsageCache();
+    release("before-clear");
+    expect(await pending).toBe("before-clear");
+
+    // Nothing was stored, so the next read loads again.
+    expect(await cachedUsageReport("k", async () => "after-clear")).toBe("after-clear");
+  });
+
+  test("evicts the oldest entry past the size cap", async () => {
+    for (let i = 0; i < 100; i++) await cachedUsageReport(`k${i}`, async () => `v${i}`);
+    await cachedUsageReport("extra", async () => "extra");
+
+    let reloaded = false;
+    await cachedUsageReport("k0", async () => {
+      reloaded = true;
+      return "v0-again";
+    });
+    expect(reloaded).toBe(true);
+    let survivorReloaded = false;
+    await cachedUsageReport("k99", async () => {
+      survivorReloaded = true;
+      return "unused";
+    });
+    expect(survivorReloaded).toBe(false);
+  });
+});

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

@@ -984,7 +984,7 @@ describe("ValidateExecutor", () => {
 // ─── Registry Wiring ─────────────────────────────────────────
 
 describe("createExecutorRegistry", () => {
-  test("registers all 12 executors (8 instant + 4 async)", () => {
+  test("registers all 13 executors (9 instant + 4 async)", () => {
     const registry = createExecutorRegistry(mockDeps);
     const types = registry.types();
 
@@ -992,6 +992,7 @@ describe("createExecutorRegistry", () => {
     expect(types).toContain("code-match");
     expect(types).toContain("notify");
     expect(types).toContain("raw-llm");
+    expect(types).toContain("system-one-decision");
     expect(types).toContain("script");
     expect(types).toContain("swarm-script");
     expect(types).toContain("vcs");
@@ -1000,7 +1001,7 @@ describe("createExecutorRegistry", () => {
     expect(types).toContain("foreach");
     expect(types).toContain("human-in-the-loop");
     expect(types).toContain("wait");
-    expect(types).toHaveLength(12);
+    expect(types).toHaveLength(13);
   });
 
   test("instant executors have mode instant, async executors have mode async", () => {
@@ -1022,6 +1023,8 @@ describe("createExecutorRegistry", () => {
     expect(registry.get("foreach").mode).toBe("async");
     expect(registry.get("human-in-the-loop").mode).toBe("async");
     expect(registry.get("wait").mode).toBe("async");
+    // Answers at once, but waits when `humanReview` sends an answer to a person.
+    expect(registry.get("system-one-decision").mode).toBe("async");
   });
 
   test("get() retrieves the correct executor by type", () => {