@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/realtime/transport.ts

@@ -159,8 +159,7 @@ async function authenticate(req: IncomingMessage): Promise<AuthenticatedConnecti
       throw new Error("Invalid page origin");
     const page = await getPage(pageId);
     if (!page) throw new Error("Page not found");
-    const cookie = await extractAndVerifyCookie(req);
-    const session = cookie?.pageId === pageId ? cookie : null;
+    const session = await extractAndVerifyCookie(req, pageId);
     if (!session && page.authMode !== "public") throw new Error("Page session required");
     if (session?.uid && (await findUserById(session.uid))?.status !== "active")
       throw new Error("Viewer is inactive");

package/src/script-workflows/workflow-ctx.ts

@@ -36,6 +36,7 @@ type AgentTaskConfig = {
   routingNote?: string;
   tags?: string[];
   priority?: number;
+  dependsOn?: string[];
   offerMode?: boolean;
   dir?: string;
   vcsRepo?: string;

package/src/scripts-runtime/types/stdlib.d.ts

@@ -53,6 +53,8 @@ declare module "swarm-sdk" {
     routingNote?: string;
     tags?: string[];
     priority?: number;
+    /** Task IDs that must complete before this task starts. */
+    dependsOn?: string[];
     offerMode?: boolean;
     dir?: string;
     vcsRepo?: string;

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -15,6 +15,7 @@ declare module "swarm-extension" {
       | "github"
       | "gitlab"
       | "azure-devops"
+      | "bitbucket"
       | "system"
       | "linear"
       | "jira"
@@ -41,7 +42,7 @@ declare module "swarm-extension" {
     slackTriggerMessageTs?: string | undefined;
     slackUserId?: string | undefined;
     overrideSlackContext?: boolean | undefined;
-    vcsProvider?: "github" | "gitlab" | "azure-devops" | undefined;
+    vcsProvider?: "github" | "gitlab" | "azure-devops" | "bitbucket" | undefined;
     vcsRepo?: string | undefined;
     vcsEventType?: string | undefined;
     vcsNumber?: number | undefined;
@@ -67,6 +68,7 @@ declare module "swarm-extension" {
     sourceTaskId?: string | undefined;
     outputSchema?: Record<string, unknown> | undefined;
     inheritParentOutputSchema?: boolean | undefined;
+    inheritParentRequester?: boolean | undefined;
     inheritParentRoutingAffinity?: boolean | undefined;
     inheritParentFollowUpConfig?: boolean | undefined;
     followUpConfig?:
@@ -131,6 +133,7 @@ declare module "swarm-extension" {
       | "github"
       | "gitlab"
       | "azure-devops"
+      | "bitbucket"
       | "system"
       | "linear"
       | "jira"
@@ -171,7 +174,7 @@ declare module "swarm-extension" {
     slackUserId?: string | undefined;
     slackProgressMessageTs?: string | undefined;
     slackTreeRootMessageTs?: string | undefined;
-    vcsProvider?: "github" | "gitlab" | "azure-devops" | undefined;
+    vcsProvider?: "github" | "gitlab" | "azure-devops" | "bitbucket" | undefined;
     vcsRepo?: string | undefined;
     vcsEventType?: string | undefined;
     vcsNumber?: number | undefined;
@@ -485,8 +488,15 @@ declare module "swarm-extension" {
     userName?: string;
     /** The buffered messages, joined. */
     text: string;
+    /** True for an @mention and for a reply to one of the bot's messages. */
     botMentioned: boolean;
     isDirectMessage: boolean;
+    /** Platform chat type, such as Telegram `private`, `group`, `supergroup` or `channel`. */
+    chatType?: string;
+    /** Set for a Telegram supergroup with topics. */
+    isForum?: boolean;
+    /** A buffered message replies to one of the bot's own messages. */
+    replyToBot: boolean;
     /** Set when earlier swarm tasks exist in this thread. */
     threadContext?: {
       adapter: string;
@@ -617,7 +627,7 @@ declare module "swarm-extension" {
     /** The text, or a placeholder naming the type for a non-text message. */
     text: string;
   }
-  export type VcsProvider = "github" | "gitlab" | "azure-devops";
+  export type VcsProvider = "github" | "gitlab" | "azure-devops" | "bitbucket";
   /**
    * The provider object the event is about, as the provider names it. GitLab
    * calls a pull request a merge request, and a comment a `note`.
@@ -640,7 +650,7 @@ declare module "swarm-extension" {
     provider: VcsProvider;
     kind: VcsEventKind;
     action: string;
-    /** `owner/name` on GitHub and GitLab, the repository URL on Azure DevOps. */
+    /** `owner/name` on GitHub and GitLab, `workspace/repo_slug` on Bitbucket, the repository URL on Azure DevOps. */
     repo: string;
     /** The PR, merge request, or issue number. Absent for a pipeline outside a merge request. */
     number?: number;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -35,6 +35,8 @@ declare module "swarm-sdk" {
     routingNote?: string;
     tags?: string[];
     priority?: number;
+    /** Task IDs that must complete before this task starts. */
+    dependsOn?: string[];
     offerMode?: boolean;
     dir?: string;
     vcsRepo?: string;

package/src/server-user.ts

@@ -4,6 +4,7 @@ import * as z from "zod";
 import pkg from "../package.json";
 import { enqueueAdmissionRow } from "./be/rbac-audit";
 import { getUserGrant } from "./be/rbac-roles";
+import { MCP_MAX_TOOL_INPUT_ELEMENTS } from "./mcp-limits";
 import {
   type AdmissionRbac,
   decideToolAdmission,
@@ -107,6 +108,7 @@ export function createUserServer(user: User): McpServer {
       capabilities: {
         logging: {},
       },
+      maxToolInputElements: MCP_MAX_TOOL_INPUT_ELEMENTS,
     },
   );
 

package/src/server.ts

@@ -7,6 +7,7 @@ import { isSteeringEnabled } from "./be/steering";
 import { registerGithubTaskReactions } from "./github/task-reactions";
 import { loadGlobalConfigsIntoEnv } from "./http/core";
 import { isChatSdkEnabled } from "./integrations/chat-sdk/config";
+import { MCP_MAX_TOOL_INPUT_ELEMENTS } from "./mcp-limits";
 import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
 import { getSlackConfiguration } from "./slack/config";
@@ -450,6 +451,7 @@ export async function createServer(
       capabilities: {
         logging: {},
       },
+      maxToolInputElements: MCP_MAX_TOOL_INPUT_ELEMENTS,
     },
   );
 

package/src/slack/assistant.ts

@@ -204,13 +204,13 @@ export function createAssistant(): Assistant {
         // Fetch shared files before the task text is final: a file that can't be
         // downloaded is flagged in it.
         if (files?.length) await safeSetStatus("Downloading attachments...");
-        await using inbound = await fetchSlackFiles(client, files);
+        await using inbound = await fetchSlackFiles(client, files, { transcribe: true });
         // Any in-body `<@U…>` mention the requester typed is rewritten via
         // the identity primitive before it reaches agent-visible task text —
         // never a raw Slack ID. Bot-mention routing checks above use the
         // raw `messageText`, not this rendered copy.
         const renderedMessageText = await rewriteSlackMentions(
-          buildEffectiveText(messageText, inbound.files, inbound.failed),
+          buildEffectiveText(messageText, inbound.files, inbound.failed, inbound.notes),
           cachedBotUserId ?? undefined,
         );
 

package/src/slack/files.ts

@@ -22,6 +22,8 @@ export interface SlackFile {
   title?: string;
   mimetype: string;
   filetype: string;
+  /** `slack_audio` on a voice clip recorded in Slack. */
+  subtype?: string;
   size: number;
   url_private: string;
   url_private_download: string;

package/src/slack/handlers.test.ts

@@ -20,6 +20,7 @@ import {
   checkUserAccess,
   isBotMessage,
   isSwarmThreadRoot,
+  type isUserAllowed,
   registerMessageHandler,
   type UserFilterConfig,
 } from "./handlers";
@@ -189,6 +190,163 @@ describe("checkUserAccess", () => {
   });
 });
 
+describe("isUserAllowed", () => {
+  const usersInfo = mock(async () => ({ ok: true, user: {} }));
+  const client = { users: { info: usersInfo } } as never;
+  let enrichSpy: ReturnType<typeof spyOn<typeof slackEnrichModule, "enrichSlackUserEmail">>;
+  let logSpy: ReturnType<typeof spyOn<typeof console, "log">>;
+
+  // handlers.ts reads SLACK_ALLOWED_* once at module load, so each case evaluates a fresh
+  // copy under its own env and calls the production two-argument isUserAllowed. The copy
+  // shares ./enrich with this file, so the enrichSlackUserEmail spy still applies.
+  const ENV_KEYS = ["SLACK_ALLOWED_EMAIL_DOMAINS", "SLACK_ALLOWED_USER_IDS"] as const;
+  let loadCount = 0;
+  async function loadIsUserAllowed(env: {
+    SLACK_ALLOWED_EMAIL_DOMAINS?: string;
+    SLACK_ALLOWED_USER_IDS?: string;
+  }): Promise<typeof isUserAllowed> {
+    const saved = ENV_KEYS.map((key) => [key, process.env[key]] as const);
+    try {
+      for (const key of ENV_KEYS) {
+        if (env[key] === undefined) delete process.env[key];
+        else process.env[key] = env[key];
+      }
+      loadCount += 1;
+      const fresh = (await import(`./handlers?env=${loadCount}`)) as typeof import("./handlers");
+      return fresh.isUserAllowed;
+    } finally {
+      for (const [key, value] of saved) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  }
+
+  beforeEach(() => {
+    usersInfo.mockClear();
+    enrichSpy = spyOn(slackEnrichModule, "enrichSlackUserEmail");
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    enrichSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  const loggedLines = () => logSpy.mock.calls.map((call) => String(call[0]));
+
+  describe("filtering off (neither env var set)", () => {
+    test("allows everyone without an email lookup", async () => {
+      const allowed = await loadIsUserAllowed({});
+      expect(await allowed(client, "U_ANY")).toBe(true);
+      expect(enrichSpy).not.toHaveBeenCalled();
+      expect(usersInfo).not.toHaveBeenCalled();
+    });
+
+    test("treats blank and comma-only values as unset", async () => {
+      const allowed = await loadIsUserAllowed({
+        SLACK_ALLOWED_EMAIL_DOMAINS: " , ",
+        SLACK_ALLOWED_USER_IDS: ",",
+      });
+      expect(await allowed(client, "U_ANY")).toBe(true);
+      expect(enrichSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("user IDs only", () => {
+    const env = { SLACK_ALLOWED_USER_IDS: " U_LISTED , U_SECOND ," };
+
+    test("allows trimmed allowlisted IDs without an email lookup", async () => {
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_LISTED")).toBe(true);
+      expect(await allowed(client, "U_SECOND")).toBe(true);
+      expect(enrichSpy).not.toHaveBeenCalled();
+      expect(usersInfo).not.toHaveBeenCalled();
+    });
+
+    test("denies an unlisted ID without an email lookup", async () => {
+      enrichSpy.mockResolvedValue("person@company.com");
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(false);
+      expect(enrichSpy).not.toHaveBeenCalled();
+      expect(usersInfo).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("email domains only", () => {
+    const env = { SLACK_ALLOWED_EMAIL_DOMAINS: " Company.COM , other.org " };
+
+    test("allows trimmed, case-insensitive domains after one lookup", async () => {
+      const allowed = await loadIsUserAllowed(env);
+      enrichSpy.mockResolvedValue("person@company.com");
+      expect(await allowed(client, "U_A")).toBe(true);
+      enrichSpy.mockResolvedValue("person@Other.Org");
+      expect(await allowed(client, "U_B")).toBe(true);
+      expect(enrichSpy).toHaveBeenCalledTimes(2);
+      expect(enrichSpy).toHaveBeenNthCalledWith(1, client, "U_A");
+      expect(enrichSpy).toHaveBeenNthCalledWith(2, client, "U_B");
+      expect(loggedLines()).toEqual([]);
+    });
+
+    test("denies and logs a domain that is not allowed", async () => {
+      enrichSpy.mockResolvedValue("person@evil.com");
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(false);
+      expect(loggedLines()).toEqual([
+        '[Slack] User U_OTHER email domain "evil.com" not in allowed list',
+      ]);
+    });
+  });
+
+  describe("user IDs and email domains", () => {
+    const env = {
+      SLACK_ALLOWED_EMAIL_DOMAINS: "company.com",
+      SLACK_ALLOWED_USER_IDS: "U_LISTED",
+    };
+
+    test("allows an allowlisted ID without an email lookup", async () => {
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_LISTED")).toBe(true);
+      expect(enrichSpy).not.toHaveBeenCalled();
+      expect(usersInfo).not.toHaveBeenCalled();
+    });
+
+    test("allows an unlisted ID whose email domain is allowed", async () => {
+      enrichSpy.mockResolvedValue("person@Company.com");
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(true);
+      expect(enrichSpy).toHaveBeenCalledTimes(1);
+      expect(enrichSpy).toHaveBeenCalledWith(client, "U_OTHER");
+      expect(loggedLines()).toEqual([]);
+    });
+
+    test("denies and logs a domain that is not allowed", async () => {
+      enrichSpy.mockResolvedValue("person@other.com");
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(false);
+      expect(loggedLines()).toEqual([
+        '[Slack] User U_OTHER email domain "other.com" not in allowed list',
+      ]);
+    });
+
+    test("denies and logs a user with no email", async () => {
+      enrichSpy.mockResolvedValue(null);
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(false);
+      expect(loggedLines()).toEqual(["[Slack] User U_OTHER has no email, denying access"]);
+    });
+
+    test("denies and logs a user with a malformed email", async () => {
+      enrichSpy.mockResolvedValue("no-at-sign");
+      const allowed = await loadIsUserAllowed(env);
+      expect(await allowed(client, "U_OTHER")).toBe(false);
+      expect(loggedLines()).toEqual([
+        "[Slack] User U_OTHER has invalid email format, denying access",
+      ]);
+    });
+  });
+});
+
 // Helper to create a minimal SlackFile for testing
 function makeFile(overrides: Partial<SlackFile> = {}): SlackFile {
   return {

package/src/slack/handlers.ts

@@ -79,8 +79,6 @@ const allowedUserIds = (process.env.SLACK_ALLOWED_USER_IDS || "")
   .map((id) => id.trim())
   .filter(Boolean);
 
-const filteringEnabled = allowedEmailDomains.length > 0 || allowedUserIds.length > 0;
-
 /**
  * Configuration for user filtering.
  */
@@ -89,6 +87,8 @@ export interface UserFilterConfig {
   allowedUserIds: string[];
 }
 
+const envUserFilterConfig: UserFilterConfig = { allowedEmailDomains, allowedUserIds };
+
 /**
  * Core logic for checking if a user is allowed based on email and/or user ID.
  * Exported for testing.
@@ -137,40 +137,31 @@ export function checkUserAccess(
 /**
  * Check if a user is allowed to interact with the swarm.
  * Returns true if filtering is disabled, user is in whitelist, or user's email domain is allowed.
+ * The allow/deny decision is `checkUserAccess`; this wrapper only adds the lazy email lookup
+ * and the deny logs. The config comes from the SLACK_ALLOWED_* env vars, read at module load.
  */
 export async function isUserAllowed(client: WebClient, userId: string): Promise<boolean> {
-  // If no filtering configured, allow all users (backwards compatible)
-  if (!filteringEnabled) {
-    return true;
-  }
-
-  // Check user ID whitelist first (fast path)
-  if (allowedUserIds.includes(userId)) {
-    return true;
-  }
-
-  // No email domains configured and not in user whitelist
-  if (allowedEmailDomains.length === 0) {
-    return false;
+  const config = envUserFilterConfig;
+  // Decide without an email first: filtering off and allowlisted IDs pass, and with no
+  // email domains configured an unlisted ID is denied. Only domain checks need a lookup.
+  const allowedWithoutEmail = checkUserAccess(userId, null, config);
+  if (allowedWithoutEmail || config.allowedEmailDomains.length === 0) {
+    return allowedWithoutEmail;
   }
 
   // Check email domain — uses kv-backed enrichment (24h TTL, only success cached).
   const email = await enrichSlackUserEmail(client, userId);
+  const allowed = checkUserAccess(userId, email, config);
 
-  if (!email) {
-    console.log(`[Slack] User ${userId} has no email, denying access`);
-    return false;
-  }
-
-  const domain = email.split("@")[1]?.toLowerCase();
-  if (!domain) {
-    console.log(`[Slack] User ${userId} has invalid email format, denying access`);
-    return false;
-  }
-
-  const allowed = allowedEmailDomains.includes(domain);
   if (!allowed) {
-    console.log(`[Slack] User ${userId} email domain "${domain}" not in allowed list`);
+    const domain = email?.split("@")[1]?.toLowerCase();
+    if (!email) {
+      console.log(`[Slack] User ${userId} has no email, denying access`);
+    } else if (!domain) {
+      console.log(`[Slack] User ${userId} has invalid email format, denying access`);
+    } else {
+      console.log(`[Slack] User ${userId} email domain "${domain}" not in allowed list`);
+    }
   }
   return allowed;
 }
@@ -702,8 +693,8 @@ export function registerMessageHandler(app: App): void {
         return ignoreSlackInbound("rate_limited");
       }
 
-      await using inbound = await fetchSlackFiles(client, msg.files);
-      const taskText = buildEffectiveText(msg.text, inbound.files, inbound.failed);
+      await using inbound = await fetchSlackFiles(client, msg.files, { transcribe: true });
+      const taskText = buildEffectiveText(msg.text, inbound.files, inbound.failed, inbound.notes);
       const taskDescription = isImplicitMention
         ? taskText
         : extractTaskFromMessage(taskText, botUserId);
@@ -778,9 +769,9 @@ export function registerMessageHandler(app: App): void {
     }
 
     // Extract task description (the text plus a `[File: …]` line per attachment)
-    await using inbound = await fetchSlackFiles(client, msg.files);
+    await using inbound = await fetchSlackFiles(client, msg.files, { transcribe: true });
     const taskDescription = extractTaskFromMessage(
-      buildEffectiveText(msg.text, inbound.files, inbound.failed),
+      buildEffectiveText(msg.text, inbound.files, inbound.failed, inbound.notes),
       botUserId,
     );
     if (!taskDescription) {

package/src/slack/inbound-files.ts

@@ -13,6 +13,8 @@
  * could not be attached — never dropped silently. A download failure is
  * also flagged on that line; a storage failure happens after the text is
  * written, so it shows up only in the reply and in the missing attachment.
+ * Audio files (voice clips) a user shares get their transcript on the next
+ * line when transcription is configured, and keep the audio attached.
  */
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -27,6 +29,7 @@ import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import type { AgentTask, CreateTaskOptions, TaskAttachment } from "../types";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { taskAttachmentFetchCommand } from "../utils/task-attachment-links";
+import { transcribeAudioNotes } from "../utils/transcription";
 import { getFileInfo, type SlackFile } from "./files";
 import { noteSlackInboundSideEffect } from "./inbound-dispatch";
 // Side-effect import: registers all Slack event templates in the in-memory registry
@@ -73,6 +76,8 @@ export type InboundSlackFiles = {
   files: SlackFile[];
   fetched: FetchedSlackFile[];
   failed: SlackFileFailure[];
+  /** Task-text note per audio file id (a transcript), filled when fetched with `transcribe`. */
+  notes?: Map<string, string>;
   /** Deletes the downloaded copies; hold the batch with `await using`. */
   [Symbol.asyncDispose](): Promise<void>;
 };
@@ -96,9 +101,14 @@ export function formatFileSize(bytes: number): string {
  * Build a text representation of file attachments for inclusion in messages.
  * Each file is formatted as: [File: filename.ext (mimetype, size) id=FILE_ID],
  * followed by `(not attached: <reason>)` when the file never made it into the
- * task's attachments.
+ * task's attachments, and by the file's note (a voice-clip transcript) on the
+ * next line.
  */
-export function buildAttachmentText(files: SlackFile[], failed: SlackFileFailure[] = []): string {
+export function buildAttachmentText(
+  files: SlackFile[],
+  failed: SlackFileFailure[] = [],
+  notes: Map<string, string> = new Map(),
+): string {
   const reasons = new Map(failed.map((f) => [f.file.id, f.reason]));
   return files
     .map((f) => {
@@ -106,7 +116,8 @@ export function buildAttachmentText(files: SlackFile[], failed: SlackFileFailure
       const size = typeof f.size === "number" ? formatFileSize(f.size) : "unknown size";
       const line = `[File: ${f.name ?? f.id} (${f.mimetype ?? "unknown type"}, ${size}) id=${f.id}]`;
       const reason = reasons.get(f.id);
-      return reason ? `${line} (not attached: ${reason})` : line;
+      const note = notes.get(f.id);
+      return [reason ? `${line} (not attached: ${reason})` : line, note].filter(Boolean).join("\n");
     })
     .join("\n");
 }
@@ -121,15 +132,16 @@ export function buildEffectiveText(
   text: string | undefined,
   files?: SlackFile[],
   failed?: SlackFileFailure[],
+  notes?: Map<string, string>,
 ): string {
   const hasText = !!text?.trim();
   const hasFiles = files && files.length > 0;
 
   if (hasText && hasFiles) {
-    return `${text}\n\n${buildAttachmentText(files, failed)}`;
+    return `${text}\n\n${buildAttachmentText(files, failed, notes)}`;
   }
   if (hasFiles) {
-    return buildAttachmentText(files, failed);
+    return buildAttachmentText(files, failed, notes);
   }
   return text || "";
 }
@@ -147,11 +159,14 @@ export function bufferedFileFailures(files: SlackFile[] | undefined): SlackFileF
  * Download every file on a Slack message with the bot token, each to its own
  * temp file. Never throws: a file that can't be fetched lands in `failed` with
  * a reason the user and the agent can read. Hold the result with `await using`
- * so the temp files go away with it.
+ * so the temp files go away with it. With `transcribe`, every downloaded audio
+ * file also gets a `notes` entry: its transcript, the failure, or a line saying
+ * no provider is configured.
  */
 export async function fetchSlackFiles(
   client: WebClient,
   files: SlackFile[] | undefined,
+  options: { transcribe?: boolean } = {},
 ): Promise<InboundSlackFiles> {
   let dir: string | undefined;
   const result: InboundSlackFiles = {
@@ -182,9 +197,27 @@ export async function fetchSlackFiles(
       result.fetched.push({ file, ...outcome });
     }
   }
+  if (options.transcribe) {
+    result.notes = await transcribeAudioNotes(
+      result.fetched
+        .filter(({ file }) => isSlackAudio(file))
+        .map(({ file, path }) => ({
+          key: file.id,
+          name: file.name ?? file.id,
+          data: Bun.file(path),
+          mimeType: file.mimetype,
+        })),
+      "[Slack]",
+    );
+  }
   return result;
 }
 
+/** An audio file, or a voice clip recorded in Slack (its MIME type can read `video/…`). */
+function isSlackAudio(file: SlackFile): boolean {
+  return file.subtype === "slack_audio" || Boolean(file.mimetype?.startsWith("audio/"));
+}
+
 /** Does the start of an HTML response read like Slack's sign-in page? */
 function looksLikeSignIn(head: Uint8Array[]): boolean {
   const joined = new Uint8Array(head.reduce((total, part) => total + part.byteLength, 0));

package/src/slack/thread-buffer.ts

@@ -177,7 +177,7 @@ async function slackFlush(
   const app = getSlackApp();
   const files = items.flatMap((item) => item.files ?? []);
   await using inbound = app
-    ? await fetchSlackFiles(app.client, files)
+    ? await fetchSlackFiles(app.client, files, { transcribe: true })
     : {
         files,
         fetched: [],
@@ -196,6 +196,7 @@ async function slackFlush(
           item.text,
           item.files?.map((file) => resolvedFiles.get(file.id) ?? file),
           inbound.failed,
+          inbound.notes,
         ),
       )
       .join("\n---\n"),

package/src/tasks/context-key.ts

@@ -21,6 +21,10 @@
  *   task:trackers:gitlab:{projectId}:{mr|issue}:{iid}
  *   task:trackers:azure-devops:{repositoryId}:pr:{pullRequestId}
  *   task:trackers:azure-devops:{organization}:workitem:{workItemId}
+ *   task:trackers:bitbucket:{repoUuid}:pr:{pullRequestId}
+ *                                                 (repo UUID with Bitbucket's `{}` braces
+ *                                                  stripped and lowercased, so renames keep
+ *                                                  task threads)
  *   task:trackers:linear:{issueIdentifier}        (e.g. DES-42 — case preserved)
  *   task:trackers:jira:{issueIdentifier}          (e.g. PROJ-123 — case preserved)
  *   task:schedule:{scheduleId}
@@ -50,7 +54,13 @@ export type ContextKeyFamily =
   | "schedule"
   | "workflow";
 
-export type TrackerProvider = "github" | "gitlab" | "azure-devops" | "linear" | "jira";
+export type TrackerProvider =
+  | "github"
+  | "gitlab"
+  | "azure-devops"
+  | "bitbucket"
+  | "linear"
+  | "jira";
 
 export type ParsedContextKey =
   | { family: "slack"; parts: { channelId: string; threadTs: string } }
@@ -76,6 +86,11 @@ export type ParsedContextKey =
       subFamily: "azure-devops";
       parts: { organization: string; kind: "workitem"; workItemId: number };
     }
+  | {
+      family: "trackers";
+      subFamily: "bitbucket";
+      parts: { repoUuid: string; kind: "pr"; pullRequestId: number };
+    }
   | {
       family: "trackers";
       subFamily: "linear";
@@ -224,6 +239,34 @@ export function azureDevOpsWorkItemContextKey(input: {
   return ["task", "trackers", "azure-devops", organization, "workitem", workItemId].join(SEPARATOR);
 }
 
+/**
+ * Bitbucket Cloud wraps repository UUIDs in braces (`{1a2b...}`). Strip them
+ * and lowercase so the key is stable regardless of which payload field the
+ * UUID came from.
+ */
+export function bitbucketContextKey({
+  repoUuid,
+  pullRequestId,
+}: {
+  repoUuid: string;
+  pullRequestId: number | string;
+}): string {
+  const rawUuid = typeof repoUuid === "string" ? repoUuid.trim().replace(/^\{|\}$/g, "") : repoUuid;
+  const uuid = assertSafePart(rawUuid, "repoUuid").toLowerCase();
+  if (/[{}]/.test(uuid)) {
+    throw new Error(
+      `context-key: bitbucket "repoUuid" has unbalanced braces (got ${JSON.stringify(repoUuid)})`,
+    );
+  }
+  const id = assertSafePart(pullRequestId, "pullRequestId");
+  if (!/^\d+$/.test(id)) {
+    throw new Error(
+      `context-key: bitbucket "pullRequestId" must be a positive integer (got ${JSON.stringify(id)})`,
+    );
+  }
+  return ["task", "trackers", "bitbucket", uuid, "pr", id].join(SEPARATOR);
+}
+
 export function linearContextKey(input: { issueIdentifier: string }): string {
   const issueIdentifier = assertSafePart(input.issueIdentifier, "issueIdentifier");
   return ["task", "trackers", "linear", issueIdentifier].join(SEPARATOR);
@@ -401,6 +444,23 @@ export function parseContextKey(key: string): ParsedContextKey {
           parts: { repositoryId: parts[3] as string, kind: "pr", pullRequestId },
         };
       }
+      if (subFamily === "bitbucket") {
+        if (parts.length !== 6 || parts[4] !== "pr" || !parts[3]) {
+          throw new Error(`context-key: malformed bitbucket key: ${JSON.stringify(key)}`);
+        }
+        const idStr = parts[5] as string;
+        const pullRequestId = Number.parseInt(idStr, 10);
+        if (!/^\d+$/.test(idStr) || !Number.isFinite(pullRequestId)) {
+          throw new Error(
+            `context-key: malformed bitbucket pullRequestId "${idStr}": ${JSON.stringify(key)}`,
+          );
+        }
+        return {
+          family: "trackers",
+          subFamily: "bitbucket",
+          parts: { repoUuid: parts[3] as string, kind: "pr", pullRequestId },
+        };
+      }
       if (subFamily === "linear") {
         if (parts.length !== 4) {
           throw new Error(`context-key: malformed linear key: ${JSON.stringify(key)}`);