@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/dist/{cli-9jfty8px.js → cli-ktcdczth.js}

@@ -1,6 +1,9 @@
 import {
   slackContextKey,
   init_context_key,
+  encryptSecret,
+  decryptSecret,
+  getEncryptionKey,
   init_crypto,
   getDbClient2,
   getAgentById2,
@@ -47,10 +50,10 @@ import {
   checkDependencies2,
   emitBuiltInIntegrationConnectedOnce2,
   init_db3
-} from "./cli-txr0z97c.js";
+} from "./cli-wmhajw68.js";
 import {
   getChannelBlockReason2
-} from "./cli-6vq3ymqm.js";
+} from "./cli-0tkm519n.js";
 import {
   require_dist5,
   require_axios,
@@ -67,11 +70,11 @@ import {
 import {
   isTerminalTaskStatus,
   init_types2
-} from "./cli-e1p7dqe1.js";
+} from "./cli-4aydmmdy.js";
 import {
   taskAttachmentDisplayUrl,
   init_task_attachment_links
-} from "./cli-0wx63vvw.js";
+} from "./cli-9km88w11.js";
 import {
   getSlackConfiguration,
   init_config
@@ -93,7 +96,7 @@ import {
 import {
   getAppUrl,
   init_constants2
-} from "./cli-3cywb44q.js";
+} from "./cli-77eq8txs.js";
 import {
   isEnvFlagEnabled,
   init_env_flag
@@ -6005,8 +6008,9 @@ function installSlackExternalChannelGuard() {
 }
 
 // src/slack/inbound-dispatch.ts
-import { AsyncLocalStorage } from "node:async_hooks";
 init_crypto();
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 
 // src/be/db-queries/slack-inbound.ts
 init_db3();
@@ -6026,6 +6030,176 @@ var SLACK_INBOUND_LIMITS = {
   maxAttempts: 3,
   retryBackoffMs: 30000
 };
+function toReceipt(row) {
+  return {
+    id: row.id,
+    dedupKey: row.dedup_key,
+    transport: row.transport,
+    kind: row.kind,
+    payloadType: row.payload_type,
+    apiAppId: row.api_app_id,
+    eventId: row.event_id,
+    payloadCiphertext: row.payload_ciphertext,
+    payloadBytes: row.payload_bytes,
+    retryNum: row.retry_num,
+    retryReason: row.retry_reason,
+    state: row.state,
+    attempts: row.attempts,
+    duplicateCount: row.duplicate_count,
+    outcomeCode: row.outcome_code,
+    errorCode: row.error_code,
+    receivedAt: row.received_at,
+    availableAt: row.available_at,
+    claimedAt: row.claimed_at,
+    completedAt: row.completed_at,
+    lastDuplicateAt: row.last_duplicate_at,
+    payloadErasedAt: row.payload_erased_at
+  };
+}
+async function admitSlackInboundReceipt(input, now = new Date, limits = SLACK_INBOUND_LIMITS) {
+  const nowIso = now.toISOString();
+  return getDbClient2().transaction(async (tx) => {
+    const duplicate = await tx.get(`UPDATE slack_inbound_receipts
+          SET duplicate_count = duplicate_count + 1, last_duplicate_at = ?, updated_at = ?
+        WHERE dedup_key = ?
+        RETURNING *`, [nowIso, nowIso, input.dedupKey]);
+    if (duplicate)
+      return { status: "duplicate", receipt: toReceipt(duplicate) };
+    if (input.payloadBytes > limits.maxPayloadBytes) {
+      return { status: "rejected", reason: "payload_too_large" };
+    }
+    const backlog = await tx.get(`SELECT COUNT(*) AS receipts, SUM(payload_bytes) AS bytes
+         FROM slack_inbound_receipts
+        WHERE state IN ('pending', 'processing')`);
+    const receipts = backlog?.receipts ?? 0;
+    const bytes = backlog?.bytes ?? 0;
+    if (receipts >= limits.maxBacklogReceipts || bytes + input.payloadBytes > limits.maxBacklogBytes) {
+      return { status: "rejected", reason: "backlog_full" };
+    }
+    const inserted = await tx.get(`INSERT INTO slack_inbound_receipts (
+          id, dedup_key, transport, kind, payload_type, api_app_id, event_id,
+          payload_ciphertext, payload_bytes, retry_num, retry_reason,
+          received_at, available_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(dedup_key) DO NOTHING
+        RETURNING *`, [
+      crypto.randomUUID(),
+      input.dedupKey,
+      input.transport,
+      input.kind,
+      input.payloadType,
+      input.apiAppId ?? null,
+      input.eventId ?? null,
+      input.payloadCiphertext,
+      input.payloadBytes,
+      input.retryNum ?? null,
+      input.retryReason ?? null,
+      nowIso,
+      nowIso,
+      nowIso,
+      nowIso
+    ]);
+    if (inserted)
+      return { status: "admitted", receipt: toReceipt(inserted) };
+    const winner = await tx.get("SELECT * FROM slack_inbound_receipts WHERE dedup_key = ?", [input.dedupKey]);
+    if (!winner)
+      throw new Error("Slack inbound receipt vanished during admission");
+    return { status: "duplicate", receipt: toReceipt(winner) };
+  });
+}
+async function recordSlackInboundInline(input, now = new Date) {
+  const nowIso = now.toISOString();
+  const inserted = await getDbClient2().get(`INSERT INTO slack_inbound_receipts (
+        id, dedup_key, transport, kind, payload_type, api_app_id, event_id,
+        payload_bytes, retry_num, retry_reason, state, attempts, outcome_code,
+        received_at, available_at, completed_at, payload_erased_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?, 'processed', 1, 'ran_inline', ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(dedup_key) DO NOTHING
+      RETURNING id`, [
+    crypto.randomUUID(),
+    input.dedupKey,
+    input.transport,
+    input.kind,
+    input.payloadType,
+    input.apiAppId ?? null,
+    input.eventId ?? null,
+    input.retryNum ?? null,
+    input.retryReason ?? null,
+    nowIso,
+    nowIso,
+    nowIso,
+    nowIso,
+    nowIso,
+    nowIso
+  ]);
+  if (inserted)
+    return "recorded";
+  await touchSlackInboundDuplicate(input.dedupKey, now);
+  return "duplicate";
+}
+async function touchSlackInboundDuplicate(dedupKey, now = new Date) {
+  const nowIso = now.toISOString();
+  const row = await getDbClient2().get(`UPDATE slack_inbound_receipts
+        SET duplicate_count = duplicate_count + 1, last_duplicate_at = ?, updated_at = ?
+      WHERE dedup_key = ?
+      RETURNING id`, [nowIso, nowIso, dedupKey]);
+  return row !== null && row !== undefined;
+}
+async function claimSlackInboundReceipt(now = new Date, id) {
+  const nowIso = now.toISOString();
+  const row = id ? await getDbClient2().get(`UPDATE slack_inbound_receipts
+            SET state = 'processing', attempts = attempts + 1, claimed_at = ?, updated_at = ?
+          WHERE id = ? AND state = 'pending' AND available_at <= ?
+          RETURNING *`, [nowIso, nowIso, id, nowIso]) : await getDbClient2().get(`UPDATE slack_inbound_receipts
+            SET state = 'processing', attempts = attempts + 1, claimed_at = ?, updated_at = ?
+          WHERE id = (
+                  SELECT id FROM slack_inbound_receipts
+                   WHERE state = 'pending' AND available_at <= ?
+                   ORDER BY received_at, id
+                   LIMIT 1
+                )
+            AND state = 'pending'
+          RETURNING *`, [nowIso, nowIso, nowIso]);
+  return row ? toReceipt(row) : null;
+}
+async function completeSlackInboundReceipt(id, outcome, now = new Date) {
+  const nowIso = now.toISOString();
+  const erase = outcome.state === "processed" || outcome.state === "ignored";
+  const { changes } = await getDbClient2().run(`UPDATE slack_inbound_receipts
+        SET state = ?, outcome_code = ?, error_code = ?, completed_at = ?, updated_at = ?,
+            payload_ciphertext = CASE WHEN ? THEN NULL ELSE payload_ciphertext END,
+            payload_erased_at = CASE WHEN ? THEN ? ELSE payload_erased_at END
+      WHERE id = ? AND state = 'processing'`, [
+    outcome.state,
+    outcome.outcomeCode ?? null,
+    outcome.errorCode ?? null,
+    outcome.state === "uncertain" ? null : nowIso,
+    nowIso,
+    erase ? 1 : 0,
+    erase ? 1 : 0,
+    nowIso,
+    id
+  ]);
+  return changes > 0;
+}
+async function releaseSlackInboundReceipt(id, errorCode, availableAt, now = new Date) {
+  const nowIso = now.toISOString();
+  const { changes } = await getDbClient2().run(`UPDATE slack_inbound_receipts
+        SET state = 'pending', error_code = ?, available_at = ?, claimed_at = NULL, updated_at = ?
+      WHERE id = ? AND state = 'processing'`, [errorCode, availableAt.toISOString(), nowIso, id]);
+  return changes > 0;
+}
+async function getNextSlackInboundAvailableAt() {
+  const row = await getDbClient2().get(`SELECT MIN(available_at) AS next FROM slack_inbound_receipts WHERE state = 'pending'`);
+  return row?.next ? new Date(row.next) : null;
+}
+async function markInterruptedSlackInboundReceiptsUncertain(now = new Date) {
+  const nowIso = now.toISOString();
+  const { changes } = await getDbClient2().run(`UPDATE slack_inbound_receipts
+        SET state = 'uncertain', error_code = 'interrupted_during_processing', updated_at = ?
+      WHERE state = 'processing'`, [nowIso]);
+  return changes;
+}
 async function getSlackInboundReceiptStats(uncertainLimit = 20) {
   const db = getDbClient2();
   return db.transaction(async (tx) => {
@@ -6122,6 +6296,7 @@ function emptyCounters() {
     ignored: 0,
     failed: 0,
     uncertain: 0,
+    ackNotReady: 0,
     lastOutcomeAt: null,
     lastFailure: null
   };
@@ -6140,6 +6315,9 @@ function recordOutcome(transport, outcome) {
     console.warn(`[Slack] inbound ${transport} delivery ${outcome.state}: ${outcome.code}`);
   }
 }
+function recordSlackSocketAckNotReady() {
+  counters.socket.ackNotReady += 1;
+}
 function slackInboundOutcomeMiddleware() {
   return async ({ next }) => {
     const existing = deliveryStorage.getStore();
@@ -6166,6 +6344,213 @@ function slackInboundOutcomeMiddleware() {
     });
   };
 }
+async function runAdmittedSlackDelivery(transport, fn, options = {}) {
+  const state = newDeliveryState(transport, true);
+  try {
+    await deliveryStorage.run(state, fn);
+  } catch (error) {
+    return resolveSlackInboundOutcome(state, error);
+  }
+  if (options.requireBoltDispatch && !state.dispatched) {
+    return { state: "failed", code: "not_dispatched" };
+  }
+  return resolveSlackInboundOutcome(state);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function stringField(body, key) {
+  const value = body[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function computeSlackInboundKey(kind, rawBody, body) {
+  if (!body || typeof body !== "object")
+    return { ok: false, reason: "malformed" };
+  const record = body;
+  const payloadType = stringField(record, "type") ?? (kind === "command" ? "command" : null);
+  if (!payloadType)
+    return { ok: false, reason: "malformed" };
+  const apiAppId = stringField(record, "api_app_id");
+  if (kind === "event" && payloadType === "event_callback") {
+    const eventId = stringField(record, "event_id");
+    if (!eventId)
+      return { ok: false, reason: "missing_event_id" };
+    return {
+      ok: true,
+      dedupKey: `event:${apiAppId ?? "-"}:${eventId}`,
+      payloadType,
+      apiAppId,
+      eventId
+    };
+  }
+  return {
+    ok: true,
+    dedupKey: `${kind}:${payloadType}:${sha256(rawBody)}`,
+    payloadType,
+    apiAppId,
+    eventId: null
+  };
+}
+function socketEventKey(body) {
+  if (body?.type !== "event_callback")
+    return null;
+  const key = computeSlackInboundKey("event", "", body);
+  return key.ok ? key : null;
+}
+async function isSlackSocketEventStored(body, now = new Date) {
+  const key = socketEventKey(body);
+  return key ? touchSlackInboundDuplicate(key.dedupKey, now) : false;
+}
+async function recordSlackSocketEventRanInline(body, retry = {}, now = new Date) {
+  const key = socketEventKey(body);
+  if (!key)
+    return "invalid";
+  return recordSlackInboundInline({
+    dedupKey: key.dedupKey,
+    transport: "socket",
+    kind: "event",
+    payloadType: key.payloadType,
+    apiAppId: key.apiAppId,
+    eventId: key.eventId,
+    retryNum: retry.retryNum,
+    retryReason: retry.retryReason
+  }, now);
+}
+async function admitSlackInbound(input, now = new Date) {
+  const key = computeSlackInboundKey(input.kind, input.rawBody, input.body);
+  if (!key.ok)
+    return { status: "invalid", reason: key.reason };
+  const payloadBytes = Buffer.byteLength(input.rawBody, "utf8");
+  if (payloadBytes > SLACK_INBOUND_LIMITS.maxPayloadBytes) {
+    return { status: "rejected", reason: "payload_too_large" };
+  }
+  return admitSlackInboundReceipt({
+    dedupKey: key.dedupKey,
+    transport: input.transport,
+    kind: input.kind,
+    payloadType: key.payloadType,
+    apiAppId: key.apiAppId,
+    eventId: key.eventId,
+    payloadCiphertext: encryptSecret(input.rawBody, getEncryptionKey()),
+    payloadBytes,
+    retryNum: input.retryNum ?? null,
+    retryReason: input.retryReason ?? null
+  }, now);
+}
+async function processNextSlackInboundReceipt(processor, options = {}) {
+  const now = options.now ?? (() => new Date);
+  const receipt = await claimSlackInboundReceipt(now());
+  if (!receipt)
+    return null;
+  let rawBody;
+  try {
+    if (!receipt.payloadCiphertext)
+      throw new Error("payload already erased");
+    rawBody = decryptSecret(receipt.payloadCiphertext, getEncryptionKey());
+  } catch {
+    const outcome = { state: "failed", code: "payload_unreadable" };
+    await completeSlackInboundReceipt(receipt.id, { state: "failed", errorCode: outcome.code }, now());
+    recordOutcome(receipt.transport, outcome);
+    return { receiptId: receipt.id, outcome, state: "failed" };
+  }
+  const outcome = await runAdmittedSlackDelivery(receipt.transport, () => processor({ receipt, rawBody }), { requireBoltDispatch: options.requireBoltDispatch });
+  recordOutcome(receipt.transport, outcome);
+  if (outcome.state === "failed" && receipt.attempts < SLACK_INBOUND_LIMITS.maxAttempts) {
+    const availableAt = new Date(now().getTime() + SLACK_INBOUND_LIMITS.retryBackoffMs * receipt.attempts);
+    await releaseSlackInboundReceipt(receipt.id, outcome.code, availableAt, now());
+    return { receiptId: receipt.id, outcome, state: "pending" };
+  }
+  await completeSlackInboundReceipt(receipt.id, {
+    state: outcome.state,
+    outcomeCode: outcome.state === "processed" || outcome.state === "ignored" ? outcome.code : null,
+    errorCode: outcome.state === "failed" || outcome.state === "uncertain" ? outcome.code : null
+  }, now());
+  return { receiptId: receipt.id, outcome, state: outcome.state };
+}
+var defaultTimer = (fn, delayMs) => {
+  const handle = setTimeout(fn, delayMs);
+  handle.unref?.();
+  return () => clearTimeout(handle);
+};
+var MIN_REARM_MS = 250;
+function createSlackInboundDrain(processor, options = {}) {
+  const maxPerPass = options.maxPerPass ?? 50;
+  const now = options.now ?? (() => new Date);
+  const setTimer = options.setTimer ?? defaultTimer;
+  let running = null;
+  let again = false;
+  let stopped = false;
+  let cancelTimer = null;
+  const clearTimer = () => {
+    cancelTimer?.();
+    cancelTimer = null;
+  };
+  const pass = async () => {
+    for (let i = 0;i < maxPerPass; i++) {
+      const result = await processNextSlackInboundReceipt(processor, {
+        now,
+        requireBoltDispatch: options.requireBoltDispatch
+      });
+      if (!result)
+        return;
+    }
+  };
+  const armRetryTimer = async () => {
+    const next = await getNextSlackInboundAvailableAt();
+    if (!next || stopped)
+      return;
+    const delayMs = Math.max(next.getTime() - now().getTime(), MIN_REARM_MS);
+    cancelTimer = setTimer(() => {
+      cancelTimer = null;
+      drain.wake();
+    }, delayMs);
+  };
+  const loop = async () => {
+    do {
+      again = false;
+      clearTimer();
+      try {
+        await pass();
+      } catch (error) {
+        console.error("[Slack] inbound drain pass failed:", scrubSecrets(String(error)));
+        return;
+      }
+      if (again)
+        continue;
+      try {
+        await armRetryTimer();
+      } catch (error) {
+        console.error("[Slack] inbound drain could not arm retry:", scrubSecrets(String(error)));
+      }
+    } while (again);
+  };
+  const drain = {
+    wake() {
+      if (stopped)
+        return Promise.resolve();
+      if (running) {
+        again = true;
+        return running;
+      }
+      running = loop().finally(() => {
+        running = null;
+      });
+      return running;
+    },
+    stop() {
+      stopped = true;
+      clearTimer();
+    }
+  };
+  return drain;
+}
+async function recoverSlackInboundAfterRestart(now = new Date) {
+  const interrupted = await markInterruptedSlackInboundReceiptsUncertain(now);
+  if (interrupted > 0) {
+    console.warn(`[Slack] ${interrupted} inbound receipt(s) were interrupted mid-processing and are now uncertain`);
+  }
+  return interrupted;
+}
 async function getSlackInboundDiagnostics() {
   const config = getSlackConfiguration();
   return {
@@ -6180,6 +6565,117 @@ async function getSlackInboundDiagnostics() {
   };
 }
 
+// src/slack/socket-ack.ts
+var NOT_READY_MESSAGE = "Failed to send a WebSocket message as the client is not ready";
+function isSocketNotReadyError(error) {
+  return error instanceof Error && error.message === NOT_READY_MESSAGE;
+}
+var ORDER_DEPENDENT_EVENTS = new Set(["assistant_thread_context_changed"]);
+function isOrderDependentEvent(body) {
+  const type = body?.event?.type;
+  return typeof type === "string" && ORDER_DEPENDENT_EVENTS.has(type);
+}
+function tolerateSocketNotReadyAcks(client, options) {
+  const emit = client.emit.bind(client);
+  const deliver = (event, args) => emit(event, ...args);
+  client.emit = (event, ...args) => {
+    const payload = args[0];
+    if (event !== "slack_event" || payload?.type !== "events_api" || typeof payload.ack !== "function") {
+      return deliver(event, args);
+    }
+    const ack = payload.ack;
+    const envelope = payload.envelope_id ?? "unknown";
+    payload.ack = async (response) => {
+      try {
+        await ack(response);
+      } catch (error) {
+        if (!isSocketNotReadyError(error))
+          throw error;
+        recordSlackSocketAckNotReady();
+        const disposition = await dispose(payload, envelope);
+        if (disposition === "drain") {
+          options.onAdmitted();
+          throw error;
+        }
+        if (disposition === "drop")
+          throw error;
+        console.warn(`[Slack] socket ack failed (client not ready), processing inline: envelope_id=${envelope}`);
+      }
+    };
+    if (typeof payload.retry_num !== "number" || payload.retry_num < 1) {
+      return deliver(event, args);
+    }
+    (async () => {
+      let stored = false;
+      try {
+        stored = await isSlackSocketEventStored(payload.body);
+      } catch (storeError) {
+        console.warn("[Slack] could not check stored event key, processing:", storeError);
+      }
+      if (!stored) {
+        deliver(event, args);
+        return;
+      }
+      console.log(`[Slack] dropping redelivery of a stored event: envelope_id=${envelope}`);
+      try {
+        await ack();
+      } catch (error) {
+        console.warn("[Slack] ack of a dropped redelivery failed:", error);
+      }
+    })();
+    return client.listenerCount(event) > 0;
+  };
+}
+async function dispose(payload, envelope) {
+  if (isOrderDependentEvent(payload.body)) {
+    rememberInline(payload, envelope);
+    return "inline";
+  }
+  try {
+    const result = await admitSlackInbound({
+      transport: "socket",
+      kind: "event",
+      rawBody: JSON.stringify(payload.body),
+      body: payload.body,
+      retryNum: payload.retry_num,
+      retryReason: payload.retry_reason
+    });
+    if (result.status === "admitted" || result.status === "duplicate") {
+      console.warn(`[Slack] socket ack failed (client not ready), event stored for the drain: envelope_id=${envelope}`);
+      return "drain";
+    }
+    console.warn(`[Slack] could not store unacked event (${result.reason}): envelope_id=${envelope}`);
+  } catch (storeError) {
+    console.warn("[Slack] could not persist unacked event:", storeError);
+  }
+  return "inline";
+}
+async function rememberInline(payload, envelope) {
+  try {
+    const result = await recordSlackSocketEventRanInline(payload.body, {
+      retryNum: payload.retry_num,
+      retryReason: payload.retry_reason
+    });
+    if (result === "duplicate") {
+      console.warn(`[Slack] inline event key was already stored: envelope_id=${envelope}`);
+    }
+  } catch (storeError) {
+    console.warn("[Slack] could not remember unacked inline event:", storeError);
+  }
+}
+function installSocketAckRecovery(client, app) {
+  const drain = createSlackInboundDrain(async ({ receipt, rawBody }) => {
+    await app.processEvent({
+      body: JSON.parse(rawBody),
+      ack: async () => {},
+      retryNum: receipt.retryNum ?? undefined,
+      retryReason: receipt.retryReason ?? undefined
+    });
+  }, { requireBoltDispatch: true });
+  tolerateSocketNotReadyAcks(client, { onAdmitted: () => void drain.wake() });
+  return drain;
+}
+
 // src/slack/socket-mode-guard.ts
 init_env_flag();
 var SLACK_DEV_SOCKET_MODE_OPT_IN = "SLACK_ALLOW_DEV_SOCKET_MODE";
@@ -6240,7 +6736,7 @@ async function initOtel(serviceRole = process.env.AGENT_ROLE || "api") {
     return;
   initialized = true;
   try {
-    const impl = await import("./otel-impl-epet9j18.js");
+    const impl = await import("./otel-impl-jerq8vz8.js");
     await impl.boot(serviceRole, {
       exportConsoleLogs: serviceRole === "api" && isApiLogExportEnabled()
     });
@@ -7616,7 +8112,7 @@ async function sendInlineTaskOutput(task) {
 
 `),
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks: batch.map((chunk) => ({
           type: "section",
           text: { type: "mrkdwn", text: chunk }
@@ -7669,7 +8165,7 @@ async function sendTaskResponse(task) {
           thread_ts: task.slackThreadTs,
           text: task.slackReplySent || i > 0 ? `${completedStatusIcon()} ${agentName} completed${i > 0 ? ` (continued ${i + 1}/${blockBatches.length})` : ""}` : body,
           username: getAgentDisplayName(agent),
-          icon_emoji: getAgentEmoji(agent),
+          icon: getAgentSlackIcon(agent),
           blocks: blockBatches[i]
         });
       }
@@ -7681,7 +8177,7 @@ async function sendTaskResponse(task) {
         thread_ts: task.slackThreadTs,
         text: `Task failed: ${reason}`,
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks
       });
     } else if (task.status === "cancelled") {
@@ -7691,7 +8187,7 @@ async function sendTaskResponse(task) {
         thread_ts: task.slackThreadTs,
         text: "Task cancelled",
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks
       });
     }
@@ -7718,7 +8214,7 @@ async function sendProgressUpdate(task, progress) {
       thread_ts: task.slackThreadTs,
       text: progress,
       username: getAgentDisplayName(agent),
-      icon_emoji: getAgentEmoji(agent),
+      icon: getAgentSlackIcon(agent),
       blocks
     });
   } catch (error) {
@@ -7809,7 +8305,7 @@ async function updateToFinal(task, messageTs) {
           thread_ts: task.slackThreadTs ?? messageTs,
           text: `${completedStatusIcon()} ${agentName} completed (continued ${i + 1}/${completionBlockBatches.length})`,
           username: getAgentDisplayName(agent),
-          icon_emoji: getAgentEmoji(agent),
+          icon: getAgentSlackIcon(agent),
           blocks: completionBlockBatches[i]
         });
       }
@@ -7861,11 +8357,20 @@ async function sendWithPersona(client, options) {
     unfurl_links: false,
     unfurl_media: false,
     username: options.username,
-    icon_emoji: options.icon_emoji,
+    ...options.icon,
     blocks
   });
   return result.ts;
 }
+function getAgentSlackIcon(agent) {
+  if (agent.slackIcon?.type === "url")
+    return { icon_url: agent.slackIcon.url };
+  if (agent.slackIcon?.type === "emoji")
+    return { icon_emoji: agent.slackIcon.emoji };
+  if (agent.slackIcon?.type === "app")
+    return {};
+  return { icon_emoji: getAgentEmoji(agent) };
+}
 function getAgentEmoji(agent) {
   if (agent.isLead)
     return ":crown:";
@@ -8620,7 +9125,7 @@ async function createThreadTree(task) {
       blocks: treeBlocks(text),
       unfurl_links: false,
       unfurl_media: false,
-      ...agent ? { username: getAgentDisplayName(agent), icon_emoji: getAgentEmoji(agent) } : {},
+      ...agent ? { username: getAgentDisplayName(agent), ...getAgentSlackIcon(agent) } : {},
       metadata: {
         event_type: SLACK_RENDER_METADATA_EVENT,
         event_payload: { message_id: reservation.id, kind: "tree" }
@@ -9035,10 +9540,8 @@ async function streamOutcomeCard(task, tree, options) {
     markdown_text: presentation
   };
   const agent = task.agentId ? await getAgentById2(task.agentId) : undefined;
-  if (agent) {
-    startPayload.username = getAgentDisplayName(agent);
-    startPayload.icon_emoji = getAgentEmoji(agent);
-  }
+  const persona = agent ? { username: getAgentDisplayName(agent), ...getAgentSlackIcon(agent) } : {};
+  Object.assign(startPayload, persona);
   if (!task.slackChannelId.startsWith("D") && task.slackUserId) {
     const teamId = await slackTeamId(app.client);
     if (teamId) {
@@ -9081,8 +9584,7 @@ async function streamOutcomeCard(task, tree, options) {
           thread_ts: task.slackThreadTs,
           text: presentation,
           blocks: [{ type: "markdown", text: presentation }, ...captions],
-          ...startPayload.username ? { username: startPayload.username } : {},
-          ...startPayload.icon_emoji ? { icon_emoji: startPayload.icon_emoji } : {}
+          ...persona
         });
         deliveredViaFallback = true;
       }
@@ -9721,7 +10223,7 @@ async function postInitialDMTreeMessage(task) {
       unfurl_links: false,
       unfurl_media: false,
       username: getAgentDisplayName(agent),
-      icon_emoji: getAgentEmoji(agent),
+      ...getAgentSlackIcon(agent),
       blocks
     });
     if (result.ts) {
@@ -10018,6 +10520,7 @@ function stopTaskWatcher() {
 var app = null;
 var receiver = null;
 var initialized2 = false;
+var inboundDrain = null;
 var SOCKET_EVENT_STATES = {
   connecting: "connecting",
   reconnecting: "connecting",
@@ -10083,19 +10586,20 @@ async function initSlackApp2() {
     logLevel,
     ...clientOptions ? { clientOptions } : {}
   });
+  inboundDrain = installSocketAckRecovery(receiver.client, app);
   initialized2 = true;
   app.use(slackInboundOutcomeMiddleware());
-  const { registerMessageHandler } = await import("./handlers-7x8sywgr.js");
-  const { registerCommandHandler } = await import("./commands-nw1dn4av.js");
-  const { registerActionHandlers } = await import("./actions-rd9xn281.js");
-  const { registerWorkObjectHandlers } = await import("./work-objects-ftj4zw70.js");
+  const { registerMessageHandler } = await import("./handlers-ss5948rq.js");
+  const { registerCommandHandler } = await import("./commands-hwdhacfx.js");
+  const { registerActionHandlers } = await import("./actions-a90cfpca.js");
+  const { registerWorkObjectHandlers } = await import("./work-objects-x7rb53qn.js");
   registerMessageHandler(app);
   registerCommandHandler(app);
   registerActionHandlers(app);
   registerWorkObjectHandlers(app);
-  const { createAssistant } = await import("./assistant-6jbzs8wa.js");
+  const { createAssistant } = await import("./assistant-ck01q2yg.js");
   app.assistant(createAssistant());
-  const { isBlockExternalEnabled, scanExternalChannelsOnBoot } = await import("./external-channel-mf9vp1fe.js");
+  const { isBlockExternalEnabled, scanExternalChannelsOnBoot } = await import("./external-channel-g6vv85zv.js");
   if (isBlockExternalEnabled()) {
     scanExternalChannelsOnBoot(app.client).catch((error) => {
       console.error("[Slack] External channel boot scan failed:", error);
@@ -10108,11 +10612,13 @@ async function startSlackApp2() {
     await initSlackApp2();
   }
   if (app) {
-    const { isSlackRenderV2Enabled } = await import("./render-v2-cy8zsfsf.js");
+    const { isSlackRenderV2Enabled } = await import("./render-v2-65x4ayj8.js");
     if (isSlackRenderV2Enabled())
       await ensureSlackRenderV2Activation2();
+    await recoverSlackInboundAfterRestart();
     await app.start();
     console.log("[Slack] Bot connected via Socket Mode");
+    inboundDrain?.wake();
     await emitBuiltInIntegrationConnectedOnce2("slack");
     await startTaskWatcher();
     return true;
@@ -10121,6 +10627,8 @@ async function startSlackApp2() {
 }
 async function stopSlackApp2() {
   stopTaskWatcher();
+  inboundDrain?.stop();
+  inboundDrain = null;
   if (app) {
     await app.stop();
     app = null;
@@ -10131,4 +10639,4 @@ async function stopSlackApp2() {
   initialized2 = false;
 }
 
-export { require_dist4, getSlackConnectionState, noteSlackInboundSideEffect, ignoreSlackInbound, reportSlackInboundFailure, isAdmittedSlackDelivery, getSlackInboundDiagnostics, terminalReactionEvent, isPollTracingEnabled, initOtel, withSpan2, startSpan2, withSpanContext2, withRemoteContext2, injectTraceContext2, recordSessionCost2, recordDbRetentionSweep2, recordDbRetentionStatement2, slackTaskOutput, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildMrkdwnSectionBlocks, buildCaptionBlock, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, taskCitationIssues, stripInvalidTaskCitations, taskCitationSourceGroups, renderTaskCitations, taskCitationWarnings, MAX_TASK_CITATIONS, CitationInputSchema, TaskCitationSchema, upsertTaskCitations, getTaskCitations, getTaskCitationsForTasks, hasTaskCitationCheckRefusal, initialize, ensure, getAgentDisplayName, getAgentEmoji, markSlackSessionProcessing, isSlackRenderV2Enabled2, callSlackWithRetry2, ensureSlackThreadTree2, slackErrorCode2, processSlackRenderV22, registerTreeMessage, getSlackApp2, initSlackApp2, startSlackApp2, stopSlackApp2 };
+export { require_dist4, getSlackConnectionState, noteSlackInboundSideEffect, ignoreSlackInbound, reportSlackInboundFailure, isAdmittedSlackDelivery, getSlackInboundDiagnostics, terminalReactionEvent, isPollTracingEnabled, initOtel, withSpan2, startSpan2, withSpanContext2, withRemoteContext2, injectTraceContext2, recordSessionCost2, recordDbRetentionSweep2, recordDbRetentionStatement2, slackTaskOutput, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildMrkdwnSectionBlocks, buildCaptionBlock, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, taskCitationIssues, stripInvalidTaskCitations, taskCitationSourceGroups, renderTaskCitations, taskCitationWarnings, MAX_TASK_CITATIONS, CitationInputSchema, TaskCitationSchema, upsertTaskCitations, getTaskCitations, getTaskCitationsForTasks, hasTaskCitationCheckRefusal, initialize, ensure, getAgentDisplayName, getAgentSlackIcon, markSlackSessionProcessing, isSlackRenderV2Enabled2, callSlackWithRetry2, ensureSlackThreadTree2, slackErrorCode2, processSlackRenderV22, registerTreeMessage, getSlackApp2, initSlackApp2, startSlackApp2, stopSlackApp2 };