@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/slack/render-v2.ts

@@ -77,7 +77,7 @@ type SlackThreadMessage = {
 };
 
 export function isSlackRenderV2Enabled(): boolean {
-  return isEnvFlagEnabled("SLACK_RENDER_V2", false);
+  return isEnvFlagEnabled("SLACK_RENDER_V2", true);
 }
 
 export function isSlackDelegationEnabled(): boolean {
@@ -121,6 +121,88 @@ export async function callSlackWithRetry(
   }
 }
 
+// Outcome delivery (chat.startStream, with its chat.postMessage fallback) can
+// fail for reasons callSlackWithRetry does not retry (e.g. user_not_found).
+// Without a bound, processSlackRenderV2's 3s tick re-attempts the same
+// failing task forever. This tracks per-task failures in memory and applies
+// capped exponential backoff plus a give-up ceiling so a persistently broken
+// recipient stops hammering Slack instead of retrying at tick cadence.
+const OUTCOME_DELIVERY_MAX_ATTEMPTS = 5;
+const OUTCOME_DELIVERY_BASE_DELAY_MS = 30_000;
+const OUTCOME_DELIVERY_MAX_DELAY_MS = 30 * 60_000;
+const outcomeDeliveryFailures = new Map<string, { count: number; nextAttemptAt: number }>();
+
+function outcomeDeliveryGate(taskId: string): boolean {
+  const state = outcomeDeliveryFailures.get(taskId);
+  if (!state) return true;
+  if (state.count >= OUTCOME_DELIVERY_MAX_ATTEMPTS) return false;
+  return Date.now() >= state.nextAttemptAt;
+}
+
+function noteOutcomeDeliverySuccess(taskId: string): void {
+  outcomeDeliveryFailures.delete(taskId);
+}
+
+async function noteOutcomeDeliveryFailure(task: AgentTask, error: unknown): Promise<void> {
+  const state = outcomeDeliveryFailures.get(task.id) ?? { count: 0, nextAttemptAt: 0 };
+  state.count += 1;
+  const delay = Math.min(
+    OUTCOME_DELIVERY_BASE_DELAY_MS * 2 ** (state.count - 1),
+    OUTCOME_DELIVERY_MAX_DELAY_MS,
+  );
+  state.nextAttemptAt = Date.now() + delay;
+  outcomeDeliveryFailures.set(task.id, state);
+  console.error(
+    `[Slack] Outcome delivery failed for task ${task.id} (attempt ${state.count}/${OUTCOME_DELIVERY_MAX_ATTEMPTS}):`,
+    error,
+  );
+  if (state.count >= OUTCOME_DELIVERY_MAX_ATTEMPTS) {
+    console.error(
+      `[Slack] Giving up on outcome delivery for task ${task.id} after ${state.count} attempts; surfacing failure and clearing the working indicator`,
+    );
+    await surfaceOutcomeDeliveryGiveUp(task, error);
+  }
+}
+
+/** Best-effort: post a visible failure notice and clear the "is working" status so a
+ * permanently broken delivery doesn't fail silently or leave the thread spinning. */
+async function surfaceOutcomeDeliveryGiveUp(task: AgentTask, error: unknown): Promise<void> {
+  const app = getSlackApp();
+  if (!app || !task.slackChannelId || !task.slackThreadTs) return;
+  try {
+    await app.client.apiCall("chat.postMessage", {
+      channel: task.slackChannelId,
+      thread_ts: task.slackThreadTs,
+      text: `⚠️ Couldn't deliver this task's reply after ${OUTCOME_DELIVERY_MAX_ATTEMPTS} attempts (${
+        error instanceof Error ? error.message : String(error)
+      }). See task ${getTaskLink(task.id)} for the result.`,
+    });
+  } catch (postError) {
+    console.error(`[Slack] Give-up notice failed to post for task ${task.id}:`, postError);
+  }
+  await clearAssistantStatus(app.client, task.slackChannelId, task.slackThreadTs);
+}
+
+/** Clears the assistant "is working" indicator in DM channels. Best-effort: the
+ * call throws when the thread isn't an assistant thread, which is expected
+ * for non-DM channels and safe to ignore. */
+async function clearAssistantStatus(
+  client: WebClient,
+  channelId: string,
+  threadTs: string,
+): Promise<void> {
+  if (!channelId.startsWith("D")) return;
+  try {
+    await client.apiCall("assistant.threads.setStatus", {
+      channel_id: channelId,
+      thread_ts: threadTs,
+      status: "",
+    });
+  } catch (error) {
+    console.warn(`[Slack] Failed to clear assistant status for ${channelId}/${threadTs}:`, error);
+  }
+}
+
 function slackTreeStallMinutes(): number {
   return Number(process.env.SLACK_TREE_STALL_MIN) || 15;
 }
