@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/src/slack/event-dedup.test.ts

@@ -45,6 +45,17 @@ describe("wasEventSeen (production cache)", () => {
 });
 
 describe("isolated test cache (TTL behavior)", () => {
+  test("default TTL still drops a redelivery after Slack's 24h delayed-retry window", () => {
+    const cache = _createTestCache();
+    try {
+      expect(cache.wasEventSeen("Ev_late")).toBe(false);
+      cache.advance(24 * 60 * 60 * 1000); // last delayed-events retry
+      expect(cache.wasEventSeen("Ev_late")).toBe(true);
+    } finally {
+      cache.destroy();
+    }
+  });
+
   test("entry expires after TTL elapses", () => {
     const cache = _createTestCache(1000); // 1s TTL
     try {

package/src/slack/event-dedup.ts

@@ -13,15 +13,19 @@
  * This module exposes a single in-memory check-and-insert that returns `false`
  * the first time we see an event_id (caller should proceed) and `true` on
  * subsequent retries within the TTL window — i.e. it answers "was this event
- * already seen?" (default TTL 5 min). Slack's max retry window is 1h with 3
- * retries, but the second retry typically lands within 60s, so 5 min is a
- * safe-but-tight bound.
+ * already seen?" (default TTL 25h). The TTL must outlive the last possible
+ * redelivery: Slack's standard schedule ends after ~5 min, but the optional
+ * Delayed Events feature retries hourly for 24h. The socket-ack wrapper
+ * (`socket-ack.ts`) runs listeners for an event whose ack failed, so this cache
+ * is what drops the later redelivery. Entries are an id and a number, so the
+ * long TTL costs little memory.
  *
  * Single-pod-only. The API server (which owns the Slack socket) runs as a
  * single API process; if that ever changes, swap this for a DB-backed table.
  */
 
-const DEFAULT_TTL_MS = 300_000; // 5 minutes
+export const EVENT_DEDUP_TTL_MS = 25 * 60 * 60 * 1000; // 24h delayed-retry window + 1h margin
+const DEFAULT_TTL_MS = EVENT_DEDUP_TTL_MS;
 const CLEANUP_INTERVAL_MS = 60_000; // 1 minute
 
 interface DedupCache {

package/src/slack/inbound-dispatch.ts

@@ -9,6 +9,7 @@ import {
   getNextSlackInboundAvailableAt,
   getSlackInboundReceiptStats,
   markInterruptedSlackInboundReceiptsUncertain,
+  recordSlackInboundInline,
   releaseSlackInboundReceipt,
   SLACK_INBOUND_LIMITS,
   type SlackInboundAdmission,
@@ -16,6 +17,7 @@ import {
   type SlackInboundReceipt,
   type SlackInboundReceiptStats,
   type SlackInboundTransport,
+  touchSlackInboundDuplicate,
 } from "../be/db-queries/slack-inbound";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { getSlackConfiguration, type SlackMode } from "./config";
@@ -128,6 +130,8 @@ export function resolveSlackInboundOutcome(
 // ─── Outcome counters (Socket Mode is observed, not stored) ─────────────────
 
 type OutcomeCounters = Record<SlackInboundOutcomeState, number> & {
+  /** Socket acks that failed because the client was not ready; the event still ran. */
+  ackNotReady: number;
   lastOutcomeAt: string | null;
   lastFailure: { code: string; at: string } | null;
 };
@@ -138,6 +142,7 @@ function emptyCounters(): OutcomeCounters {
     ignored: 0,
     failed: 0,
     uncertain: 0,
+    ackNotReady: 0,
     lastOutcomeAt: null,
     lastFailure: null,
   };
@@ -159,6 +164,11 @@ function recordOutcome(transport: SlackInboundTransport, outcome: SlackInboundOu
   }
 }
 
+/** Count a Socket Mode ack that failed because the client was not ready. */
+export function recordSlackSocketAckNotReady(): void {
+  counters.socket.ackNotReady += 1;
+}
+
 /** Test-only. */
 export function resetSlackInboundCountersForTests(): void {
   counters.socket = emptyCounters();
@@ -290,6 +300,54 @@ export function computeSlackInboundKey(
   };
 }
 
+/** Dedup key for a Socket Mode `event_callback` body, or null for any other envelope. */
+function socketEventKey(body: unknown): Extract<SlackInboundKeyResult, { ok: true }> | null {
+  if ((body as { type?: unknown } | null)?.type !== "event_callback") return null;
+  const key = computeSlackInboundKey("event", "", body);
+  return key.ok ? key : null;
+}
+
+/**
+ * Is this Socket Mode event already stored as a receipt (admitted after a
+ * failed ack)? Counts the sighting. A stored receipt is owned by the drain, so
+ * a redelivery needs no second run.
+ */
+export async function isSlackSocketEventStored(
+  body: unknown,
+  now: Date = new Date(),
+): Promise<boolean> {
+  const key = socketEventKey(body);
+  return key ? touchSlackInboundDuplicate(key.dedupKey, now) : false;
+}
+
+/**
+ * Remember a Socket Mode event that runs inline after a failed ack, so its
+ * redelivery is dropped by `isSlackSocketEventStored` even after a restart.
+ * Stores the dedup key only, never the payload. `invalid` when the envelope has
+ * no usable key (nothing to remember, the caller still runs it).
+ */
+export async function recordSlackSocketEventRanInline(
+  body: unknown,
+  retry: { retryNum?: number | null; retryReason?: string | null } = {},
+  now: Date = new Date(),
+): Promise<"recorded" | "duplicate" | "invalid"> {
+  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,
+  );
+}
+
 export interface AdmitSlackInboundInput {
   transport: SlackInboundTransport;
   kind: SlackInboundKind;

package/src/slack/render-v2.ts

@@ -52,7 +52,7 @@ import {
 } from "./blocks";
 import { buildAskClosure, type ClosureState, closureState } from "./closure";
 import { completedStatusIcon, reactionName, type SlackReactionEvent } from "./reaction-shortcode";
-import { getAgentDisplayName, getAgentEmoji } from "./responses";
+import { getAgentDisplayName, getAgentSlackIcon } from "./responses";
 import {
   _resetSlackSessionStatusForTests,
   beginSlackStatusTick,
@@ -675,7 +675,7 @@ async function createThreadTree(task: AgentTask): Promise<SlackMessageRecord | n
       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" },
@@ -1312,10 +1312,10 @@ export async function streamOutcomeCard(
     markdown_text: presentation,
   };
   const agent = task.agentId ? await getAgentById(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) {
@@ -1379,8 +1379,7 @@ export async function streamOutcomeCard(
           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;
       }

package/src/slack/responses.ts

@@ -99,7 +99,7 @@ export async function sendInlineTaskOutput(task: AgentTask): Promise<boolean> {
         thread_ts: task.slackThreadTs,
         text: batch.join("\n\n"),
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks: batch.map((chunk) => ({
           type: "section",
           text: { type: "mrkdwn", text: chunk },
@@ -173,7 +173,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
               ? `${completedStatusIcon()} ${agentName} completed${i > 0 ? ` (continued ${i + 1}/${blockBatches.length})` : ""}`
               : body,
           username: getAgentDisplayName(agent),
-          icon_emoji: getAgentEmoji(agent),
+          icon: getAgentSlackIcon(agent),
           blocks: blockBatches[i],
         });
       }
@@ -185,7 +185,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
         thread_ts: task.slackThreadTs,
         text: `Task failed: ${reason}`,
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks,
       });
     } else if (task.status === "cancelled") {
@@ -195,7 +195,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
         thread_ts: task.slackThreadTs,
         text: "Task cancelled",
         username: getAgentDisplayName(agent),
-        icon_emoji: getAgentEmoji(agent),
+        icon: getAgentSlackIcon(agent),
         blocks,
       });
     }
@@ -232,7 +232,7 @@ export async function sendProgressUpdate(
       thread_ts: task.slackThreadTs,
       text: progress,
       username: getAgentDisplayName(agent),
-      icon_emoji: getAgentEmoji(agent),
+      icon: getAgentSlackIcon(agent),
       blocks,
     });
   } catch (error) {
@@ -354,7 +354,7 @@ export async function updateToFinal(
           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],
         });
       }
@@ -418,7 +418,7 @@ export async function sendWithPersona(
     thread_ts: string;
     text: string;
     username: string;
-    icon_emoji: string;
+    icon: SlackPersonaIcon;
     blocks?: unknown[];
   },
 ): Promise<string | undefined> {
@@ -433,7 +433,7 @@ export async function sendWithPersona(
     unfurl_links: false,
     unfurl_media: false,
     username: options.username,
-    icon_emoji: options.icon_emoji,
+    ...options.icon,
     // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects are typed as plain JSON
     blocks: blocks as any,
   });
