@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/cli-sdzq01t9.js

@@ -1,823 +0,0 @@
-import {
-  getFileStorageProvider,
-  providerPath
-} from "./cli-jsp14b6c.js";
-import {
-  createTaskWithSiblingAwareness
-} from "./cli-ayvy5kde.js";
-import {
-  init_task_attachment_links,
-  taskAttachmentFetchCommand
-} from "./cli-9d8ntetj.js";
-import {
-  getAgentById,
-  getAgentWorkingOnThread,
-  getAllAgents,
-  getTaskAttachments,
-  getTaskById,
-  init_db,
-  insertTaskAttachment,
-  promoteDraftTask,
-  refreshDraftTaskLease
-} from "./cli-qgd4sqz5.js";
-import {
-  init_registry,
-  init_resolver,
-  registerTemplate,
-  resolveTemplate
-} from "./cli-3apbzgyk.js";
-import {
-  init_env_flag,
-  isEnvFlagEnabled
-} from "./cli-ej6gbxfb.js";
-import {
-  init_secret_scrubber,
-  scrubSecrets
-} from "./cli-r2ap2czm.js";
-import {
-  __callDispose,
-  __using
-} from "./cli-bc05qbss.js";
-
-// src/slack/templates.ts
-init_registry();
-registerTemplate({
-  eventType: "slack.assistant.greeting",
-  header: "",
-  defaultBody: "Hi! I'm your Agent Swarm assistant. How can I help?",
-  variables: [],
-  category: "system"
-});
-registerTemplate({
-  eventType: "slack.assistant.suggested_prompts",
-  header: "",
-  defaultBody: `Try these:
-- Check status: What's the current status of all agents?
-- Assign a task: Can you help me with...
-- List recent tasks: Show me the most recent tasks`,
-  variables: [],
-  category: "system"
-});
-registerTemplate({
-  eventType: "slack.assistant.offline",
-  header: "",
-  defaultBody: "No agents are available right now. Your request has been queued and will be processed when agents come back online.",
-  variables: [],
-  category: "system"
-});
-registerTemplate({
-  eventType: "slack.message.attachment_failed",
-  header: "",
-  defaultBody: ":warning: Couldn't attach {{failed_files}} to the task. The agent sees the file name, not its contents.",
-  variables: [
-    {
-      name: "failed_files",
-      description: "Comma-separated `name` (reason) list of the files that were not attached"
-    }
-  ],
-  category: "system"
-});
-registerTemplate({
-  eventType: "slack.message.thread_context",
-  header: "",
-  defaultBody: `<thread_context>
-{{thread_messages}}
-</thread_context>`,
-  variables: [
-    {
-      name: "thread_messages",
-      description: "Formatted thread messages (user: text pairs)"
-    }
-  ],
-  category: "system"
-});
-
-// src/slack/inbound-files.ts
-init_db();
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// src/be/task-attachment-store.ts
-init_secret_scrubber();
-init_db();
-var MAX_TASK_ATTACHMENT_BYTES = 50 * 1024 * 1024;
-async function recordTaskAttachmentUpload(input) {
-  const { provider, scope, uploaded, contentType } = input;
-  try {
-    return await insertTaskAttachment({
-      taskId: scope.taskId,
-      agentId: input.agentId,
-      name: scope.name,
-      kind: provider.id === "agent-fs" ? "agent-fs" : "shared-fs",
-      path: uploaded.key,
-      providerId: provider.id,
-      providerKey: uploaded.key,
-      capabilities: {
-        ...provider.capabilities,
-        version: uploaded.version,
-        etag: uploaded.etag
-      },
-      mimeType: uploaded.contentType ?? contentType,
-      sizeBytes: uploaded.sizeBytes ?? input.sizeBytes,
-      sha256: uploaded.sha256 ?? input.sha256,
-      intent: input.intent,
-      description: input.description,
-      isPrimary: input.isPrimary ?? false,
-      createdBy: input.createdBy
-    });
-  } catch (error) {
-    try {
-      await provider.delete(scope);
-    } catch (cleanupError) {
-      console.warn(scrubSecrets(`[fs] upload metadata insert failed and blob cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`));
-    }
-    throw error;
-  }
-}
-
-// src/slack/inbound-files.ts
-init_resolver();
-init_secret_scrubber();
-init_task_attachment_links();
-
-// src/slack/files.ts
-import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-var MAX_FILE_SIZE = 1073741824;
-var DEFAULT_DOWNLOAD_DIR = `/workspace/shared/downloads/${process.env.AGENT_ID || "default"}/slack`;
-async function uploadFile(client, options) {
-  const { file, filename, channelId, threadTs, initialComment, title } = options;
-  try {
-    if (Buffer.isBuffer(file) && file.length > MAX_FILE_SIZE) {
-      return {
-        success: false,
-        error: `File size ${file.length} bytes exceeds maximum of ${MAX_FILE_SIZE} bytes (1 GB)`
-      };
-    }
-    if (typeof file === "string") {
-      const bunFile = Bun.file(file);
-      const size = bunFile.size;
-      if (size > MAX_FILE_SIZE) {
-        return {
-          success: false,
-          error: `File size ${size} bytes exceeds maximum of ${MAX_FILE_SIZE} bytes (1 GB)`
-        };
-      }
-    }
-    const uploadArgs = {
-      file,
-      filename,
-      title: title || filename
-    };
-    if (channelId) {
-      uploadArgs.channel_id = channelId;
-      if (threadTs) {
-        uploadArgs.thread_ts = threadTs;
-      }
-      if (initialComment) {
-        uploadArgs.initial_comment = initialComment;
-      }
-    }
-    const result = await client.filesUploadV2(uploadArgs);
-    const uploadedFile = result.files?.[0];
-    const fileId = uploadedFile?.files?.[0]?.id;
-    if (!fileId) {
-      return {
-        success: false,
-        error: "Upload succeeded but no file ID returned"
-      };
-    }
-    return {
-      success: true,
-      fileId
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: errorMsg
-    };
-  }
-}
-async function downloadFile(options) {
-  const { file, savePath, token } = options;
-  try {
-    const downloadUrl = typeof file === "string" ? file : file.url_private_download;
-    if (!downloadUrl) {
-      return {
-        success: false,
-        error: "No download URL available for this file"
-      };
-    }
-    let finalPath = savePath;
-    if (typeof file !== "string" && (savePath.endsWith("/") || !savePath.includes("."))) {
-      finalPath = savePath.endsWith("/") ? `${savePath}${file.name}` : `${savePath}/${file.name}`;
-    }
-    await mkdir(dirname(finalPath), { recursive: true });
-    const response = await fetch(downloadUrl, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      return {
-        success: false,
-        error: `HTTP error ${response.status}: ${response.statusText}`
-      };
-    }
-    const body = response.body;
-    if (!body) {
-      return {
-        success: false,
-        error: "No response body"
-      };
-    }
-    const writer = createWriteStream(finalPath);
-    const reader = body.getReader();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        writer.write(value);
-      }
-      writer.end();
-    } finally {
-      reader.releaseLock();
-    }
-    await new Promise((resolve, reject) => {
-      writer.on("finish", resolve);
-      writer.on("error", reject);
-    });
-    return {
-      success: true,
-      savedPath: finalPath
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    return {
-      success: false,
-      error: errorMsg
-    };
-  }
-}
-async function getFileInfo(client, fileId) {
-  try {
-    const result = await client.files.info({ file: fileId });
-    if (!result.file) {
-      return null;
-    }
-    const f = result.file;
-    return {
-      id: f.id,
-      name: f.name,
-      title: f.title,
-      mimetype: f.mimetype,
-      filetype: f.filetype,
-      size: f.size,
-      url_private: f.url_private,
-      url_private_download: f.url_private_download,
-      thumb_64: f.thumb_64,
-      thumb_80: f.thumb_80,
-      thumb_160: f.thumb_160,
-      thumb_360: f.thumb_360,
-      thumb_480: f.thumb_480,
-      user: f.user,
-      created: f.created
-    };
-  } catch {
-    return null;
-  }
-}
-
-// src/slack/inbound-files.ts
-var DOWNLOAD_TIMEOUT_MS = 30000;
-var SIGNED_OUT_REASON = "Slack returned its sign-in page instead of the file (is the files:read scope granted?)";
-var SIGN_IN_MARKERS = [
-  /<title>[^<]*sign in to slack/i,
-  /id="signin[_-]form"/i,
-  /slack\.com\/(workspace-)?signin/i
-];
-var SIGN_IN_SNIFF_BYTES = 4096;
-var draftLeaseRefreshMs = 60000;
-var SHARED_FILE_INTENT = "user-upload";
-var FETCHED_FILE_INTENT = "slack-file";
-var BUFFERED_REASON = "follow-ups queued by ADDITIVE_SLACK carry the file name only";
-function errorText(error) {
-  return scrubSecrets(error instanceof Error ? error.message : String(error));
-}
-function formatFileSize(bytes) {
-  if (bytes < 1024)
-    return `${bytes} B`;
-  if (bytes < 1024 * 1024)
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024)
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function buildAttachmentText(files, failed = []) {
-  const reasons = new Map(failed.map((f) => [f.file.id, f.reason]));
-  return files.map((f) => {
-    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;
-  }).join(`
-`);
-}
-function buildEffectiveText(text, files, failed) {
-  const hasText = !!text?.trim();
-  const hasFiles = files && files.length > 0;
-  if (hasText && hasFiles) {
-    return `${text}
-
-${buildAttachmentText(files, failed)}`;
-  }
-  if (hasFiles) {
-    return buildAttachmentText(files, failed);
-  }
-  return text || "";
-}
-function bufferedFileFailures(files) {
-  return (files ?? []).map((file) => ({ file, reason: BUFFERED_REASON }));
-}
-async function fetchSlackFiles(client, files) {
-  let dir;
-  const result = {
-    files: [],
-    fetched: [],
-    failed: [],
-    async[Symbol.asyncDispose]() {
-      if (dir)
-        await rm(dir, { recursive: true, force: true });
-    }
-  };
-  if (!files || files.length === 0)
-    return result;
-  dir = await mkdtemp(join(tmpdir(), "slack-files-"));
-  const token = client.token ?? process.env.SLACK_BOT_TOKEN;
-  for (const [index, eventFile] of files.entries()) {
-    const file = eventFile.url_private_download ? eventFile : await getFileInfo(client, eventFile.id) ?? eventFile;
-    result.files.push(file);
-    const outcome = await downloadSlackFile(file, token, join(dir, String(index)));
-    if (typeof outcome === "string") {
-      console.warn(`[Slack] could not fetch file ${file.id}: ${outcome}`);
-      result.failed.push({ file, reason: outcome });
-    } else {
-      result.fetched.push({ file, ...outcome });
-    }
-  }
-  return result;
-}
-function looksLikeSignIn(head) {
-  const joined = new Uint8Array(head.reduce((total, part) => total + part.byteLength, 0));
-  let offset = 0;
-  for (const part of head) {
-    joined.set(part, offset);
-    offset += part.byteLength;
-  }
-  const text = new TextDecoder().decode(joined);
-  return SIGN_IN_MARKERS.some((marker) => marker.test(text));
-}
-async function downloadSlackFile(file, token, path) {
-  const limit = `larger than the ${MAX_TASK_ATTACHMENT_BYTES / (1024 * 1024)} MB limit`;
-  if (file.size > MAX_TASK_ATTACHMENT_BYTES)
-    return limit;
-  if (!file.url_private_download)
-    return "Slack gave no download URL";
-  if (!token)
-    return "no Slack bot token configured";
-  const abort = new AbortController;
-  try {
-    const response = await fetch(file.url_private_download, {
-      headers: { Authorization: `Bearer ${token}` },
-      signal: AbortSignal.any([abort.signal, AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)])
-    });
-    if (!response.ok)
-      return `download failed (HTTP ${response.status})`;
-    const isHtml = (response.headers.get("content-type") ?? "").startsWith("text/html");
-    const redirectedToHtml = isHtml && response.redirected && !new URL(response.url).pathname.includes("/files-pri/");
-    if (redirectedToHtml || isHtml && !file.mimetype?.startsWith("text/html")) {
-      abort.abort();
-      return SIGNED_OUT_REASON;
-    }
-    if (Number(response.headers.get("content-length") ?? 0) > MAX_TASK_ATTACHMENT_BYTES) {
-      abort.abort();
-      return limit;
-    }
-    const hasher = new Bun.CryptoHasher("sha256");
-    const sink = Bun.file(path).writer({ highWaterMark: 1024 * 1024 });
-    let sizeBytes = 0;
-    let overCap = false;
-    const head = [];
-    let headBytes = 0;
-    try {
-      for await (const chunk of response.body ?? []) {
-        sizeBytes += chunk.byteLength;
-        if (sizeBytes > MAX_TASK_ATTACHMENT_BYTES) {
-          overCap = true;
-          break;
-        }
-        if (isHtml && headBytes < SIGN_IN_SNIFF_BYTES) {
-          const wanted = chunk.subarray(0, SIGN_IN_SNIFF_BYTES - headBytes);
-          head.push(wanted);
-          headBytes += wanted.byteLength;
-        }
-        hasher.update(chunk);
-        sink.write(chunk);
-      }
-    } finally {
-      await sink.end();
-    }
-    if (overCap) {
-      abort.abort();
-      return limit;
-    }
-    if (isHtml && looksLikeSignIn(head))
-      return SIGNED_OUT_REASON;
-    if (isHtml && file.size > 0 && sizeBytes !== file.size) {
-      return `Slack sent ${sizeBytes} bytes of HTML for a ${file.size}-byte file, likely its sign-in page (is the files:read scope granted?)`;
-    }
-    return { path, sizeBytes, sha256: hasher.digest("hex") };
-  } catch (error) {
-    return `download failed (${errorText(error)})`;
-  }
-}
-async function createSlackTaskWithFiles(description, options, inbound) {
-  if (inbound.fetched.length === 0) {
-    const task2 = await createTaskWithSiblingAwareness(description, options);
-    return { task: task2, unattached: inbound.failed };
-  }
-  const task = await createTaskWithSiblingAwareness(description, { ...options, status: "draft" });
-  const unattached = [...inbound.failed];
-  const lease = setInterval(() => {
-    refreshDraftTaskLease(task.id).catch((error) => console.warn(`[Slack] could not renew the draft lease of task ${task.id}: ${errorText(error)}`));
-  }, draftLeaseRefreshMs);
-  try {
-    unattached.push(...(await attachSlackFilesToTask(task.id, inbound.fetched, null)).unattached);
-  } finally {
-    clearInterval(lease);
-    await promoteDraftTask(task.id);
-  }
-  return { task, unattached };
-}
-async function attachSlackFilesToTask(taskId, fetched, agentId) {
-  const existing = await getTaskAttachments(taskId);
-  const bySha = new Map(existing.flatMap((a) => a.sha256 ? [[a.sha256, a]] : []));
-  const usedNames = new Set(existing.map((a) => a.name));
-  const provider = getFileStorageProvider();
-  const attached = [];
-  const unattached = [];
-  for (const { file, path, sizeBytes, sha256 } of fetched) {
-    const known = bySha.get(sha256);
-    if (known) {
-      attached.push({ file, attachment: known });
-      continue;
-    }
-    const name = usedNames.has(file.name) ? `${file.id}-${file.name}` : file.name;
-    usedNames.add(name);
-    const key = providerPath({ taskId, name: `slack-${file.id}-${file.name}` });
-    const scope = { taskId, name, key };
-    try {
-      const uploaded = await provider.upload(scope, Bun.file(path), {
-        contentType: file.mimetype,
-        sizeBytes,
-        message: `Upload ${name} from Slack for task ${taskId}`
-      });
-      const attachment = await recordTaskAttachmentUpload({
-        provider,
-        scope,
-        uploaded,
-        sizeBytes,
-        sha256,
-        contentType: file.mimetype,
-        agentId,
-        intent: agentId ? FETCHED_FILE_INTENT : SHARED_FILE_INTENT,
-        description: agentId ? `Fetched from Slack (file ${file.id})` : `Shared on Slack (file ${file.id})`
-      });
-      bySha.set(sha256, attachment);
-      attached.push({ file, attachment });
-    } catch (error) {
-      const reason = `could not be stored (${errorText(error)})`;
-      console.warn(`[Slack] file ${file.id} for task ${taskId} ${reason}`);
-      unattached.push({ file, reason });
-    }
-  }
-  return { attached, unattached };
-}
-async function attachSlackFilesForAgent(client, task, files, agentId) {
-  const outcomes = new Map;
-  for (const file of files) {
-    let __stack = [];
-    try {
-      if (outcomes.has(file.id))
-        continue;
-      const inbound = __using(__stack, await fetchSlackFiles(client, [file]), 1);
-      const { attached, unattached } = await attachSlackFilesToTask(task.id, inbound.fetched, agentId);
-      for (const { file: failed, reason } of [...inbound.failed, ...unattached]) {
-        outcomes.set(failed.id, { reason });
-      }
-      for (const { file: stored, attachment } of attached) {
-        outcomes.set(stored.id, {
-          attachment,
-          fetchCommand: taskAttachmentFetchCommand(task.id, attachment.id, attachment.name)
-        });
-      }
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      var _promise = __callDispose(__stack, _err, _hasErr);
-      _promise && await _promise;
-    }
-  }
-  return outcomes;
-}
-async function attachableTask(agentId, taskId) {
-  if (!taskId)
-    return null;
-  const task = await getTaskById(taskId);
-  if (!task)
-    return null;
-  return task.agentId === agentId || task.creatorAgentId === agentId ? task : null;
-}
-async function notifySlackFileFailures(client, channel, threadTs, failures) {
-  if (failures.length === 0)
-    return;
-  const byFile = new Map(failures.map((f) => [f.file.id, f]));
-  const failedFiles = [...byFile.values()].map((f) => `\`${f.file.name}\` (${f.reason})`).join(", ");
-  const { text } = resolveTemplate("slack.message.attachment_failed", {
-    failed_files: failedFiles
-  });
-  try {
-    await client.chat.postMessage({
-      channel,
-      thread_ts: threadTs,
-      text,
-      unfurl_links: false,
-      unfurl_media: false
-    });
-  } catch (error) {
-    console.warn(`[Slack] could not post the attachment-failure notice in ${channel}/${threadTs}: ${errorText(error)}`);
-  }
-}
-
-// src/slack/router.ts
-init_db();
-init_env_flag();
-function hasOtherUserMention(text, botUserId) {
-  const mentions = text.match(/<@([A-Z0-9]+)>/g) ?? [];
-  return mentions.some((m) => m !== `<@${botUserId}>`);
-}
-async function routeMessage(text, botUserId, botMentioned, threadContext) {
-  const matches = [];
-  const requireMentionForThreadFollowup = isEnvFlagEnabled("SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION", false);
-  const agents = (await getAllAgents()).filter((a) => a.status !== "offline");
-  const idMatches = text.matchAll(/swarm#([a-f0-9-]{36})/gi);
-  for (const match of idMatches) {
-    const agentId = match[1];
-    if (!agentId)
-      continue;
-    const agent = await getAgentById(agentId);
-    if (agent && agent.status !== "offline") {
-      matches.push({ agent, matchedText: match[0] });
-    }
-  }
-  if (/swarm#all/i.test(text)) {
-    const nonLeadAgents = agents.filter((a) => !a.isLead);
-    for (const agent of nonLeadAgents) {
-      if (!matches.some((m) => m.agent.id === agent.id)) {
-        matches.push({ agent, matchedText: "swarm#all" });
-      }
-    }
-  }
-  if (matches.length === 0 && threadContext && (!requireMentionForThreadFollowup || botMentioned)) {
-    if (!botMentioned && hasOtherUserMention(text, botUserId)) {
-      console.log(`[Slack] Skipping thread follow-up in ${threadContext.channelId}/${threadContext.threadTs}: message mentions another user`);
-      return matches;
-    }
-    const workingAgent = await getAgentWorkingOnThread(threadContext.channelId, threadContext.threadTs);
-    if (workingAgent && workingAgent.status !== "offline") {
-      console.log(`[Slack] Thread follow-up: routing to agent ${workingAgent.name} (${workingAgent.id}) in thread ${threadContext.threadTs}`);
-      matches.push({ agent: workingAgent, matchedText: "thread follow-up" });
-    } else if (workingAgent) {
-      console.log(`[Slack] Thread follow-up: agent ${workingAgent.name} is offline, routing to lead`);
-      const allAgents = await getAllAgents();
-      const lead = allAgents.find((a) => a.isLead && a.status !== "offline");
-      if (lead) {
-        matches.push({ agent: lead, matchedText: "thread follow-up (lead fallback)" });
-      }
-    }
-  }
-  if (matches.length === 0 && botMentioned) {
-    const lead = agents.find((a) => a.isLead);
-    if (lead) {
-      matches.push({ agent: lead, matchedText: "@bot" });
-    }
-  }
-  return matches;
-}
-function extractTaskFromMessage(text, botUserId) {
-  return text.replace(new RegExp(`<@${botUserId}>`, "g"), "").replace(/swarm#[a-f0-9-]{36}/gi, "").replace(/swarm#all/gi, "").trim();
-}
-
-// src/slack/message-text.ts
-function collectRichTextParts(node, parts) {
-  if (node == null || typeof node !== "object")
-    return;
-  const n = node;
-  if (n.type === "text" && n.text) {
-    parts.push(n.text);
-  }
-  if (Array.isArray(n.elements)) {
-    for (const child of n.elements) {
-      collectRichTextParts(child, parts);
-    }
-  }
-}
-function extractSlackMessageText(msg) {
-  const topText = msg.text?.trim() ?? "";
-  const attachmentParts = [];
-  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
-    for (const raw of msg.attachments) {
-      if (raw == null || typeof raw !== "object")
-        continue;
-      const a = raw;
-      const attParts = [];
-      const titleText = a.title_link && a.title ? `<${a.title_link}|${a.title}>` : a.title;
-      const seenPrimary = new Set;
-      for (const part of [a.pretext, titleText, a.text, a.fallback]) {
-        const s = part?.trim();
-        if (s && !seenPrimary.has(s)) {
-          seenPrimary.add(s);
-          attParts.push(s);
-        }
-      }
-      if (Array.isArray(a.fields)) {
-        for (const field of a.fields) {
-          if (field == null || typeof field !== "object")
-            continue;
-          const f = field;
-          if (f.title && f.value)
-            attParts.push(`${f.title}: ${f.value}`);
-          else if (f.title)
-            attParts.push(f.title);
-          else if (f.value)
-            attParts.push(f.value);
-        }
-      }
-      if (Array.isArray(a.actions)) {
-        for (const action of a.actions) {
-          if (action == null || typeof action !== "object")
-            continue;
-          const act = action;
-          if (act.url) {
-            attParts.push(act.text ? `<${act.url}|${act.text}>` : act.url);
-          }
-        }
-      }
-      if (attParts.length > 0)
-        attachmentParts.push(attParts.join(`
-`));
-    }
-  }
-  const blockParts = [];
-  if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
-    for (const rawBlock of msg.blocks) {
-      if (rawBlock == null || typeof rawBlock !== "object")
-        continue;
-      const block = rawBlock;
-      if (block.type === "section") {
-        if (block.text?.text)
-          blockParts.push(block.text.text);
-        if (Array.isArray(block.fields)) {
-          for (const field of block.fields) {
-            if (field != null && typeof field === "object" && field.text) {
-              blockParts.push(field.text);
-            }
-          }
-        }
-      } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          collectRichTextParts(el, blockParts);
-        }
-      } else if (block.type === "header") {
-        if (block.text?.text)
-          blockParts.push(block.text.text);
-      } else if (block.type === "context" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          if (el == null || typeof el !== "object")
-            continue;
-          const e = el;
-          if (e.text)
-            blockParts.push(e.text);
-        }
-      } else if (block.type === "actions" && Array.isArray(block.elements)) {
-        for (const el of block.elements) {
-          if (el == null || typeof el !== "object")
-            continue;
-          const e = el;
-          const label = e.text?.text;
-          const url = e.url;
-          if (label && url)
-            blockParts.push(`<${url}|${label}>`);
-          else if (label)
-            blockParts.push(label);
-          else if (url)
-            blockParts.push(url);
-        }
-      }
-    }
-  }
-  const bodyText = [...attachmentParts, ...blockParts].filter(Boolean).join(`
-`);
-  const bodyLines = new Set(bodyText.split(`
-`).map((l) => l.trim()).filter(Boolean));
-  if (topText && !bodyLines.has(topText)) {
-    return bodyText ? `${topText}
-${bodyText}` : topText;
-  }
-  return bodyText || topText;
-}
-function parseSlackTs(input) {
-  const trimmed = input.trim();
-  if (/^\d{6,}\.\d{1,}$/.test(trimmed))
-    return trimmed;
-  const m = trimmed.match(/p?(\d{10})(\d{6})(?:\D|$)/);
-  if (m)
-    return `${m[1]}.${m[2]}`;
-  return trimmed;
-}
-
-// src/tasks/additive-buffer.ts
-function createAdditiveBuffer(options) {
-  const { timeoutMs, onFlush, label } = options;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-    throw new Error(`additive-buffer: timeoutMs must be a positive number, got ${timeoutMs}`);
-  }
-  const buffers = new Map;
-  const prefix = label ? `[buffer:${label}]` : "[buffer]";
-  function scheduleFlush(key) {
-    return setTimeout(() => {
-      doFlush(key, "timer");
-    }, timeoutMs);
-  }
-  async function doFlush(key, reason) {
-    const entry = buffers.get(key);
-    if (!entry || entry.items.length === 0) {
-      buffers.delete(key);
-      return;
-    }
-    clearTimeout(entry.timer);
-    buffers.delete(key);
-    try {
-      await onFlush(entry.items, key, reason);
-    } catch (error) {
-      console.error(`${prefix} onFlush threw for key=${key}:`, error);
-    }
-  }
-  return {
-    enqueue(contextKey, item) {
-      if (!contextKey) {
-        throw new Error("additive-buffer: contextKey is required");
-      }
-      const existing = buffers.get(contextKey);
-      if (existing) {
-        clearTimeout(existing.timer);
-        existing.items.push(item);
-        existing.timer = scheduleFlush(contextKey);
-        console.log(`${prefix} append: ${contextKey} (${existing.items.length} items, timer reset to ${timeoutMs}ms)`);
-      } else {
-        const entry = {
-          items: [item],
-          timer: scheduleFlush(contextKey)
-        };
-        buffers.set(contextKey, entry);
-        console.log(`${prefix} created: ${contextKey} (timer set to ${timeoutMs}ms)`);
-      }
-    },
-    isBuffered(contextKey) {
-      return buffers.has(contextKey);
-    },
-    count(contextKey) {
-      return buffers.get(contextKey)?.items.length ?? 0;
-    },
-    instantFlush(contextKey) {
-      return doFlush(contextKey, "manual");
-    },
-    cancel(contextKey) {
-      const entry = buffers.get(contextKey);
-      if (!entry)
-        return false;
-      clearTimeout(entry.timer);
-      buffers.delete(contextKey);
-      return true;
-    },
-    keys() {
-      return Array.from(buffers.keys());
-    }
-  };
-}
-
-export { createAdditiveBuffer, MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload, MAX_FILE_SIZE, DEFAULT_DOWNLOAD_DIR, uploadFile, downloadFile, getFileInfo, buildEffectiveText, bufferedFileFailures, fetchSlackFiles, createSlackTaskWithFiles, attachSlackFilesForAgent, attachableTask, notifySlackFileFailures, hasOtherUserMention, routeMessage, extractTaskFromMessage, extractSlackMessageText, parseSlackTs };