@desplega.ai/agent-swarm 2.7.5 → 2.7.7

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

@@ -1,9 +1,17 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, getScheduledTasks, initDb, listWorkflows } from "../be/db";
+import {
+  closeDb,
+  getScheduledTaskByName,
+  getScheduledTasks,
+  initDb,
+  listWorkflows,
+} from "../be/db";
+import { getScript } from "../be/scripts/db";
 import { runSeeder, SEEDERS } from "../be/seed";
 import { schedulesSeeder } from "../be/seed/schedules-seeder";
 import { workflowsSeeder } from "../be/seed/workflows-seeder";
+import { scriptsSeeder } from "../be/seed-scripts";
 
 const TEST_DB_PATH = "./test-seed-registry.sqlite";
 
@@ -58,15 +66,29 @@ describe("seeder registry", () => {
     }
   });
 
-  test("seeds all 23 automation templates on a fresh database and re-runs as a no-op", async () => {
+  test("seeds all 22 automation templates on a fresh database and re-runs as a no-op", async () => {
     expect(await listWorkflows()).toHaveLength(0);
     expect(await getScheduledTasks()).toHaveLength(0);
 
+    // Boot order: scripts seed before schedules, so a script-target schedule
+    // (daily-swarm-update-check) resolves its catalog script on a fresh install.
+    const order = SEEDERS.map((seeder) => seeder.kind);
+    expect(order.indexOf("script")).toBeLessThan(order.indexOf("schedule"));
+    expect(await getScript({ name: "swarm-update-check", scope: "global" })).toBeNull();
+    const scriptResult = await runSeeder(scriptsSeeder, {
+      quiet: true,
+      scriptEmbeddingMode: "skip",
+    });
     const workflowResult = await runSeeder(workflowsSeeder, { quiet: true });
     const scheduleResult = await runSeeder(schedulesSeeder, { quiet: true });
 
+    expect(scriptResult.failed).toEqual([]);
     expect(workflowResult).toMatchObject({ created: 11, failed: [] });
-    expect(scheduleResult).toMatchObject({ created: 12, failed: [] });
+    expect(scheduleResult).toMatchObject({ created: 11, failed: [] });
+    expect(await getScheduledTaskByName("daily-swarm-update-check")).toMatchObject({
+      targetType: "script",
+      scriptName: "swarm-update-check",
+    });
     expect((await listWorkflows()).map((workflow) => workflow.name).sort()).toEqual(
       workflowsSeeder.items().map((item) => item.key),
     );
@@ -83,10 +105,10 @@ describe("seeder registry", () => {
     expect(await runSeeder(schedulesSeeder, { quiet: true })).toMatchObject({
       created: 0,
       updated: 0,
-      skippedUnchanged: 12,
+      skippedUnchanged: 11,
       failed: [],
     });
     expect(await listWorkflows()).toHaveLength(11);
-    expect(await getScheduledTasks()).toHaveLength(12);
-  });
+    expect(await getScheduledTasks()).toHaveLength(11);
+  }, 60_000); // typechecks every catalog script with tsc
 });

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

@@ -8,6 +8,7 @@ import {
   initDb,
   updateScheduledTask,
 } from "../be/db";
+import { upsertScriptByName } from "../be/scripts/db";
 import { runSeeder } from "../be/seed";
 import {
   createSchedulesSeeder,
@@ -15,6 +16,7 @@ import {
   type ScheduleTemplateSource,
 } from "../be/seed/schedules-seeder";
 import { createWorkflowsSeeder } from "../be/seed/workflows-seeder";
+import { SEED_SCRIPTS } from "../be/seed-scripts";
 
 const TEST_DB_PATH = "./test-seed-schedules.sqlite";
 
@@ -95,6 +97,23 @@ function targetScheduleSource(target: Record<string, unknown>, prompt?: string)
   } satisfies ScheduleTemplateSource;
 }
 