@@ -441,6 +441,19 @@ export async function sendWithPersona(
   return result.ts;
 }
 
+/** Empty = no override, so Slack shows the app's own avatar. */
+export type SlackPersonaIcon =
+  | { icon_emoji: string }
+  | { icon_url: string }
+  | Record<string, never>;
+
+export function getAgentSlackIcon(agent: Agent): SlackPersonaIcon {
+  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) };
+}
+
 export function getAgentEmoji(agent: Agent): string {
   if (agent.isLead) return ":crown:";
 

package/src/slack/socket-ack.ts

@@ -0,0 +1,237 @@
+import type { App, SocketModeReceiver } from "@slack/bolt";
+import {
+  admitSlackInbound,
+  createSlackInboundDrain,
+  isSlackSocketEventStored,
+  recordSlackSocketAckNotReady,
+  recordSlackSocketEventRanInline,
+} from "./inbound-dispatch";
+
+/** @slack/socket-mode `sendWhileNotReadyError()`: the socket is down or reconnecting. */
+const NOT_READY_MESSAGE = "Failed to send a WebSocket message as the client is not ready";
+
+export function isSocketNotReadyError(error: unknown): boolean {
+  return error instanceof Error && error.message === NOT_READY_MESSAGE;
+}
+
+/**
+ * Events whose effect is "last write wins". Run late from the drain they would
+ * overwrite a newer event that already ran live, so they never wait in the queue.
+ * They run inline and leave only a dedup-key tombstone behind.
+ */
+const ORDER_DEPENDENT_EVENTS = new Set(["assistant_thread_context_changed"]);
+
+function isOrderDependentEvent(body: unknown): boolean {
+  const type = (body as { event?: { type?: unknown } } | undefined)?.event?.type;
+  return typeof type === "string" && ORDER_DEPENDENT_EVENTS.has(type);
+}
+
+type SocketAck = (response?: Record<string, unknown>) => Promise<void>;
+
+interface SocketEnvelope {
+  ack?: SocketAck;
+  envelope_id?: string;
+  type?: string;
+  body?: unknown;
+  retry_num?: number;
+  retry_reason?: string;
+}
+
+interface SocketAckOptions {
+  /** Called after a not-ready event was stored as a pending receipt: start the drain. */
+  onAdmitted: () => void;
+}
+
+/**
+ * Bolt acks an Events API delivery before it runs any middleware or listener,
+ * and the receiver drops the event when that ack throws. A stalled event loop
+ * can kill the socket between receive and ack, so the event is lost.
+ *
+ * Wrap the ack Bolt receives on each `slack_event`. When it fails only because
+ * the socket is not ready, persist the event as a `pending` receipt (encrypted
+ * payload plus dedup key, in one transaction) and wake the durable drain, which
+ * hands it back to Bolt (`app.processEvent`) and records its outcome. Bolt's own
+ * copy still drops, because the original error is rethrown. Work is persisted
+ * before anything runs, so a crash or a failing middleware leaves a recoverable
+ * receipt rather than a "processed" marker: a `pending` receipt is retried after
+ * a restart, and a delivery that failed before any side effect is retried with
+ * backoff. Only a crash mid-listener leaves it `uncertain`, which the drain
+ * never replays, as for every durable delivery.
+ *
+ * If the receipt cannot be stored (store down, backlog full, no event id) the
+ * ack error is swallowed instead and Bolt runs the listeners inline, deduped
+ * only by the in-memory `event_id` cache: losing the event is the worse failure.
+ * Order-dependent events (`assistant_thread_context_changed`, last write wins)
+ * take that inline path by design: queued, an older one could run after a newer
+ * one that ran live and overwrite it. Their dedup key is stored alongside, off
+ * the ack path (Bolt runs the listener once the ack settles, so awaiting the
+ * write would let a newer live event run first), with no payload and no way for
+ * the drain to claim it. The in-memory cache is then not the only thing standing
+ * between a redelivery and a restart: after one, an older context would
+ * otherwise overwrite a newer one. A crash before that write lands loses only
+ * this protection, and a redelivery in that window can run twice.
+ * Any other ack error still throws.
+ *
+ * Slack redelivers the unacked event with the same `event_id` and a
+ * `retry_num`. The redelivery is dropped before it reaches Bolt when its key is
+ * stored, so the receipt stays the single owner of the work, also across a
+ * restart. Only retries pay the lookup; first deliveries emit synchronously. If
+ * the lookup fails the retry runs.
+ *
+ * Only `events_api` envelopes are wrapped. Interactive payloads (modal
+ * submissions, button actions) and slash commands ack from inside their
+ * handler, which does the work after acking: swallowing a failed ack there
+ * would run the handler while Slack shows the user an error, and the retry
+ * would run it again.
+ *
+ * Wrapping `emit` (public) is the narrowest hook: the receiver builds its own
+ * client and reads `args.ack` when its `slack_event` listener runs.
+ */
+function tolerateSocketNotReadyAcks(
+  client: SocketModeReceiver["client"],
+  options: SocketAckOptions,
+): void {
+  const emit = client.emit.bind(client);
+  const deliver = (event: string | symbol, args: unknown[]) => emit(event, ...args);
+
+  client.emit = (event: string | symbol, ...args: unknown[]): boolean => {
+    const payload = args[0] as SocketEnvelope | undefined;
+    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; // Bolt drops its copy; the receipt carries the event.
+        }
+        if (disposition === "drop") throw error; // An earlier delivery already ran it.
+        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);
+    }
+
+    // A redelivery: drop it when a receipt already owns the event.
+    void (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;
+  };
+}
+
+type Disposition =
+  /** Stored as a pending receipt: the drain runs it. */
+  | "drain"
+  /** Its key was already stored: an earlier delivery owns it. */
+  | "drop"
+  /** Not stored for the drain (store failure, or order-dependent): Bolt runs it inline. */
+  | "inline";
+
+async function dispose(payload: SocketEnvelope, envelope: string): Promise<Disposition> {
+  if (isOrderDependentEvent(payload.body)) {
+    // Not awaited: Bolt runs the listener once the ack settles, so a slow or
+    // blocked write would hold this event behind a newer one that ran live.
+    void 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";
+}
+
+/**
+ * An order-dependent event runs inline. Its key is stored alongside (no payload,
+ * nothing for the drain to claim) so a redelivery after a restart is dropped
+ * instead of overwriting a newer event that ran in between. The write is
+ * best-effort and off the ack path: it never delays the event, and a store
+ * failure only costs the restart protection, never the event.
+ */
+async function rememberInline(payload: SocketEnvelope, envelope: string): Promise<void> {
+  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);
+  }
+}
+
+/**
+ * Install the not-ready ack tolerance on the receiver's client and the durable
+ * drain that runs the receipts it stores. The caller owns the drain: `wake()` it
+ * after boot recovery to pick up receipts stored before a restart, `stop()` it
+ * on shutdown.
+ */
+export function installSocketAckRecovery(
+  client: SocketModeReceiver["client"],
+  app: Pick<App, "processEvent">,
+): ReturnType<typeof createSlackInboundDrain> {
+  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;
+}