@@ -665,7 +747,11 @@ async function outcomeContent(task: AgentTask, slackReplySent: boolean): Promise
   if (task.status === "cancelled") {
     return `🚫 **Cancelled**\n\n${outcomeText(task.failureReason, "Task was cancelled.")}`;
   }
-  if (slackReplySent && task.status === "completed") {
+  // A deferral's output is engine-authored, never posted by hand via
+  // slack-reply, so it must not collapse into the "agent completed" summary
+  // even when the agent also sent a slack-reply earlier in the same task.
+  const isDeferred = task.tags?.includes("deferred");
+  if (slackReplySent && task.status === "completed" && !isDeferred) {
     const agentName = task.agentId
       ? ((await getAgentById(task.agentId))?.name ?? "Agent")
       : "Agent";
@@ -697,12 +783,23 @@ export async function childOutcomeContent(
   if (task.status === "failed") {
     return `↳ ❌ ${agentName} — failed\n\n${outcomeText(task.failureReason, "Task failed.")}`;
   }
-  if (slackReplySent) {
+  if (slackReplySent && !task.tags?.includes("deferred")) {
     return `↳ ✅ ${agentName} completed`;
   }
   return `↳ ✅ ${agentName} — result\n\n${outcomeText(task.output, "Task completed.")}`;
 }
 
+// A deferred wake continues a human conversation even though the scheduler
+// assigns source="schedule". Its answer must not depend on delegation cards.
+function isSlackContinuation(task: AgentTask): boolean {
+  return (
+    task.source === "schedule" &&
+    task.taskType === "deferred" &&
+    !!task.slackChannelId &&
+    !!task.slackThreadTs
+  );
+}
+
 /**
  * True when `task` is a candidate for its own child result card (plan
  * section 3.4, rules 1-4, 3, and part of rule 6). Callers still need the
@@ -712,6 +809,7 @@ export async function childOutcomeContent(
 function isChildCardCandidate(task: AgentTask, delegationActivatedAt: string): boolean {
   return (
     task.source !== "slack" &&
+    !isSlackContinuation(task) &&
     !!task.slackChannelId &&
     !!task.slackThreadTs &&
     (task.status === "completed" || task.status === "failed") &&
@@ -721,9 +819,11 @@ function isChildCardCandidate(task: AgentTask, delegationActivatedAt: string): b
   );
 }
 
-function taskNeedsAskOutcome(task: AgentTask, activatedAt: string): boolean {
+function taskNeedsDirectOutcome(task: AgentTask, activatedAt: string): boolean {
   return (
-    task.source === "slack" && isAskOutcomeStatus(task.status) && task.createdAt >= activatedAt
+    ((task.source === "slack" && isAskOutcomeStatus(task.status)) ||
+      (isSlackContinuation(task) && isOutcomeStatus(task.status))) &&
+    task.createdAt >= activatedAt
   );
 }
 
@@ -847,7 +947,17 @@ function attachmentLine(attachments: TaskAttachment[]): string | undefined {
   const attachment = attachments.find((item) => item.isPrimary) ?? attachments[0];
   if (!attachment) return undefined;
   const url = taskAttachmentDisplayUrl(attachment);
-  return /^https?:\/\//.test(url) ? `📎 [${attachment.name}](${url})` : undefined;
+  if (!/^https?:\/\//.test(url)) return undefined;
+  const label = attachment.name
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/[\\[\]()]/g, "\\$&");
+  // Keep the Markdown destination intact without changing existing URL escapes.
+  const destination = url
+    .replace(/[\s\\<>]/g, encodeURIComponent)
+    .replace(/\(/g, "%28")
+    .replace(/\)/g, "%29");
+  return `📎 [${label}](${destination})`;
 }
 
 type MarkdownFence = { character: "`" | "~"; length: number };
@@ -1019,13 +1129,36 @@ export async function streamOutcomeCard(
     reservationWasCreated = reserved.created;
   }
   let streamedFreshContent = false;
+  let deliveredViaFallback = false;
   if (isPendingSlackMessage(outcome)) {
     const reconciled = reservationWasCreated
       ? undefined
       : await findReservedSlackMessage(app.client, outcome, presentation);
     streamedFreshContent = !reconciled;
-    const started =
-      reconciled ?? (await callSlackWithRetry(app.client, "chat.startStream", startPayload));
+    let started = reconciled;
+    if (!started) {
+      try {
+        started = await callSlackWithRetry(app.client, "chat.startStream", startPayload);
+      } catch (error) {
+        // chat.startStream can fail for reasons callSlackWithRetry does not
+        // retry (e.g. user_not_found). Without a fallback the agent's answer
+        // — already computed above — is dropped entirely. Fall back to a
+        // plain chat.postMessage so a streaming-API error never swallows a
+        // reply.
+        console.error(
+          `[Slack] chat.startStream failed for task ${task.id}; falling back to chat.postMessage:`,
+          error,
+        );
+        started = await callSlackWithRetry(app.client, "chat.postMessage", {
+          channel: task.slackChannelId,
+          thread_ts: task.slackThreadTs,
+          text: presentation,
+          ...(startPayload.username ? { username: startPayload.username } : {}),
+          ...(startPayload.icon_emoji ? { icon_emoji: startPayload.icon_emoji } : {}),
+        });
+        deliveredViaFallback = true;
+      }
+    }
     if (typeof started.ts !== "string" || !started.ts) {
       throw new Error("Slack did not return a timestamp for the outcome stream");
     }
@@ -1035,29 +1168,36 @@ export async function streamOutcomeCard(
     if (!persisted) throw new Error("Failed to persist the outcome stream timestamp");
     outcome = persisted;
   }
-  if (!streamedFreshContent) {
-    // The stream backing this message was started (or reconciled from) an earlier
-    // pass, whose slackReplySent snapshot may have since changed. Overwrite its
-    // content with the freshly computed presentation before finalizing, so a
-    // completed-then-collapsed reply doesn't finalize with stale full output.
-    await callSlackWithRetry(app.client, "chat.update", {
-      channel: task.slackChannelId,
-      ts: outcome.ts,
-      text: presentation,
-    });
-  }
-  try {
-    await callSlackWithRetry(app.client, "chat.stopStream", {
-      channel: task.slackChannelId,
-      ts: outcome.ts,
-      blocks: await outcomeFooter(task, tasks, duration),
-    });
-  } catch (error) {
-    // A process may have stopped the stream before it persisted the final
-    // permalink. In that one recovery case the message is already immutable,
-    // so continue by resolving and recording its permalink.
-    if (!isStreamAlreadyStopped(error)) throw error;
+  if (!deliveredViaFallback) {
+    if (!streamedFreshContent) {
+      // The stream backing this message was started (or reconciled from) an earlier
+      // pass, whose slackReplySent snapshot may have since changed. Overwrite its
+      // content with the freshly computed presentation before finalizing, so a
+      // completed-then-collapsed reply doesn't finalize with stale full output.
+      await callSlackWithRetry(app.client, "chat.update", {
+        channel: task.slackChannelId,
+        ts: outcome.ts,
+        text: presentation,
+      });
+    }
+    try {
+      await callSlackWithRetry(app.client, "chat.stopStream", {
+        channel: task.slackChannelId,
+        ts: outcome.ts,
+        blocks: await outcomeFooter(task, tasks, duration),
+      });
+    } catch (error) {
+      // A process may have stopped the stream before it persisted the final
+      // permalink. In that one recovery case the message is already immutable,
+      // so continue by resolving and recording its permalink.
+      if (!isStreamAlreadyStopped(error)) throw error;
+    }
   }
+  // chat.startStream/chat.postMessage posting a new message in the thread is
+  // what normally clears Slack's own "is working…" assistant indicator.
+  // Clear it explicitly too, so a delivery that only ever fails still
+  // doesn't leave the thread stuck spinning.
+  await clearAssistantStatus(app.client, task.slackChannelId, task.slackThreadTs);
   const permalink = await resolvePermalink(app.client, task.slackChannelId, outcome.ts);
   return await updateSlackMessageRecord(outcome.id, {
     permalink,
@@ -1123,13 +1263,14 @@ export async function processSlackRenderV2(): Promise<void> {
       // In-progress asks are eligible only for the timeout backstop. They do
       // not represent immediately active outcome work, so avoid waking an old
       // tree solely to verify its permalink on every render tick.
-      const isAskCandidate = taskNeedsAskOutcome(task, activatedAt) && isOutcomeStatus(task.status);
+      const isDirectCandidate =
+        taskNeedsDirectOutcome(task, activatedAt) && isOutcomeStatus(task.status);
       const isChildCandidate =
         delegationEnabled &&
         delegationActivatedAt !== null &&
         isChildCardCandidate(task, delegationActivatedAt) &&
         !task.slackReplySent;
-      if (isAskCandidate || isChildCandidate) {
+      if (isDirectCandidate || isChildCandidate) {
         needsOutcome = true;
         break;
       }
@@ -1199,36 +1340,42 @@ export async function processSlackRenderV2(): Promise<void> {
       if (!ownerAsk || ownerAsk.createdAt < delegationActivatedAt) continue;
       if (childCardsThisTick >= CHILD_CARDS_PER_TICK) continue;
       if (askId && (await childCardCountFor(askId)) >= CHILD_CARDS_PER_ASK) continue;
+      if (!outcomeDeliveryGate(task.id)) continue;
       try {
         const outcome = await streamOutcomeCard(task, tree, { buildContent: childOutcomeContent });
         if (outcome) {
+          noteOutcomeDeliverySuccess(task.id);
           childCardsThisTick++;
           if (askId) childCardCounts.set(askId, (childCardCounts.get(askId) ?? 0) + 1);
           await recordSlackDelivery(task, outcome, "child_outcome");
         }
         outcomeCreated ||= !!outcome;
       } catch (error) {
-        console.error(`[Slack] Failed to stream child outcome for task ${task.id}:`, error);
+        await noteOutcomeDeliveryFailure(task, error);
       }
     }
 
     for (const task of tasks) {
       if (!isSlackRenderV2Enabled()) return;
-      if (task.source !== "slack") continue;
+      if (!taskNeedsDirectOutcome(task, activatedAt)) continue;
       if ((await getSlackOutcomeMessage(task.id))?.finalizedAt) continue;
-      if (!isAskOutcomeStatus(task.status) || task.createdAt < activatedAt) continue;
       const deferByClosure =
+        task.source === "slack" &&
         delegationEnabled &&
         delegationActivatedAt !== null &&
         task.createdAt >= delegationActivatedAt;
 
       if (!deferByClosure) {
+        if (!outcomeDeliveryGate(task.id)) continue;
         try {
           const outcome = await streamOutcomeCard(task, tree);
-          if (outcome) await finalizeTerminalSlackReactions([task]);
+          if (outcome) {
+            noteOutcomeDeliverySuccess(task.id);
+            await finalizeTerminalSlackReactions([task]);
+          }
           outcomeCreated ||= !!outcome;
         } catch (error) {
-          console.error(`[Slack] Failed to stream outcome for task ${task.id}:`, error);
+          await noteOutcomeDeliveryFailure(task, error);
         }
         continue;
       }
@@ -1253,6 +1400,7 @@ export async function processSlackRenderV2(): Promise<void> {
       if (childCardPending) continue;
       const state = closureState(task, closure, new Date(), settleSec, timeoutMin);
       if (state === "open") continue;
+      if (!outcomeDeliveryGate(task.id)) continue;
       try {
         const outcome = await streamOutcomeCard(task, tree, {
           buildContent: (_t, slackReplySent) =>
@@ -1260,6 +1408,7 @@ export async function processSlackRenderV2(): Promise<void> {
           conclusionKind: state === "timedOut" ? "timeout" : "complete",
         });
         if (outcome) {
+          noteOutcomeDeliverySuccess(task.id);
           const app = getSlackApp();
           if (app && task.slackChannelId && task.slackTriggerMessageTs) {
             const reaction = conclusionReactionChoice(state, task, closure);
@@ -1280,7 +1429,7 @@ export async function processSlackRenderV2(): Promise<void> {
         }
         outcomeCreated ||= !!outcome;
       } catch (error) {
-        console.error(`[Slack] Failed to stream ask conclusion for task ${task.id}:`, error);
+        await noteOutcomeDeliveryFailure(task, error);
       }
     }
     try {
@@ -1299,4 +1448,5 @@ export function _resetSlackRenderV2ForTests(): void {
   lastTreeUpdateAt.clear();
   treeUpdateTails.clear();
   cachedTeamId = undefined;
+  outcomeDeliveryFailures.clear();
 }

package/src/slack/router.ts

@@ -1,4 +1,5 @@
 import { getAgentById, getAgentWorkingOnThread, getAllAgents } from "../be/db";
+import type { Agent } from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import type { AgentMatch } from "./types";
 
@@ -16,6 +17,15 @@ export function hasOtherUserMention(text: string, botUserId: string): boolean {
   return mentions.some((m) => m !== `<@${botUserId}>`);
 }
 
+/**
+ * Build the matches for an explicit swarm#all broadcast.
+ */
+export function broadcastMatches(agents: Agent[]): AgentMatch[] {
+  return agents
+    .filter((agent) => !agent.isLead)
+    .map((agent) => ({ agent, matchedText: "swarm#all" }));
+}
+
 /**
  * Routes a Slack message to the appropriate agent(s) based on mentions.
  *
@@ -50,10 +60,10 @@ export async function routeMessage(
 
   // Check for swarm#all broadcast
   if (/swarm#all/i.test(text)) {
-    const nonLeadAgents = agents.filter((a) => !a.isLead);
-    for (const agent of nonLeadAgents) {
+    for (const broadcastMatch of broadcastMatches(agents)) {
+      const agent = broadcastMatch.agent;
       if (!matches.some((m) => m.agent.id === agent.id)) {
-        matches.push({ agent, matchedText: "swarm#all" });
+        matches.push(broadcastMatch);
       }
     }
   }

package/src/slack/steering.ts

@@ -20,7 +20,7 @@ async function configuredSteeringTarget(
   channelId: string,
   threadTs: string,
 ): Promise<AgentTask | null> {
-  switch (process.env.SLACK_THREAD_STEERING) {
+  switch (process.env.SLACK_THREAD_STEERING ?? "lead") {
     case "lead":
       return getLatestLeadTaskInThread(channelId, threadTs);
     case "all":
@@ -32,8 +32,8 @@ async function configuredSteeringTarget(
 
 /**
  * Request steering for the configured Slack thread target, if it is currently
- * in progress. The default and invalid configuration values deliberately
- * return null so Slack preserves its existing task-creation behavior.
+ * in progress. Unset configuration targets the lead; explicit off or invalid
+ * values return null so Slack preserves its task-creation behavior.
  */
 export async function requestSlackThreadSteering(
   args: SlackThreadSteeringRequest,

package/src/slack/thread-buffer.ts

@@ -6,10 +6,17 @@ import {
 } from "../be/db";
 import { createAdditiveBuffer } from "../tasks/additive-buffer";
 import { slackContextKey } from "../tasks/context-key";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
 import { rewriteSlackMentions } from "./enrich";
+import type { SlackFile } from "./files";
+import {
+  bufferedFileFailures,
+  buildEffectiveText,
+  createSlackTaskWithFiles,
+  fetchSlackFiles,
+  notifySlackFileFailures,
+} from "./inbound-files";
 import { extractSlackMessageText } from "./message-text";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
 import { getAgentDisplayName, getAgentEmoji } from "./responses";
@@ -22,6 +29,7 @@ interface BufferedMessage {
   ts: string;
   channelId: string;
   threadTs: string;
+  files?: SlackFile[];
 }
 
 const BUFFER_TIMEOUT_MS = Number(process.env.ADDITIVE_SLACK_BUFFER_MS) || 10_000;
@@ -53,6 +61,7 @@ export function bufferThreadMessage(
   text: string,
   userId: string,
   ts: string,
+  files?: SlackFile[],
 ): void {
   slackBuffer.enqueue(makeKey(channelId, threadTs), {
     text,
@@ -60,6 +69,7 @@ export function bufferThreadMessage(
     ts,
     channelId,
     threadTs,
+    files,
   });
 }
 
@@ -146,10 +156,33 @@ async function slackFlush(
 
   console.log(`[Slack] Flushing buffer: ${key} (${items.length} messages, immediate=${immediate})`);
 
+  // Keep only metadata during the debounce; downloads live for this flush only.
+  const app = getSlackApp();
+  const files = items.flatMap((item) => item.files ?? []);
+  await using inbound = app
+    ? await fetchSlackFiles(app.client, files)
+    : {
+        files,
+        fetched: [],
+        failed: bufferedFileFailures(files),
+        async [Symbol.asyncDispose]() {},
+      };
+  const resolvedFiles = new Map(inbound.files.map((file) => [file.id, file]));
+
   // Build combined task description. Any in-body `<@U…>` mentions the
   // requester typed are rewritten via the identity primitive so the agent
   // sees a name or the explicit UNKNOWN sentinel — never a raw Slack ID.
-  const combinedText = await rewriteSlackMentions(items.map((m) => m.text).join("\n---\n"));
+  const combinedText = await rewriteSlackMentions(
+    items
+      .map((item) =>
+        buildEffectiveText(
+          item.text,
+          item.files?.map((file) => resolvedFiles.get(file.id) ?? file),
+          inbound.failed,
+        ),
+      )
+      .join("\n---\n"),
+  );
   const description = `[Thread follow-up — ${items.length} message(s) buffered]\n\n${combinedText}`;
 
   // Find the latest active task in this thread for dependency chaining
@@ -160,18 +193,22 @@ async function slackFlush(
     );
   }
 
-  const steering = await requestSlackThreadSteering({
-    channelId,
-    threadTs,
-    message: combinedText,
-    messageTimestamps: items.map((item) => item.ts),
-  });
+  // Steering carries text only. As on the mention path, files need a follow-up
+  // task so its attachments exist before a worker can claim it.
+  const steering =
+    files.length === 0
+      ? await requestSlackThreadSteering({
+          channelId,
+          threadTs,
+          message: combinedText,
+          messageTimestamps: items.map((item) => item.ts),
+        })
+      : null;
   if (steering) {
     console.log(
       `[Slack] Buffer flushed → steering ${steering.result.outcome} for task ${steering.task.id}`,
     );
 
-    const app = getSlackApp();
     const agent = steering.task.agentId ? await getAgentById(steering.task.agentId) : undefined;
     if (app) {
       if (!isSlackRenderV2Enabled()) {
@@ -207,19 +244,26 @@ async function slackFlush(
   const dependsOn = !immediate && latestActiveTask ? [latestActiveTask.id] : undefined;
 
   const mostRecentTask = await getMostRecentTaskInThread(channelId, threadTs);
-  const task = await createTaskWithSiblingAwareness(fullDescription, {
-    agentId: lead?.id,
-    routingReason:
-      lead && mostRecentTask?.agentId === lead.id ? "continuity" : lead ? "skill" : undefined,
-    source: "slack",
-    slackChannelId: channelId,
-    slackThreadTs: threadTs,
-    slackTriggerMessageTs: items.at(-1)!.ts,
-    slackUserId: originalRequesterId,
-    dependsOn,
-    parentTaskId: mostRecentTask?.id,
-    contextKey: slackContextKey({ channelId, threadTs }),
-  });
+  const { task, unattached } = await createSlackTaskWithFiles(
+    fullDescription,
+    {
+      agentId: lead?.id,
+      routingReason:
+        lead && mostRecentTask?.agentId === lead.id ? "continuity" : lead ? "skill" : undefined,
+      routingSource: lead ? "engine_default" : undefined,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      slackTriggerMessageTs: items.at(-1)!.ts,
+      slackUserId: originalRequesterId,
+      dependsOn,
+      parentTaskId: mostRecentTask?.id,
+      contextKey: slackContextKey({ channelId, threadTs }),
+    },
+    inbound,
+  );
+
+  if (app) await notifySlackFileFailures(app.client, channelId, threadTs, unattached);
 
   console.log(
     `[Slack] Buffer flushed → task ${task.id} (dependsOn: ${dependsOn ? dependsOn.join(", ") : "none"})`,
@@ -231,7 +275,6 @@ async function slackFlush(
   }
 
   // Slack feedback with Block Kit
-  const app = getSlackApp();
   if (app) {
     const hasDependency = !immediate && !!latestActiveTask;
     const blocks = buildBufferFlushBlocks({