@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/tests/prompt-template-resolver.test.ts

@@ -1,7 +1,12 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { unlink } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
 import { closeDb, getPromptTemplates, initDb, upsertPromptTemplate } from "../be/db";
 import { seedDefaultTemplates } from "../be/seed-prompt-templates";
+import { handlePromptTemplates } from "../http/prompt-templates";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { getPromptTemplateDefaultDrift } from "../prompts/default-drift";
 import {
   clearTemplateDefinitions,
   getAllTemplateDefinitions,
@@ -13,6 +18,37 @@ import { restoreAllTemplateDefinitions } from "./template-registry-helpers";
 
 const TEST_DB_PATH = "./test-prompt-resolver.sqlite";
 
+async function dispatchPromptTemplates(path: string): Promise<unknown> {
+  const req = Readable.from([]) as IncomingMessage;
+  req.method = "GET";
+  req.url = path;
+
+  let body = "";
+  const res = {
+    headersSent: false,
+    writableEnded: false,
+    setHeader() {},
+    writeHead() {
+      this.headersSent = true;
+      return this;
+    },
+    end(chunk?: unknown) {
+      if (chunk !== undefined) body += String(chunk);
+      this.writableEnded = true;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  const handled = await handlePromptTemplates(
+    req,
+    res,
+    getPathSegments(path),
+    parseQueryParams(path),
+  );
+  expect(handled).toBe(true);
+  return JSON.parse(body);
+}
+
 describe("Prompt Template Resolver", () => {
   beforeAll(async () => {
     for (const suffix of ["", "-wal", "-shm"]) {
@@ -568,7 +604,8 @@ describe("Prompt Template Resolver", () => {
       expect(after[0].body).toBe("Updated default");
     });
 
-    test("re-seeding does not touch user customizations (isDefault=false)", () => {
+    test("re-seeding does not touch user customizations (isDefault=false)", async () => {
+      const warn = spyOn(console, "warn").mockImplementation(() => {});
       registerTemplate({
         eventType: "seed.test.custom",
         header: "",
@@ -583,7 +620,7 @@ describe("Prompt Template Resolver", () => {
       upsertPromptTemplate({
         eventType: "seed.test.custom",
         scope: "global",
-        body: "User custom body",
+        body: "Default body v1",
         changedBy: "user-123",
       });
 
@@ -594,14 +631,14 @@ describe("Prompt Template Resolver", () => {
       });
       expect(customized.length).toBe(1);
       expect(customized[0].isDefault).toBe(false);
-      expect(customized[0].body).toBe("User custom body");
+      expect(customized[0].body).toBe("Default body v1");
 
       // Re-seed with updated code
       clearTemplateDefinitions();
       registerTemplate({
         eventType: "seed.test.custom",
         header: "",
-        defaultBody: "Default body v2",
+        defaultBody: "Default body version 2",
         variables: [],
         category: "event",
       });
@@ -614,8 +651,142 @@ describe("Prompt Template Resolver", () => {
         scope: "global",
       });
       expect(afterReseed.length).toBe(1);
-      expect(afterReseed[0].body).toBe("User custom body");
+      expect(afterReseed[0].body).toBe("Default body v1");
+      expect(afterReseed[0].isDefault).toBe(false);
+      expect(
+        getPromptTemplateDefaultDrift(afterReseed[0], "Default body version 2").defaultDrifted,
+      ).toBe(true);
+      const response = (await dispatchPromptTemplates(
+        "/api/prompt-templates?eventType=seed.test.custom",
+      )) as { templates: Array<{ defaultDrifted: boolean }> };
+      expect(response.templates).toHaveLength(1);
+      expect(response.templates[0]?.defaultDrifted).toBe(true);
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(warn.mock.calls[0]?.[0]).toContain('"seed.test.custom"');
+      expect(warn.mock.calls[0]?.[0]).toContain("frozen for 0 hours");
+      expect(warn.mock.calls[0]?.[0]).toContain(
+        "byte delta +7 (code default 22 bytes, customization 15 bytes)",
+      );
+      warn.mockRestore();
+    });
+
+    test("customized templates matching the code default self-heal as defaults", async () => {
+      const warn = spyOn(console, "warn").mockImplementation(() => {});
+      registerTemplate({
+        eventType: "seed.test.custom-matching",
+        header: "",
+        defaultBody: "Still current",
+        variables: [],
+        category: "event",
+      });
+
+      seedDefaultTemplates();
+      upsertPromptTemplate({
+        eventType: "seed.test.custom-matching",
+        scope: "global",
+        body: "Still current",
+        changedBy: "user-123",
+      });
+      seedDefaultTemplates();
+
+      const customized = getPromptTemplates({
+        eventType: "seed.test.custom-matching",
+        scope: "global",
+      });
+      expect(customized).toHaveLength(1);
+      expect(customized[0].isDefault).toBe(true);
+      expect(getPromptTemplateDefaultDrift(customized[0], "Still current").defaultDrifted).toBe(
+        false,
+      );
+      const response = (await dispatchPromptTemplates(
+        "/api/prompt-templates?eventType=seed.test.custom-matching",
+      )) as { templates: Array<{ defaultDrifted: boolean; isDefault: boolean }> };
+      expect(response.templates).toHaveLength(1);
+      expect(response.templates[0]?.defaultDrifted).toBe(false);
+      expect(response.templates[0]?.isDefault).toBe(true);
+
+      clearTemplateDefinitions();
+      registerTemplate({
+        eventType: "seed.test.custom-matching",
+        header: "",
+        defaultBody: "Next code default",
+        variables: [],
+        category: "event",
+      });
+      seedDefaultTemplates();
+      const reconciled = getPromptTemplates({
+        eventType: "seed.test.custom-matching",
+        scope: "global",
+      });
+      expect(reconciled).toHaveLength(1);
+      expect(reconciled[0].body).toBe("Next code default");
+      expect(reconciled[0].isDefault).toBe(true);
+      expect(warn).not.toHaveBeenCalled();
+      warn.mockRestore();
+    });
+
+    test("customized templates matching the code default preserve skip_event state", () => {
+      registerTemplate({
+        eventType: "seed.test.custom-matching-skipped",
+        header: "",
+        defaultBody: "Still current",
+        variables: [],
+        category: "event",
+      });
+
+      seedDefaultTemplates();
+      const skipped = upsertPromptTemplate({
+        eventType: "seed.test.custom-matching-skipped",
+        scope: "global",
+        state: "skip_event",
+        body: "Still current",
+        changedBy: "user-123",
+      });
+      expect(skipped.isDefault).toBe(false);
+      expect(skipped.state).toBe("skip_event");
+
+      seedDefaultTemplates();
+
+      const afterReseed = getPromptTemplates({
+        eventType: "seed.test.custom-matching-skipped",
+        scope: "global",
+      });
+      expect(afterReseed).toHaveLength(1);
+      expect(afterReseed[0].body).toBe("Still current");
+      expect(afterReseed[0].state).toBe("skip_event");
       expect(afterReseed[0].isDefault).toBe(false);
+      expect(afterReseed[0].version).toBe(skipped.version);
+    });
+
+    test("unchanged default templates remain defaults without warnings", () => {
+      const warn = spyOn(console, "warn").mockImplementation(() => {});
+      registerTemplate({
+        eventType: "seed.test.default-unchanged",
+        header: "",
+        defaultBody: "Current default",
+        variables: [],
+        category: "event",
+      });
+
+      seedDefaultTemplates();
+      const seeded = getPromptTemplates({
+        eventType: "seed.test.default-unchanged",
+        scope: "global",
+      });
+      expect(seeded).toHaveLength(1);
+      expect(seeded[0].body).toBe("Current default");
+      expect(seeded[0].isDefault).toBe(true);
+
+      seedDefaultTemplates();
+      const unchanged = getPromptTemplates({
+        eventType: "seed.test.default-unchanged",
+        scope: "global",
+      });
+      expect(unchanged).toHaveLength(1);
+      expect(unchanged[0].body).toBe("Current default");
+      expect(unchanged[0].isDefault).toBe(true);
+      expect(warn).not.toHaveBeenCalled();
+      warn.mockRestore();
     });
 
     test("seeding with no registered templates is a no-op", () => {

package/src/tests/prompt-template-session.test.ts

@@ -68,7 +68,7 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 18 system templates are registered", () => {
+  test("all 19 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
@@ -89,6 +89,7 @@ describe("Session templates — registration", () => {
       "system.agent.services",
       "system.agent.artifacts",
       "system.agent.share_urls",
+      "system.agent.communication_style",
     ];
 
     for (const eventType of systemTemplates) {
@@ -113,7 +114,7 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 31 session/system templates registered", () => {
+  test("total of 32 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
     // 26 = the original 19 + `system.session.worker.pi` + `system.agent.seed_scripts`
@@ -124,7 +125,8 @@ describe("Session templates — registration", () => {
     // 30 = 29 + `system.agent.scheduling` (split out of context_mode so the
     // pi composites keep the scheduling rules without the ctx_* tool block).
     // 31 = 30 + `system.agent.apps`.
-    expect(sessionSystem.length).toBe(31);
+    // 32 = 31 + `system.agent.communication_style`.
+    expect(sessionSystem.length).toBe(32);
   });
 });
 
@@ -221,8 +223,15 @@ describe("Session templates — individual resolution", () => {
 
   test("system.agent.worker contains worker tools", () => {
     const result = resolveTemplate("system.agent.worker", {});
+    expect(result.text).toContain("Skills (CHECK BEFORE STARTING WORK)");
+    expect(result.text).toContain("researching");
+    expect(result.text).toContain("planning");
+    expect(result.text).toContain("code-reviewing");
     expect(result.text).toContain("store-progress");
     expect(result.text).toContain("task-action");
+    expect(result.text).toContain("Credential Hygiene");
+    expect(result.text).not.toContain("Slack Thread Updates");
+    expect(result.text).not.toContain("On start");
   });
 
   test("system.agent.register contains join-swarm", () => {
@@ -332,6 +341,9 @@ describe("Session templates — composite resolution", () => {
     // Contains register section
     expect(result.text).toContain("join-swarm");
 
+    // Lead is hinted to persist learned requester comms preferences
+    expect(result.text).toContain("persist them with its `comms` field");
+
     // Contains lead-specific section (not worker)
     expect(result.text).toContain("CRITICAL: You are a coordinator");
     expect(result.text).toContain("coordinator");
@@ -351,6 +363,9 @@ describe("Session templates — composite resolution", () => {
 
     // Contains system
     expect(result.text).toContain("System packages available");
+
+    // Contains communication style
+    expect(result.text).toContain("### Communication Style");
   });
 
   test("system.session.worker resolves all template references", () => {
@@ -387,6 +402,27 @@ describe("Session templates — composite resolution", () => {
 
     // Contains system
     expect(result.text).toContain("System packages available");
+
+    // Contains communication style
+    expect(result.text).toContain("### Communication Style");
+  });
+
+  test("communication style block resolves in every session composite", () => {
+    const composites = [
+      "system.session.lead",
+      "system.session.worker",
+      "system.session.worker.pi",
+      "system.session.lead.pi",
+      "system.session.worker.remote",
+    ];
+
+    for (const eventType of composites) {
+      const result = resolveTemplate(eventType, { role: "worker", agentId: "agent-001" });
+      expect(result.skipped).toBe(false);
+      expect(result.text).toContain("### Communication Style");
+      expect(result.text).toContain("Mirror the requester");
+      expect(result.text).toContain("Never use em dashes");
+    }
   });
 
   test("composite does NOT include conditional sections (agent_fs, services, artifacts)", () => {

package/src/tests/queue-stall-alarm.test.ts

@@ -0,0 +1,226 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, createTaskExtended, getDb, initDb, updateTaskVcs } from "../be/db";
+import {
+  _test,
+  checkQueueStall,
+  getQueueStallSnapshot,
+  isQueueStalled,
+  QUEUE_STALL_THRESHOLD_MS,
+} from "../queue-stall-alarm";
+
+const TEST_DB_PATH = "./test-queue-stall-alarm.sqlite";
+const NOW = new Date("2026-08-17T17:00:00.000Z");
+
+beforeAll(() => {
+  closeDb();
+  initDb(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  _test.resetState();
+  getDb().run("DELETE FROM agent_log");
+  getDb().run("DELETE FROM agent_tasks");
+  getDb().run("DELETE FROM agents");
+});
+
+afterAll(async () => {
+  _test.resetState();
+  closeDb();
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+});
+
+function setCreatedAt(taskId: string, createdAt: string): void {
+  getDb().run("UPDATE agent_tasks SET createdAt = ?, lastUpdatedAt = ? WHERE id = ?", [
+    createdAt,
+    createdAt,
+    taskId,
+  ]);
+  getDb().run(
+    "UPDATE agent_log SET createdAt = ? WHERE taskId = ? AND eventType = 'task_created'",
+    [createdAt, taskId],
+  );
+}
+
+describe("queue stall alarm", () => {
+  test("positive control: alerts when a claimable task is older than 30 minutes", async () => {
+    const worker = createAgent({ name: "worker", isLead: false, status: "idle" });
+    const task = createTaskExtended("Old claimable task", { agentId: worker.id });
+    setCreatedAt(task.id, "2026-08-17T16:29:59.000Z");
+    const notify = mock(async (_message: string) => {});
+
+    const snapshot = await checkQueueStall(NOW, notify);
+
+    expect(isQueueStalled(snapshot)).toBe(true);
+    expect(snapshot.claimableCount).toBe(1);
+    expect(snapshot.oldestTaskId).toBe(task.id);
+    expect(snapshot.oldestAgeMs).toBeGreaterThan(QUEUE_STALL_THRESHOLD_MS);
+    expect(notify).toHaveBeenCalledTimes(1);
+    expect(notify.mock.calls[0]?.[0]).toContain("queue pickup stalled");
+  });
+
+  test("negative control: an empty queue never alerts", async () => {
+    const notify = mock(async (_message: string) => {});
+
+    const snapshot = await checkQueueStall(NOW, notify);
+
+    expect(snapshot.claimableCount).toBe(0);
+    expect(isQueueStalled(snapshot)).toBe(false);
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  test("does not alert for a non-empty but fresh queue", async () => {
+    const task = createTaskExtended("Fresh pool task");
+    setCreatedAt(task.id, "2026-08-17T16:45:00.000Z");
+    const notify = mock(async (_message: string) => {});
+
+    const snapshot = await checkQueueStall(NOW, notify);
+
+    expect(snapshot.claimableCount).toBe(1);
+    expect(isQueueStalled(snapshot)).toBe(false);
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  test("measures queue age from a backlog task becoming claimable", async () => {
+    const task = createTaskExtended("Released backlog task");
+    setCreatedAt(task.id, "2026-08-17T12:00:00.000Z");
+    getDb().run("UPDATE agent_tasks SET status = 'backlog' WHERE id = ?", [task.id]);
+    getDb().run("UPDATE agent_tasks SET status = 'unassigned', lastUpdatedAt = ? WHERE id = ?", [
+      "2026-08-17T16:59:00.000Z",
+      task.id,
+    ]);
+    getDb().run(
+      `INSERT INTO agent_log (id, eventType, taskId, oldValue, newValue, createdAt)
+       VALUES (?, 'task_status_change', ?, 'backlog', 'unassigned', ?)`,
+      [crypto.randomUUID(), task.id, "2026-08-17T16:59:00.000Z"],
+    );
+    const notify = mock(async (_message: string) => {});
+
+    const snapshot = await checkQueueStall(NOW, notify);
+
+    expect(snapshot.oldestAgeMs).toBe(60_000);
+    expect(isQueueStalled(snapshot)).toBe(false);
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  test("measures queue age from the final dependency completing", async () => {
+    const worker = createAgent({ name: "worker", isLead: false, status: "idle" });
+    const prerequisite = createTaskExtended("Prerequisite", { agentId: worker.id });
+    const blocked = createTaskExtended("Newly unblocked", {
+      agentId: worker.id,
+      dependsOn: [prerequisite.id],
+    });
+    setCreatedAt(blocked.id, "2026-08-17T12:00:00.000Z");
+    getDb().run(
+      "UPDATE agent_tasks SET status = 'completed', finishedAt = ?, lastUpdatedAt = ? WHERE id = ?",
+      ["2026-08-17T16:59:00.000Z", "2026-08-17T16:59:00.000Z", prerequisite.id],
+    );
+    const notify = mock(async (_message: string) => {});
+
+    const snapshot = await checkQueueStall(NOW, notify);
+
+    expect(snapshot.oldestTaskId).toBe(blocked.id);
+    expect(snapshot.oldestAgeMs).toBe(60_000);
+    expect(isQueueStalled(snapshot)).toBe(false);
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  test("does not reset queue age when VCS metadata updates a claimable task", () => {
+    const task = createTaskExtended("Old task with new VCS metadata");
+    setCreatedAt(task.id, "2026-08-17T16:00:00.000Z");
+
+    updateTaskVcs(task.id, {
+      vcsProvider: "github",
+      vcsRepo: "desplega-ai/agent-swarm",
+      vcsNumber: 1177,
+      vcsUrl: "https://github.com/desplega-ai/agent-swarm/pull/1177",
+    });
+
+    const snapshot = getQueueStallSnapshot(NOW);
+    expect(snapshot.oldestAgeMs).toBe(60 * 60 * 1000);
+    expect(isQueueStalled(snapshot)).toBe(true);
+  });
+
+  test("does not reset claimable age when VCS metadata updates a completed dependency", () => {
+    const worker = createAgent({ name: "worker", isLead: false, status: "idle" });
+    const prerequisite = createTaskExtended("Completed prerequisite", { agentId: worker.id });
+    const blocked = createTaskExtended("Waiting after prerequisite", {
+      agentId: worker.id,
+      dependsOn: [prerequisite.id],
+    });
+    setCreatedAt(blocked.id, "2026-08-17T12:00:00.000Z");
+    getDb().run(
+      "UPDATE agent_tasks SET status = 'completed', finishedAt = ?, lastUpdatedAt = ? WHERE id = ?",
+      ["2026-08-17T16:00:00.000Z", "2026-08-17T16:00:00.000Z", prerequisite.id],
+    );
+
+    updateTaskVcs(prerequisite.id, {
+      vcsProvider: "github",
+      vcsRepo: "desplega-ai/agent-swarm",
+      vcsNumber: 1177,
+      vcsUrl: "https://github.com/desplega-ai/agent-swarm/pull/1177",
+    });
+
+    const snapshot = getQueueStallSnapshot(NOW);
+    expect(snapshot.oldestTaskId).toBe(blocked.id);
+    expect(snapshot.oldestAgeMs).toBe(60 * 60 * 1000);
+    expect(isQueueStalled(snapshot)).toBe(true);
+  });
+
+  test("excludes pending tasks whose dependencies are not complete", () => {
+    const worker = createAgent({ name: "worker", isLead: false, status: "idle" });
+    const prerequisite = createTaskExtended("Prerequisite", { agentId: worker.id });
+    const blocked = createTaskExtended("Blocked", {
+      agentId: worker.id,
+      dependsOn: [prerequisite.id],
+    });
+    setCreatedAt(blocked.id, "2026-08-17T12:00:00.000Z");
+
+    const snapshot = getQueueStallSnapshot(NOW);
+
+    expect(snapshot.claimableCount).toBe(1);
+    expect(snapshot.oldestTaskId).toBe(prerequisite.id);
+  });
+
+  test("reports direct and pool pickup transitions as diagnostic context", () => {
+    const worker = createAgent({ name: "worker", isLead: false, status: "idle" });
+    const task = createTaskExtended("Queued", { agentId: worker.id });
+    getDb().run(
+      `INSERT INTO agent_log (id, eventType, taskId, agentId, oldValue, newValue, createdAt)
+       VALUES (?, 'task_status_change', ?, ?, 'pending', 'in_progress', ?)`,
+      [crypto.randomUUID(), task.id, worker.id, "2026-08-17T16:50:00.000Z"],
+    );
+    getDb().run(
+      `INSERT INTO agent_log (id, eventType, taskId, agentId, oldValue, newValue, createdAt)
+       VALUES (?, 'task_claimed', ?, ?, 'unassigned', 'in_progress', ?)`,
+      [crypto.randomUUID(), task.id, worker.id, "2026-08-17T16:55:00.000Z"],
+    );
+
+    expect(getQueueStallSnapshot(NOW).recentPickupCount).toBe(2);
+  });
+
+  test("scrubs secrets from notification failures before logging", () => {
+    const token = "ghp_1234567890abcdefABCDEF1234567890ABCD";
+
+    const output = _test.formatCheckFailure(new Error(`Slack rejected token ${token}`));
+
+    expect(output).not.toContain(token);
+    expect(output).toContain("[REDACTED:github_token]");
+  });
+
+  test("deduplicates an active alarm and sends recovery", async () => {
+    const task = createTaskExtended("Old pool task");
+    setCreatedAt(task.id, "2026-08-17T16:00:00.000Z");
+    const notify = mock(async (_message: string) => {});
+
+    await checkQueueStall(NOW, notify);
+    await checkQueueStall(NOW, notify);
+    getDb().run("UPDATE agent_tasks SET status = 'completed' WHERE id = ?", [task.id]);
+    await checkQueueStall(NOW, notify);
+
+    expect(notify).toHaveBeenCalledTimes(2);
+    expect(notify.mock.calls[1]?.[0]).toContain("queue pickup recovered");
+  });
+});

package/src/tests/rbac-charact-slack.test.ts

@@ -28,6 +28,9 @@ import {
   registerRegisterKapsoNumberTool,
   registerUnregisterKapsoNumberTool,
 } from "../tools/register-kapso-number";
+import { registerSlackArchiveChannelTool } from "../tools/slack-archive-channel";
+import { registerSlackCreateChannelTool } from "../tools/slack-create-channel";
+import { registerSlackInviteToChannelTool } from "../tools/slack-invite-to-channel";
 import { registerSlackPostTool } from "../tools/slack-post";
 import { registerSlackReadTool } from "../tools/slack-read";
 import { registerSlackStartThreadTool } from "../tools/slack-start-thread";
@@ -102,6 +105,9 @@ beforeAll(async () => {
   server = new McpServer({ name: "test-rbac-charact-slack", version: "1.0.0" });
   registerSlackPostTool(server);
   registerSlackStartThreadTool(server);
+  registerSlackCreateChannelTool(server);
+  registerSlackInviteToChannelTool(server);
+  registerSlackArchiveChannelTool(server);
   registerSlackReadTool(server);
   registerSlackUploadFileTool(server);
   registerDeleteChannelTool(server);
@@ -167,6 +173,29 @@ describe("slack tool gates (characterization)", () => {
     expect(result.structuredContent.message).not.toContain("requires lead privileges");
   });
 
+  test.each([
+    ["slack-create-channel", { name: "project-channel" }],
+    ["slack-invite-to-channel", { channelId: "C0CHARACT01", userIds: ["U0CHARACT01"] }],
+    ["slack-archive-channel", { channelId: "C0CHARACT01" }],
+  ])("worker cannot use %s", async (toolName, args) => {
+    const result = await callTool(toolName, WORKER_ID, args);
+
+    expect(result.structuredContent.success).toBe(false);
+    expect(result.structuredContent.message).toBe(
+      "Managing Slack channels requires lead privileges.",
+    );
+  });
+
+  test.each([
+    ["slack-create-channel", { name: "project-channel" }],
+    ["slack-invite-to-channel", { channelId: "C0CHARACT01", userIds: ["U0CHARACT01"] }],
+    ["slack-archive-channel", { channelId: "C0CHARACT01" }],
+  ])("lead %s is not blocked by the lead gate", async (toolName, args) => {
+    const result = await callTool(toolName, LEAD_ID, args);
+
+    expect(result.structuredContent.message).not.toContain("requires lead privileges");
+  });
+
   // slack-read.ts:146 — direct channel read requires lead
   test("worker cannot read a Slack channel directly", async () => {
     const result = await callTool("slack-read", WORKER_ID, {

package/src/tests/rbac-engine.test.ts

@@ -50,6 +50,9 @@ const LEAD_ONLY_VERBS: PermissionVerb[] = [
   "integration.slack.post",
   "integration.slack.read",
   "integration.slack.thread.start",
+  "integration.slack.channel.create",
+  "integration.slack.channel.invite",
+  "integration.slack.channel.archive",
   "integration.slack.upload",
   "integration.slack.delete",
   "integration.slack.update",

package/src/tests/requester-comms.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test";
+import { getUserCommsPrefs } from "../utils/requester-comms";
+
+describe("getUserCommsPrefs", () => {
+  test("returns undefined for missing user or metadata", () => {
+    expect(getUserCommsPrefs(undefined)).toBeUndefined();
+    expect(getUserCommsPrefs({ metadata: undefined })).toBeUndefined();
+    expect(getUserCommsPrefs({ metadata: {} })).toBeUndefined();
+  });
+
+  test("returns undefined when comms is not an object", () => {
+    expect(getUserCommsPrefs({ metadata: { comms: "casual" } })).toBeUndefined();
+    expect(getUserCommsPrefs({ metadata: { comms: ["casual"] } })).toBeUndefined();
+    expect(getUserCommsPrefs({ metadata: { comms: null } })).toBeUndefined();
+  });
+
+  test("picks trimmed string fields and drops the rest", () => {
+    expect(
+      getUserCommsPrefs({
+        metadata: {
+          comms: { tone: "  casual  ", language: "uk", verbosity: 3, extra: "ignored" },
+        },
+      }),
+    ).toEqual({ tone: "casual", language: "uk", verbosity: undefined });
+  });
+
+  test("returns undefined when all comms fields are empty or non-string", () => {
+    expect(
+      getUserCommsPrefs({ metadata: { comms: { tone: "   ", language: 7 } } }),
+    ).toBeUndefined();
+  });
+});