package/src/slack/thread-buffer.ts

@@ -23,7 +23,7 @@ import {
 } from "./inbound-files";
 import { extractSlackMessageText } from "./message-text";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
-import { getAgentDisplayName, getAgentEmoji } from "./responses";
+import { getAgentDisplayName, getAgentSlackIcon } from "./responses";
 import { formatSlackSteeringAck, requestSlackThreadSteering } from "./steering";
 import { registerTreeMessage } from "./watcher";
 
@@ -257,9 +257,7 @@ async function slackFlush(
             text: formatSlackSteeringAck(steering.result),
             unfurl_links: false,
             unfurl_media: false,
-            ...(agent
-              ? { username: getAgentDisplayName(agent), icon_emoji: getAgentEmoji(agent) }
-              : {}),
+            ...(agent ? { username: getAgentDisplayName(agent), ...getAgentSlackIcon(agent) } : {}),
           });
         } catch (error) {
           console.error("[Slack] Failed to post steering feedback:", error);
@@ -363,7 +361,7 @@ async function slackFlush(
         text: fallbackText,
         unfurl_links: false,
         unfurl_media: false,
-        ...(lead ? { username: getAgentDisplayName(lead), icon_emoji: getAgentEmoji(lead) } : {}),
+        ...(lead ? { username: getAgentDisplayName(lead), ...getAgentSlackIcon(lead) } : {}),
         // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
         blocks: blocks as any,
       });