+/** Stand-in for the catalog script daily-swarm-update-check targets; boot seeds the real one first. */
+async function seedUpdateCheckScript() {
+  await upsertScriptByName({
+    name: "swarm-update-check",
+    scope: "global",
+    scopeId: null,
+    source: "export default async function main() { return {}; }",
+    description: "test stand-in",
+    intent: "seed-schedules test fixture",
+    signatureJson: "{}",
+    fsMode: "none",
+    agentId: null,
+    isScratch: false,
+    typeChecked: true,
+  });
+}
+
 async function makeWorkflow(name: string) {
   return createWorkflow({ name, definition: { nodes: [] } });
 }
@@ -118,9 +137,9 @@ afterEach(async () => {
 });
 
 describe("schedules seeder", () => {
-  test("loads all twelve schedule templates, including the unfenced schedule block", () => {
+  test("loads all eleven schedule templates, including the unfenced schedule block", () => {
     const schedules = loadSeedSchedules();
-    expect(schedules).toHaveLength(12);
+    expect(schedules).toHaveLength(11);
     // Zero-config, requires:[], placeholders:[], template enabled:true -> auto-enabled
     // under the default (unset -> on) SEED_AUTOMATIONS_ENABLED switch.
     expect(schedules.find((schedule) => schedule.name === "daily-status-report")).toMatchObject({
@@ -135,6 +154,11 @@ describe("schedules seeder", () => {
       enabled: true,
       requiredParams: [],
       requires: [],
+      // A script fire: no agent task, no prompt.
+      targetType: "script",
+      scriptName: "swarm-update-check",
+      scriptArgs: {},
+      taskTemplate: "",
     });
     expect(
       schedules.find((schedule) => schedule.name === "weekly-harness-upgrade-check"),
@@ -149,9 +173,10 @@ describe("schedules seeder", () => {
       "daily-blocker-digest",
       "daily-status-report",
       "daily-swarm-update-check",
-      "daily-workflow-health-audit",
       "dreaming-daily",
     ]);
+    // The status report absorbed the workflow-health audit's six queries.
+    expect(schedules.map((schedule) => schedule.name)).not.toContain("daily-workflow-health-audit");
     // dreaming replaces Daily Evolution, which seeds off even though it is zero-config.
     expect(
       schedules.find((schedule) => schedule.name === "daily-compounding-reflection"),
@@ -160,20 +185,22 @@ describe("schedules seeder", () => {
 
   test("SEED_AUTOMATIONS_ENABLED=false still seeds all schedules disabled", async () => {
     process.env.SEED_AUTOMATIONS_ENABLED = "false";
-    // dreaming-daily targets the seeded dreaming workflow.
+    // dreaming-daily targets the seeded dreaming workflow, daily-swarm-update-check a catalog script.
     await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    await seedUpdateCheckScript();
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
-    expect(result).toMatchObject({ created: 12, failed: [] });
+    expect(result).toMatchObject({ created: 11, failed: [] });
     const schedules = await getScheduledTasks();
-    expect(schedules).toHaveLength(12);
+    expect(schedules).toHaveLength(11);
     expect(schedules.every((schedule) => schedule.enabled === false)).toBe(true);
   });
 
   test("seeds a disabled schedule whose timezone still needs setup", async () => {
-    // dreaming-daily targets the seeded dreaming workflow.
+    // dreaming-daily targets the seeded dreaming workflow, daily-swarm-update-check a catalog script.
     await runSeeder(createWorkflowsSeeder(), { quiet: true });
+    await seedUpdateCheckScript();
     const result = await runSeeder(createSchedulesSeeder(), { quiet: true });
-    expect(result).toMatchObject({ created: 12, failed: [] });
+    expect(result).toMatchObject({ created: 11, failed: [] });
     expect(await getScheduledTaskByName("weekly-dependabot-triage")).toMatchObject({
       cronExpression: "40 3 * * 0",
       timezone: "{{TIMEZONE}}",
@@ -313,6 +340,32 @@ describe("schedules seeder", () => {
     expect(result.failed[0]?.error).toContain('Global script "no-such-script" not found');
   });
 
+  test("daily-swarm-update-check runs the catalog's swarm-update-check script, no agent task", async () => {
+    // The scripts catalog ships the target, so boot's script seeder creates it first.
+    expect(SEED_SCRIPTS.map((script) => script.name)).toContain("swarm-update-check");
+    const updateCheck = loadSeedSchedules().filter(
+      (schedule) => schedule.name === "daily-swarm-update-check",
+    );
+    expect(updateCheck).toHaveLength(1);
+
+    // Control: without the script the item fails instead of seeding an agent task.
+    const seeder = createSchedulesSeeder();
+    const before = await runSeeder(seeder, { quiet: true });
+    expect(before.failed.map((failure) => failure.key)).toContain("daily-swarm-update-check");
+    expect(await getScheduledTaskByName("daily-swarm-update-check")).toBeNull();
+
+    await seedUpdateCheckScript();
+    await runSeeder(seeder, { quiet: true });
+    const row = await getScheduledTaskByName("daily-swarm-update-check");
+    expect(row).toMatchObject({
+      targetType: "script",
+      scriptName: "swarm-update-check",
+      scriptArgs: {},
+      enabled: true,
+    });
+    expect(row?.taskTemplate).toBeUndefined();
+  });
+
   test("fails a workflow target whose workflow does not exist, without creating a row", async () => {
     const result = await runSeeder(
       createSchedulesSeeder([

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

@@ -20,6 +20,10 @@ import opsCatalogAudit, {
   renderPage as renderOpsCatalogAuditPage,
 } from "../be/seed-scripts/catalog/ops-catalog-audit";
 import scheduleHealth from "../be/seed-scripts/catalog/schedule-health";
+import swarmUpdateCheck, {
+  compareVersions,
+  parseVersion,
+} from "../be/seed-scripts/catalog/swarm-update-check";
 import taskContextGathering from "../be/seed-scripts/catalog/task-context-gathering";
 import taskFailureAudit from "../be/seed-scripts/catalog/task-failure-audit";
 import { extractScriptSignature } from "../scripts-runtime/extract-signature";
@@ -62,8 +66,8 @@ afterAll(async () => {
 });
 
 describe("seed-scripts catalog", () => {
-  test("manifest holds 39 unique, well-described scripts", () => {
-    expect(SEED_SCRIPTS.length).toBe(39);
+  test("manifest holds 40 unique, well-described scripts", () => {
+    expect(SEED_SCRIPTS.length).toBe(40);
     const names = SEED_SCRIPTS.map((s) => s.name);
     expect(new Set(names).size).toBe(names.length);
     for (const s of SEED_SCRIPTS) {
@@ -217,6 +221,32 @@ describe("seed-scripts catalog", () => {
     ).toHaveLength(200);
   });
 
+  test.each([
+    ["Incomplete response returned, reason: max_output_tokens", "output-limit"],
+    ["Stopped: max_tokens", "output-limit"],
+    ["Maximum output length exceeded", "output-limit"],
+    ["Output token limit reached", "output-limit"],
+    ["401 Unauthorized", "auth/credentials"],
+    ["invalid token", "auth/credentials"],
+    ["Resource not accessible by personal access token", "auth/credentials"],
+    ["Processed 100 tokens", "other"],
+    ["max_input_tokens exceeded", "other"],
+  ])("task-failure-audit classifies %s as %s", async (failureReason, expectedKey) => {
+    const result = await taskFailureAudit(
+      { publishPage: false },
+      {
+        swarm: {
+          async task_list() {
+            return { data: { tasks: [{ id: "failed-task", failureReason }] } };
+          },
+        },
+      },
+    );
+
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].key).toBe(expectedKey);
+  });
+
   test("task-failure-audit projects failure reasons into schedule-group samples", async () => {
     let projectionArgs: Record<string, unknown> | undefined;
     const result = await taskFailureAudit(
@@ -1974,3 +2004,139 @@ describe("dreaming-heartbeat check refuses a worker-chosen draftPath", () => {
     expect(out.reasons.join(" ")).not.toContain("draftPath");
   });
 });
+
+describe("swarm-update-check", () => {
+  const RELEASES = "https://api.github.com/repos/desplega-ai/agent-swarm/releases/latest";
+
+  /** Fake API + GitHub: `/health` answers `running`, the release endpoint `release`. */
+  function fakeCtx(opts: {
+    running?: string | null;
+    release?: { status: number; body?: unknown } | "network-error";
+    agents?: unknown[];
+  }) {
+    const fetches: { url: string; retries?: number }[] = [];
+    const sent: any[] = [];
+    const stdlib = {
+      Redacted: { value: (v: unknown) => v },
+      fetch: async (url: string, init: { retries?: number } = {}) => {
+        fetches.push({ url, retries: init.retries });
+        if (url === "http://api.test/health") {
+          return new Response(
+            JSON.stringify(opts.running === null ? {} : { version: opts.running }),
+          );
+        }
+        if (url === RELEASES) {
+          const release = opts.release ?? { status: 200, body: {} };
+          if (release === "network-error") throw new Error("getaddrinfo ENOTFOUND");
+          return new Response(JSON.stringify(release.body ?? {}), { status: release.status });
+        }
+        return new Response("{}", { status: 404 });
+      },
+    };
+    const swarm = {
+      config: { mcpBaseUrl: "http://api.test/" },
+      async swarm_get() {
+        return {
+          success: true,
+          status: 200,
+          data: {
+            agents: opts.agents ?? [
+              { id: "worker-1", isLead: false },
+              { id: "lead-1", isLead: true },
+            ],
+          },
+        };
+      },
+      async task_send(args: unknown) {
+        sent.push(args);
+        return { success: true, status: 200, data: { success: true, task: { id: "notify-1" } } };
+      },
+    };
+    return { ctx: { stdlib, swarm }, fetches, sent };
+  }
+
+  const release = (tag: string) => ({
+    status: 200,
+    body: {
+      tag_name: tag,
+      html_url: `https://github.com/desplega-ai/agent-swarm/releases/tag/${tag}`,
+    },
+  });
+
+  test("compares versions numerically, never as strings", () => {
+    expect(compareVersions(parseVersion("1.10.0")!, parseVersion("1.9.0")!)).toBeGreaterThan(0);
+    expect(compareVersions(parseVersion("v2.0.0")!, parseVersion("2.0.0")!)).toBe(0);
+    expect(parseVersion("1.2")).toBeNull();
+    expect(parseVersion(undefined)).toBeNull();
+  });
+
+  test("a newer release notifies the lead once, with the versions and release URL", async () => {
+    const { ctx, sent } = fakeCtx({ running: "1.9.0", release: release("v1.10.0") });
+    const result: any = await swarmUpdateCheck({}, ctx);
+    expect(result).toMatchObject({
+      checked: true,
+      status: "update-available",
+      running: "1.9.0",
+      latest: "1.10.0",
+      notified: true,
+      leadTaskId: "notify-1",
+    });
+    expect(sent).toHaveLength(1);
+    expect(sent[0]).toMatchObject({ agentId: "lead-1", routingReason: "skill" });
+    expect(sent[0].task).toContain("running 1.9.0, latest 1.10.0");
+    expect(sent[0].task).toContain(
+      "https://github.com/desplega-ai/agent-swarm/releases/tag/v1.10.0",
+    );
+    expect(sent[0].task).toContain("admin delivery channel");
+  });
+
+  test("control: up to date and older-than-running releases notify nobody", async () => {
+    for (const tag of ["v1.10.0", "v1.9.9"]) {
+      const { ctx, sent } = fakeCtx({ running: "1.10.0", release: release(tag) });
+      const result: any = await swarmUpdateCheck({}, ctx);
+      expect(result).toMatchObject({ checked: true, status: "up-to-date" });
+      expect(sent).toHaveLength(0);
+    }
+  });
+
+  test("a missing running version is unknown, not up to date, and skips GitHub", async () => {
+    const { ctx, sent, fetches } = fakeCtx({ running: null, release: release("v9.0.0") });
+    const result: any = await swarmUpdateCheck({}, ctx);
+    expect(result).toMatchObject({ checked: false, status: "unknown" });
+    expect(result.message).toContain("Unable to determine running version");
+    expect(fetches.map((f) => f.url)).not.toContain(RELEASES);
+    expect(sent).toHaveLength(0);
+  });
+
+  test("a failed GitHub call is reported after one attempt and notifies nobody", async () => {
+    for (const failure of [
+      { status: 403, body: { message: "rate limited" } },
+      "network-error" as const,
+    ]) {
+      const { ctx, sent, fetches } = fakeCtx({ running: "1.0.0", release: failure });
+      const result: any = await swarmUpdateCheck({}, ctx);
+      expect(result).toMatchObject({ checked: false, status: "github-unreachable" });
+      expect(result.message).toContain("Could not reach GitHub releases API");
+      const github = fetches.filter((f) => f.url === RELEASES);
+      expect(github).toHaveLength(1);
+      expect(github[0]?.retries).toBe(1);
+      expect(sent).toHaveLength(0);
+    }
+  });
+
+  test("dryRun reports the update without notifying", async () => {
+    const { ctx, sent } = fakeCtx({ running: "1.0.0", release: release("v1.0.1") });
+    const result: any = await swarmUpdateCheck({ dryRun: true }, ctx);
+    expect(result).toMatchObject({ status: "update-available", notified: false });
+    expect(sent).toHaveLength(0);
+  });
+
+  test("an update with no lead to notify fails the run", async () => {
+    const { ctx } = fakeCtx({
+      running: "1.0.0",
+      release: release("v1.0.1"),
+      agents: [{ id: "worker-1", isLead: false }],
+    });
+    await expect(swarmUpdateCheck({}, ctx)).rejects.toThrow("no lead to notify");
+  });
+});

package/src/tests/slack-leave-thread.test.ts

@@ -9,6 +9,7 @@ import {
   createTaskExtended,
   createWorkflow,
   deleteSwarmConfig,
+  getKv,
   getSlackTasksInThread,
   initDb,
   updateWorkflow,
@@ -19,9 +20,14 @@ import { invokeToolInProcess, resetBridgeServerForTesting } from "../http/mcp-br
 import { handleTasks } from "../http/tasks";
 import { reservedNamespaceError } from "../kv-reserved-namespaces";
 import { createServer as createMcpServer } from "../server";
+import { registerCommandHandler } from "../slack/commands";
 import { registerMessageHandler, resetSlackHandlerCachesForTesting } from "../slack/handlers";
-import { isSlackThreadLeft, SLACK_LEFT_THREAD_KV_NAMESPACE } from "../slack/left-threads";
-import { bufferThreadMessage, instantFlush } from "../slack/thread-buffer";
+import {
+  isSlackThreadLeft,
+  SLACK_LEFT_THREAD_CONFIRMATION,
+  SLACK_LEFT_THREAD_KV_NAMESPACE,
+} from "../slack/left-threads";
+import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "../slack/thread-buffer";
 import { slackContextKey } from "../tasks/context-key";
 import { registerSlackLeaveThreadTool } from "../tools/slack-leave-thread";
 import type { Agent, AgentTask } from "../types";
@@ -45,6 +51,8 @@ const previousEnv = {
 
 type Handler = (args: Record<string, unknown>) => Promise<void>;
 const handlers = new Map<string, Handler>();
+const commands = new Map<string, Handler>();
+const ephemerals: Array<Record<string, unknown>> = [];
 
 const client = {
   auth: { test: async () => ({ user_id: BOT_USER_ID, bot_id: "B_LEAVE_BOT" }) },
@@ -52,7 +60,13 @@ const client = {
     info: async () => ({ ok: true, channel: {} }),
     replies: async () => ({ ok: true, messages: [] }),
   },
-  chat: { postMessage: async () => ({ ok: true, ts: "1.1" }) },
+  chat: {
+    postMessage: async () => ({ ok: true, ts: "1.1" }),
+    postEphemeral: async (args: Record<string, unknown>) => {
+      ephemerals.push(args);
+      return { ok: true };
+    },
+  },
   reactions: { add: async () => ({ ok: true }) },
   users: { info: async () => ({ ok: true, user: { profile: {} } }) },
 };
@@ -99,10 +113,10 @@ let lead: Agent;
 let worker: Agent;
 let otherWorker: Agent;
 
-async function seedThread(channel: string, threadTs: string) {
+async function seedThread(channel: string, threadTs: string, opts: { unassigned?: boolean } = {}) {
   // As the Slack handlers create it: only Slack ingress writes slackTriggerMessageTs.
   return createTaskExtended("original ask", {
-    agentId: worker.id,
+    agentId: opts.unassigned ? undefined : worker.id,
     source: "slack",
     slackChannelId: channel,
     slackThreadTs: threadTs,
@@ -158,6 +172,11 @@ beforeAll(async () => {
       handlers.set(type, handler);
     },
   } as never);
+  registerCommandHandler({
+    command: (name: string, handler: Handler) => {
+      commands.set(name, handler);
+    },
+  } as never);
 
   routeServer = createServer(async (req, res) => {
     setRequestAuth(req, { kind: "operator", fingerprint: "test-key" });
@@ -192,6 +211,7 @@ afterAll(async () => {
 
 beforeEach(() => {
   resetSlackHandlerCachesForTesting();
+  ephemerals.length = 0;
 });
 
 describe("slack-leave-thread", () => {
@@ -429,3 +449,123 @@ describe("SLACK_LEAVE_THREAD_DISABLE", () => {
     }
   });
 });
+
+describe("!leave", () => {
+  test("leaves the thread in code: no task, no workflow event, an ephemeral confirmation", async () => {
+    const emitted: unknown[] = [];
+    const listener = (payload: unknown) => emitted.push(payload);
+    workflowEventBus.on("slack.message", listener);
+    try {
+      await seedThread("C_BANG_A", "3000.0001");
+      expect(await sendThreadReply("C_BANG_A", "3000.0001", "!leave")).toHaveLength(1);
+      expect(emitted).toHaveLength(0);
+    } finally {
+      workflowEventBus.off("slack.message", listener);
+    }
+
+    expect(await isSlackThreadLeft("C_BANG_A", "3000.0001")).toBe(true);
+    const entry = await getKv(SLACK_LEFT_THREAD_KV_NAMESPACE, "C_BANG_A:3000.0001");
+    expect(entry?.value).toMatchObject({ slackUserId: HUMAN });
+    expect(entry?.value).not.toHaveProperty("agentId");
+    expect(ephemerals).toEqual([
+      {
+        channel: "C_BANG_A",
+        user: HUMAN,
+        thread_ts: "3000.0001",
+        text: SLACK_LEFT_THREAD_CONFIRMATION,
+      },
+    ]);
+
+    expect(await sendThreadReply("C_BANG_A", "3000.0001", "chatting among ourselves")).toHaveLength(
+      1,
+    );
+    expect(
+      await sendThreadReply("C_BANG_A", "3000.0001", `<@${BOT_USER_ID}> back please`),
+    ).toHaveLength(2);
+    expect(await isSlackThreadLeft("C_BANG_A", "3000.0001")).toBe(false);
+  });
+
+  test("an @mention before !leave leaves instead of rejoining, also in a left thread", async () => {
+    await seedThread("C_BANG_B", "3100.0001");
+    await sendThreadReply("C_BANG_B", "3100.0001", "!leave");
+    expect(await sendThreadReply("C_BANG_B", "3100.0001", `<@${BOT_USER_ID}> !leave`)).toHaveLength(
+      1,
+    );
+    expect(await isSlackThreadLeft("C_BANG_B", "3100.0001")).toBe(true);
+    expect(ephemerals).toHaveLength(2);
+  });
+
+  test("with ADDITIVE_SLACK the !leave message is never buffered", async () => {
+    process.env.ADDITIVE_SLACK = "true";
+    try {
+      await seedThread("C_BANG_C", "3200.0001");
+      await sendThreadReply("C_BANG_C", "3200.0001", "!leave");
+      expect(getBufferMessageCount("C_BANG_C:3200.0001")).toBe(0);
+      expect(await isSlackThreadLeft("C_BANG_C", "3200.0001")).toBe(true);
+    } finally {
+      process.env.ADDITIVE_SLACK = "false";
+    }
+  });
+
+  test.each([
+    ["!leave", "3600.0001"],
+    [`<@${BOT_USER_ID}> !leave`, "3600.0002"],
+  ])("leaves a human-rooted thread whose only task is unassigned: %s", async (text, threadTs) => {
+    const emitted: unknown[] = [];
+    const listener = (payload: unknown) => emitted.push(payload);
+    workflowEventBus.on("slack.message", listener);
+    try {
+      const seeded = await seedThread("C_BANG_G", threadTs, { unassigned: true });
+      expect(seeded.agentId).toBeNull();
+      expect(await sendThreadReply("C_BANG_G", threadTs, text)).toHaveLength(1);
+      expect(emitted).toHaveLength(0);
+    } finally {
+      workflowEventBus.off("slack.message", listener);
+    }
+    expect(await isSlackThreadLeft("C_BANG_G", threadTs)).toBe(true);
+    expect(ephemerals).toHaveLength(1);
+  });
+
+  test("a task in another thread of the channel does not make !leave a command", async () => {
+    await seedThread("C_BANG_H", "3700.0001", { unassigned: true });
+    await sendThreadReply("C_BANG_H", "3700.0002", "!leave");
+    expect(await isSlackThreadLeft("C_BANG_H", "3700.0002")).toBe(false);
+    expect(ephemerals).toHaveLength(0);
+  });
+
+  test("is not a command outside a swarm thread, when addressed elsewhere, or with extra text", async () => {
+    await sendThreadReply("C_BANG_D", "3300.0001", "!leave");
+    expect(await isSlackThreadLeft("C_BANG_D", "3300.0001")).toBe(false);
+
+    await seedThread("C_BANG_E", "3400.0001");
+    await sendThreadReply("C_BANG_E", "3400.0001", "<@U_SOMEONE_ELSE> !leave");
+    await sendThreadReply("C_BANG_E", "3400.0001", "!leave it to me");
+    expect(await isSlackThreadLeft("C_BANG_E", "3400.0001")).toBe(false);
+    expect(ephemerals).toHaveLength(0);
+  });
+
+  test("SLACK_LEAVE_THREAD_DISABLE makes !leave an ordinary message and hides it from help", async () => {
+    async function helpText(): Promise<string> {
+      let text = "";
+      await commands.get("/agent-swarm-help")!({
+        ack: async () => {},
+        respond: async (reply: { blocks: Array<{ text: { text: string } }> }) => {
+          text = reply.blocks.map((b) => b.text.text).join("\n");
+        },
+      });
+      return text;
+    }
+    expect(await helpText()).toContain("`!leave` in a thread");
+
+    process.env.SLACK_LEAVE_THREAD_DISABLE = "true";
+    try {
+      await seedThread("C_BANG_F", "3500.0001");
+      expect(await sendThreadReply("C_BANG_F", "3500.0001", "!leave")).toHaveLength(2);
+      expect(await isSlackThreadLeft("C_BANG_F", "3500.0001")).toBe(false);
+      expect(ephemerals).toHaveLength(0);
+      expect(await helpText()).not.toContain("!leave");
+    } finally {
+      delete process.env.SLACK_LEAVE_THREAD_DISABLE;
+    }
+  });
+});

package/src/tests/slack-render-v2-query-plans.test.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite";
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import {
   closeDb,
@@ -6,6 +7,7 @@ import {
   getDb,
   getDbClient,
   getResolvableDeferralOutcomes,
+  getSlackTreeMessages,
   initDb,
   recordSlackMessage,
 } from "../be/db";
@@ -93,12 +95,32 @@ describe("slack render-v2 watcher queries", () => {
     closeDb();
   });
 
+  test("the tree sweep tests thread tasks in the covering index, not task rows", async () => {
+    const sql = await capturedSql(() => getSlackTreeMessages());
+    const detail = plan(sql);
+    const uses = "SEARCH task USING COVERING INDEX idx_agent_tasks_slack_thread_cover";
+    expect(detail.split(uses).length - 1).toBe(3);
+    // Control: without migration 264 the same tests read the task rows.
+    const copy = Database.deserialize(getDb().serialize());
+    try {
+      copy.run("DROP INDEX idx_agent_tasks_slack_thread_cover");
+      const reverted = copy
+        .query<{ detail: string }, []>(`EXPLAIN QUERY PLAN ${sql}`)
+        .all()
+        .map((row) => row.detail)
+        .join("\n");
+      expect(reverted).not.toContain(uses);
+    } finally {
+      copy.close();
+    }
+  });
+
   test("deferral resolution drives from the chain, not from every task", async () => {
     const sql = await capturedSql(() => getResolvableDeferralOutcomes());
     const detail = plan(sql, [50]);
-    // Either parentTaskId-led index is a seek on the chain's children.
+    // Any parentTaskId-led index is a seek on the chain's children.
     expect(detail).toMatch(
-      /SEARCH wake USING INDEX idx_agent_tasks_parentTaskId(_source)? \(parentTaskId=\?\)/,
+      /SEARCH wake USING INDEX idx_agent_tasks_parentTaskId(_source|_id)? \(parentTaskId=\?\)/,
     );
     expect(detail).not.toContain("idx_agent_tasks_taskType");
     expect(detail).not.toContain("idx_agent_tasks_status_last_updated");

package/src/tests/status.test.ts

@@ -87,6 +87,8 @@ const ENV_KEYS_TO_RESET = [
   "SWARM_BRAND_COLOR",
   "SWARM_MARKETING_URL",
   "SWARM_HIDE_CLOUD_PROMO",
+  "APP_URL",
+  "DASHBOARD_URL",
   "HARNESS_PROVIDER",
   "ANTHROPIC_API_KEY",
   "CLAUDE_CODE_OAUTH_TOKEN",
@@ -191,6 +193,7 @@ describe("buildStatusPayload — identity", () => {
       marketing_url: null,
       hide_cloud_promo: false,
       org_id: null,
+      dashboard_url: null,
     });
   });
 
@@ -212,9 +215,17 @@ describe("buildStatusPayload — identity", () => {
       marketing_url: "https://swarm.acme.example",
       hide_cloud_promo: true,
       org_id: "org_acme_123",
+      dashboard_url: null,
     });
   });
 
+  test("reports the configured dashboard URL: the first APP_URL entry, else DASHBOARD_URL", async () => {
+    process.env.DASHBOARD_URL = "https://old.example.com";
+    expect((await buildStatusPayload()).identity.dashboard_url).toBe("https://old.example.com");
+    process.env.APP_URL = "https://swarm.example.com/, https://other.example.com";
+    expect((await buildStatusPayload()).identity.dashboard_url).toBe("https://swarm.example.com");
+  });
+
   test("treats SWARM_CLOUD=1 the same as 'true'", async () => {
     process.env.SWARM_CLOUD = "1";
     const payload = await buildStatusPayload();