package/src/slack/watcher.ts

@@ -18,7 +18,7 @@ import { buildTreeBlocks, formatDuration } from "./blocks";
 import { isSlackRenderV2Enabled, processSlackRenderV2 } from "./render-v2";
 import {
   getAgentDisplayName,
-  getAgentEmoji,
+  getAgentSlackIcon,
   sendInlineTaskOutput,
   sendProgressUpdate,
   sendTaskResponse,
@@ -491,7 +491,7 @@ async function postInitialDMTreeMessage(task: AgentTask): Promise<string | undef
       unfurl_links: false,
       unfurl_media: false,
       username: getAgentDisplayName(agent),
-      icon_emoji: getAgentEmoji(agent),
+      ...getAgentSlackIcon(agent),
       // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
       blocks: blocks as any,
     });

package/src/slack/work-objects.ts

@@ -3,8 +3,10 @@ import type { EntityPresentDetailsArguments, WebClient } from "@slack/web-api";
 import { getAgentById, getTaskById } from "../be/db";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { getTaskUrl } from "./blocks";
+import { wasEventSeen } from "./event-dedup";
 import { shouldBlockChannel } from "./external-channel";
 import { isUserAllowed } from "./handlers";
+import { isAdmittedSlackDelivery } from "./inbound-dispatch";
 import { slackTaskOutput } from "./task-output";
 
 type DetailsEvent = SlackEventMiddlewareArgs<"entity_details_requested">["event"];
@@ -93,8 +95,10 @@ async function getDetails(event: DetailsEvent, client: WebClient): Promise<Detai
 
 export function registerWorkObjectHandlers(app: App): void {
   // Bolt acknowledges Events API deliveries; the flexpane needs a separate API response.
-  app.event("entity_details_requested", async ({ event, client, logger }) => {
+  app.event("entity_details_requested", async ({ event, body, client, logger }) => {
     if (!isEnvFlagEnabled("SLACK_WORK_OBJECTS_ENABLED", false)) return;
+    // A redelivery after a tolerated socket ack failure must not present twice.
+    if (!isAdmittedSlackDelivery() && wasEventSeen(body?.event_id)) return;
 
     let details: Details;
     try {

package/src/tests/agent-fs-release-notes.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import { renderAgentFsReleaseNotes } from "../../scripts/agent-fs-release-notes";
+
+const currentYaml = 'agentFs:\n  image:\n    tag: "0.18.11"\n';
+const unchangedSection = `## agent-fs
+
+Ships [agent-fs 0.18.11](https://github.com/desplega-ai/agent-fs/releases/tag/v0.18.11).
+
+agent-swarm pins agent-fs via the chart image tag and npm packages \`@desplega.ai/agent-fs\` and \`@desplega.ai/agent-fs-just-bash\`; each agent-fs release needs a \`chore(deps): bump agent-fs pins\` PR here.`;
+
+describe("agent-fs release notes", () => {
+  test("renders the bump when the version changed", () => {
+    expect(renderAgentFsReleaseNotes(currentYaml, 'agentFs:\n  image:\n    tag: "0.18.9"\n')).toBe(
+      unchangedSection.replace(").\n", ") (bumped from 0.18.9).\n"),
+    );
+  });
+
+  test("omits the bump when the version is unchanged", () => {
+    expect(renderAgentFsReleaseNotes(currentYaml, currentYaml)).toBe(unchangedSection);
+  });
+
+  test("omits the bump when there is no previous release tag", () => {
+    expect(renderAgentFsReleaseNotes(currentYaml)).toBe(unchangedSection);
+  });
+
+  test("omits the bump when the previous chart has no agentFs.image.tag", () => {
+    expect(renderAgentFsReleaseNotes(currentYaml, "agentFs:\n  image: {}\n")).toBe(
+      unchangedSection,
+    );
+  });
+
+  test.each([
+    "agentFs:\n  image: {}\n",
+    'agentFs:\n  image:\n    tag: ""\n',
+  ])("fails loudly when the current chart tag is missing or empty: %s", (yaml) => {
+    expect(() => renderAgentFsReleaseNotes(yaml)).toThrow(
+      "Current chart is missing agentFs.image.tag",
+    );
+  });
+});