@desplega.ai/agent-swarm 1.153.0 → 1.154.0

package/dist/{cli-a9scg8sv.js → cli-913yakhv.js}

@@ -1,6 +1,7 @@
 import {
+  resolveSlackUserId,
   rewriteSlackMentions
-} from "./cli-eazstkad.js";
+} from "./cli-r1d3dzt6.js";
 import {
   bufferedFileFailures,
   buildEffectiveText,
@@ -8,8 +9,9 @@ import {
   createSlackTaskWithFiles,
   extractSlackMessageText,
   fetchSlackFiles,
+  findUserByExternalId,
   notifySlackFileFailures
-} from "./cli-qrqhc31j.js";
+} from "./cli-6r3cgpk2.js";
 import {
   buildBufferFlushBlocks,
   ensureSlackThreadTree,
@@ -18,7 +20,7 @@ import {
   getSlackApp,
   isSlackRenderV2Enabled,
   registerTreeMessage
-} from "./cli-n0q9b7j4.js";
+} from "./cli-c1v10xb2.js";
 import {
   createLogEntry,
   getAgentById,
@@ -31,11 +33,11 @@ import {
   init_steering,
   requestSteering,
   slackContextKey
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 import {
   init_steering_enabled,
   isSteeringEnabled
-} from "./cli-z61ykvam.js";
+} from "./cli-wg04s9kr.js";
 import {
   __callDispose,
   __using
@@ -234,11 +236,20 @@ ${combinedText}`;
     if (latestActiveTask) {
       console.log(`[Slack] Dependency chaining: latest active task ${latestActiveTask.id} (status: ${latestActiveTask.status})`);
     }
+    const requestedByUserId = app ? await resolveSlackUserId(app.client, originalRequesterId, {
+      sampleEventType: "buffered_thread_reply",
+      sampleContext: items[0].text
+    }) : (await findUserByExternalId("slack", originalRequesterId))?.id;
+    const nextSenderIndex = items.findIndex((item) => item.userId !== originalRequesterId);
+    const steeringItems = nextSenderIndex === -1 ? items : items.slice(0, nextSenderIndex);
     const steering = files.length === 0 ? await requestSlackThreadSteering({
       channelId,
       threadTs,
-      message: combinedText,
-      messageTimestamps: items.map((item) => item.ts)
+      message: nextSenderIndex === -1 ? combinedText : await rewriteSlackMentions(steeringItems.map((item) => item.text).join(`
+---
+`), botUserId),
+      messageTimestamps: steeringItems.map((item) => item.ts),
+      requestedByUserId
     }) : null;
     if (steering) {
       console.log(`[Slack] Buffer flushed → steering ${steering.result.outcome} for task ${steering.task.id}`);
@@ -259,6 +270,9 @@ ${combinedText}`;
           }
         }
       }
+      if (nextSenderIndex !== -1) {
+        await slackFlush(items.slice(nextSenderIndex), key, immediate);
+      }
       return;
     }
     const lead = await getLeadAgent();
@@ -279,6 +293,7 @@ ${description}` : description;
       slackThreadTs: threadTs,
       slackTriggerMessageTs: items.at(-1).ts,
       slackUserId: originalRequesterId,
+      requestedByUserId,
       dependsOn,
       parentTaskId: mostRecentTask?.id,
       contextKey: slackContextKey({ channelId, threadTs })

package/dist/{cli-pf9q3696.js → cli-927erqqt.js}

@@ -1,3 +1,7 @@
+import {
+  getMemoryRaterNames
+} from "./cli-3bkz2p7j.js";
+
 // src/prompts/memories.ts
 var SIMILARITY_THRESHOLD = 0.4;
 var RATE_TOOL_HINT = `
@@ -26,8 +30,7 @@ ${memoryContext}
   return prompt;
 }
 function isExplicitSelfRaterEnabled() {
-  const ratersEnabled = (process.env.MEMORY_RATERS ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-  return ratersEnabled.includes("explicit-self");
+  return getMemoryRaterNames().includes("explicit-self");
 }
 
 // src/utils/skill-fs-writer.ts

package/dist/{cli-zy5w9gpt.js → cli-95jnpnqg.js}

@@ -12,7 +12,7 @@ import {
 import {
   DEFAULT_MODEL_TIER_MAP,
   init_types
-} from "./cli-zcsyfw2z.js";
+} from "./cli-4k7jazkq.js";
 import {
   init_secret_scrubber,
   registerVolatileSecret,

package/dist/{cli-cdq08v3r.js → cli-abp3g4ax.js}

@@ -4,7 +4,7 @@ import {
   getScriptMcpTypes,
   listAppRecords,
   require_typescript
-} from "./cli-6ks9xf1n.js";
+} from "./cli-pf1v8xhb.js";
 import {
   deleteSwarmConfigByKey,
   getAgentById,
@@ -13,7 +13,7 @@ import {
   getSwarmConfigs,
   init_db,
   upsertSwarmConfig
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 import {
   init_secret_scrubber,
   scrubSecrets
@@ -165,6 +165,7 @@ async function ensureAgentFsCredentialsForAgent(agentId) {
     key: "AGENT_FS_API_KEY"
   }))[0];
   if (existing?.value) {
+    await syncAgentFsDisplayName(apiUrl, existing.value, agent.name);
     return {
       enabled: true,
       created: false,
@@ -209,6 +210,7 @@ async function ensureAgentFsCredentialsForAgent(agentId) {
     isSecret: true,
     description: `agent-fs API key for ${email}`
   });
+  await syncAgentFsDisplayName(apiUrl, apiKey, agent.name);
   return {
     enabled: true,
     created: true,
@@ -218,6 +220,17 @@ async function ensureAgentFsCredentialsForAgent(agentId) {
     driveId: shared.driveId
   };
 }
+async function syncAgentFsDisplayName(apiUrl, apiKey, name) {
+  try {
+    await agentFsRequest(apiUrl, "/auth/profile", {
+      method: "PATCH",
+      headers: { authorization: `Bearer ${apiKey}` },
+      body: { displayName: name }
+    });
+  } catch (error) {
+    console.warn(scrubSecrets(`[agent-fs] display name sync skipped: ${error instanceof AgentFsRequestError ? `HTTP ${error.status}` : "request failed"}`));
+  }
+}
 async function ensureSharedOrg(apiUrl, headers) {
   const configured = await getConfigValue("AGENT_FS_DEFAULT_ORG_ID") || await getConfigValue("AGENT_FS_SHARED_ORG_ID");
   if (configured)

package/dist/{cli-nq0kgyxe.js → cli-acy6bfhr.js}

@@ -5,12 +5,12 @@ import {
   instantFlush,
   requestSlackThreadSteering,
   wasEventSeen
-} from "./cli-a9scg8sv.js";
+} from "./cli-913yakhv.js";
 import {
   enrichSlackUserEmail,
   resolveSlackUserId,
   rewriteSlackMentions
-} from "./cli-eazstkad.js";
+} from "./cli-r1d3dzt6.js";
 import {
   TaskCreationBlockedError,
   broadcastMatches,
@@ -23,14 +23,14 @@ import {
   hasOtherUserMention,
   notifySlackFileFailures,
   routeMessage
-} from "./cli-qrqhc31j.js";
+} from "./cli-6r3cgpk2.js";
 import {
   ackSlackMessage,
   buildTreeBlocks,
   ensureSlackThreadTree,
   isSlackRenderV2Enabled,
   registerTreeMessage
-} from "./cli-n0q9b7j4.js";
+} from "./cli-c1v10xb2.js";
 import {
   getAgentById,
   getAgentWorkingOnThread,
@@ -40,13 +40,14 @@ import {
   getTasksByAgentId,
   init_context_key,
   init_db,
+  isExtensionAgent,
   reactionName,
   slackContextKey
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 import {
   init_resolver,
   resolveTemplate
-} from "./cli-z61ykvam.js";
+} from "./cli-wg04s9kr.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
@@ -370,7 +371,9 @@ function registerMessageHandler(app) {
         const { target } = routeResult.data;
         if (target.kind === "agent") {
           const agent = await getAgentById(target.agentId);
-          if (agent) {
+          if (agent && isExtensionAgent(agent)) {
+            console.warn("[Slack] Extension selected an extension-identity agent. Using the built-in router:", scrubSecrets(target.agentId));
+          } else if (agent) {
             matches = [{ agent, matchedText: "extension" }];
           } else {
             console.warn("[Slack] Extension selected an unknown agent. Using the built-in router:", scrubSecrets(target.agentId));

package/dist/{cli-n0q9b7j4.js → cli-c1v10xb2.js}

@@ -27,6 +27,7 @@ import {
   getInProgressSlackTasks,
   getLogsByTaskIdChronological,
   getPendingSlackRelayTasks,
+  getResolvableDeferralOutcomes,
   getSlackOutcomeMessage,
   getSlackTasksInThread,
   getSlackTasksMissingTree,
@@ -41,6 +42,7 @@ import {
   init_reaction_shortcode,
   isPendingSlackMessage,
   markFinalizedSlackRelaysDelivered,
+  markSlackDeferralResolved,
   markSlackRelayAttempted,
   markSlackRelayDelivered,
   markSlackTreeRendered,
@@ -50,11 +52,11 @@ import {
   setSlackMessageTracking,
   slackContextKey,
   updateSlackMessageRecord
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 import {
   init_types,
   isTerminalTaskStatus
-} from "./cli-zcsyfw2z.js";
+} from "./cli-4k7jazkq.js";
 import {
   getAppUrl,
   init_constants
@@ -52640,7 +52642,7 @@ async function initOtel(serviceRole = process.env.AGENT_ROLE || "api") {
     return;
   initialized = true;
   try {
-    const impl = await import("./otel-impl-srjy4be4.js");
+    const impl = await import("./otel-impl-e0ytens5.js");
     await impl.boot(serviceRole);
     realWithSpan = impl.withSpan;
     realStartSpan = impl.startSpan;
@@ -53039,19 +53041,32 @@ function buildTreeBlocks(roots) {
 init_db();
 
 // src/slack/task-output.ts
+var LEGACY_DEFERRAL_NOTICE = /^Deferred until ([^\n(]+?) \([^\n]*?\) -> .*$/;
 function slackTaskOutput(task) {
   const output = task.output ?? undefined;
   if (task.status !== "completed" || task.outputSchema || !task.tags?.includes("deferred")) {
     return output;
   }
-  const notice = output?.match(/^Deferred until [^\n]+? \([^\n]+?\) -> (.*)$/);
-  if (!notice)
+  const legacy = output?.match(LEGACY_DEFERRAL_NOTICE);
+  if (!legacy)
     return output;
-  const pending = notice[1]?.trim();
-  return pending ? `Pending: ${pending}` : "";
+  const eta = legacy[1]?.trim();
+  return eta ? `Checking back ${eta}` : output;
 }
-function isSlackEtaOnlyNotice(task) {
-  return !!task.output && slackTaskOutput(task) === "";
+function isDeferredTask(task) {
+  if (task.status !== "completed")
+    return false;
+  if (task.deferredAt)
+    return true;
+  return !!task.tags?.includes("deferred") && task.taskType !== "deferred";
+}
+function deferralWakes(task, threadTasks) {
+  return threadTasks.filter((candidate) => candidate.parentTaskId === task.id && candidate.taskType === "deferred");
+}
+function isAwaitingWake(task, threadTasks) {
+  if (!isDeferredTask(task))
+    return false;
+  return !deferralWakes(task, threadTasks).some((wake) => wake.status === "completed" || wake.status === "failed" || wake.status === "cancelled");
 }
 
 // src/slack/responses.ts
@@ -53124,8 +53139,6 @@ async function sendInlineTaskOutput(task) {
   }
 }
 async function sendTaskResponse(task) {
-  if (isSlackEtaOnlyNotice(task))
-    return true;
   const app = getSlackApp();
   if (!app || !task.slackChannelId || !task.slackThreadTs) {
     return false;
@@ -53251,8 +53264,6 @@ async function updateProgressInPlace(task, progress, messageTs) {
   }
 }
 async function updateToFinal(task, messageTs) {
-  if (isSlackEtaOnlyNotice(task))
-    return "ok";
   const app = getSlackApp();
   if (!app || !task.slackChannelId || !task.agentId)
     return "failed";
@@ -53989,15 +54000,15 @@ async function initSlackApp() {
     ...slackApiUrl ? { clientOptions: { slackApiUrl } } : {}
   });
   initialized2 = true;
-  const { registerMessageHandler } = await import("./handlers-2y6dqpvf.js");
-  const { registerCommandHandler } = await import("./commands-355dbpa8.js");
-  const { registerActionHandlers } = await import("./actions-jzrfpkmn.js");
-  const { registerWorkObjectHandlers } = await import("./work-objects-vdsdcczj.js");
+  const { registerMessageHandler } = await import("./handlers-36fm1bwn.js");
+  const { registerCommandHandler } = await import("./commands-1cxwbhhq.js");
+  const { registerActionHandlers } = await import("./actions-kpnwp1kz.js");
+  const { registerWorkObjectHandlers } = await import("./work-objects-2ea3kvwg.js");
   registerMessageHandler(app);
   registerCommandHandler(app);
   registerActionHandlers(app);
   registerWorkObjectHandlers(app);
-  const { createAssistant } = await import("./assistant-hfkxvhgt.js");
+  const { createAssistant } = await import("./assistant-kwq4y50q.js");
   app.assistant(createAssistant());
   return app;
 }
@@ -54006,7 +54017,7 @@ async function startSlackApp() {
     await initSlackApp();
   }
   if (app) {
-    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-f9hzff72.js");
+    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-npm8xdzh.js");
     if (isSlackRenderV2Enabled2())
       await ensureSlackRenderV2Activation();
     await app.start();
@@ -54095,24 +54106,50 @@ async function finalizeSlackSteerReactions(tasks, reactionFor) {
     }
   }
 }
+var MAX_DEFERRAL_CHAIN_HOPS = 10;
+async function triggerMessageTs(task) {
+  let current = task;
+  for (let hop = 0;current && hop <= MAX_DEFERRAL_CHAIN_HOPS; hop++) {
+    if (current.slackTriggerMessageTs)
+      return current.slackTriggerMessageTs;
+    if (current.taskType !== "deferred" || !current.parentTaskId)
+      return;
+    current = await getTaskById(current.parentTaskId);
+  }
+  return;
+}
+function tasksAnsweringTrigger(threadTasks, timestamp) {
+  const linked = threadTasks.filter((task) => task.slackTriggerMessageTs === timestamp);
+  for (let index = 0;index < linked.length; index++) {
+    for (const wake of deferralWakes(linked[index], threadTasks)) {
+      if (!linked.includes(wake))
+        linked.push(wake);
+    }
+  }
+  return linked;
+}
 async function finalizeTerminalSlackReactions(tasks) {
   const app2 = getSlackApp();
   if (!app2)
     return;
   const triggers = new Map;
   for (const task of tasks) {
-    if (!task.slackChannelId || !task.slackThreadTs || !task.slackTriggerMessageTs)
+    if (!task.slackChannelId || !task.slackThreadTs)
+      continue;
+    const timestamp = await triggerMessageTs(task);
+    if (!timestamp)
       continue;
-    const key = `${task.slackChannelId}\x00${task.slackTriggerMessageTs}`;
+    const key = `${task.slackChannelId}\x00${timestamp}`;
     triggers.set(key, {
       channelId: task.slackChannelId,
       threadTs: task.slackThreadTs,
-      timestamp: task.slackTriggerMessageTs
+      timestamp
     });
   }
   for (const { channelId, threadTs, timestamp } of triggers.values()) {
-    const linkedTasks = (await getSlackTasksInThread(channelId, threadTs)).filter((task) => task.slackTriggerMessageTs === timestamp);
-    if (linkedTasks.length === 0 || linkedTasks.some((task) => !isTerminalTaskStatus(task.status))) {
+    const threadTasks = await getSlackTasksInThread(channelId, threadTs);
+    const linkedTasks = tasksAnsweringTrigger(threadTasks, timestamp);
+    if (linkedTasks.length === 0 || linkedTasks.some((task) => !isTerminalTaskStatus(task.status) || isAwaitingWake(task, threadTasks))) {
       continue;
     }
     const event = linkedTasks.every((task) => task.status === "completed") ? "completed" : "failed";
@@ -54275,7 +54312,9 @@ function isStalledMember(task, now) {
   const idleMin = (now.getTime() - new Date(task.lastUpdatedAt).getTime()) / 60000;
   return idleMin >= slackTreeStallMinutes();
 }
-async function taskStateGlyph(task, now) {
+async function taskStateGlyph(task, now, threadTasks = []) {
+  if (isAwaitingWake(task, threadTasks))
+    return "⏳";
   switch (task.status) {
     case "backlog":
     case "unassigned":
@@ -54362,11 +54401,11 @@ function renderProgress(progress) {
   const cut = boundary >= MAX_TREE_PROGRESS_LENGTH / 2 ? boundary : MAX_TREE_PROGRESS_LENGTH;
   return `${normalized.slice(0, cut).trimEnd()}…`;
 }
-async function renderNodeLines(node, depth, now, isAsk) {
+async function renderNodeLines(node, depth, now, isAsk, threadTasks) {
   const duration = formatV2Duration(new Date(node.task.createdAt), terminalEnd(node.task, now));
   const indent = FIGURE_SPACE.repeat(TREE_INDENT.topLevel + Math.max(0, depth - 1) * TREE_INDENT.levelStep);
   const boundedPrefix = indent.length > MAX_TREE_PREFIX_LENGTH ? `${indent.slice(0, MAX_TREE_PREFIX_LENGTH - 1)}…` : indent;
-  let line = `${boundedPrefix}↳ ${await taskStateGlyph(node.task, now)} ${await renderNodeLabel(node, isAsk)} · ${duration} · ${getTaskLink(node.task.id)}`;
+  let line = `${boundedPrefix}↳ ${await taskStateGlyph(node.task, now, threadTasks)} ${await renderNodeLabel(node, isAsk)} · ${duration} · ${getTaskLink(node.task.id)}`;
   const progress = renderProgress(node.task.progress);
   const suffix = isTerminalTreeStatus(node.task.status) ? "" : progress ? ` · ${progress}` : "";
   if (suffix && line.length + suffix.length <= MAX_TREE_NODE_LINE_LENGTH) {
@@ -54377,7 +54416,7 @@ async function renderNodeLines(node, depth, now, isAsk) {
   }
   const lines = [line];
   for (const child of node.children) {
-    lines.push(...await renderNodeLines(child, depth + 1, now, false));
+    lines.push(...await renderNodeLines(child, depth + 1, now, false, threadTasks));
   }
   return lines;
 }
@@ -54397,6 +54436,8 @@ function threadHeaderText(tasks, now, duration) {
     return `\uD83E\uDDF5 ⚠️ stalled — ${duration}`;
   if (tasks.some((task) => !isTerminalTreeStatus(task.status)))
     return `\uD83E\uDDF5 \uD83D\uDD04 working — ${duration}`;
+  if (tasks.some((task) => isAwaitingWake(task, tasks)))
+    return `\uD83E\uDDF5 ⏳ waiting — ${duration}`;
   const hasFailure = tasks.some((task) => task.status === "failed");
   return hasFailure ? `\uD83E\uDDF5 ❌ done with failures — ${duration}` : `\uD83E\uDDF5 ✅ done — ${duration}`;
 }
@@ -54414,7 +54455,7 @@ async function renderThreadTree(tasks, _outcomeLinks = new Map, now = new Date,
   const lines = [threadHeaderText(tasks, now, threadDuration)];
   const roots = buildRenderForest(tasks);
   for (const root of roots) {
-    lines.push(...await renderNodeLines(root, 1, now, root.task.source === "slack"));
+    lines.push(...await renderNodeLines(root, 1, now, root.task.source === "slack", tasks));
   }
   const text = normalizeV2Text(lines.join(`
 `));
@@ -54424,7 +54465,7 @@ async function renderThreadTree(tasks, _outcomeLinks = new Map, now = new Date,
   const recentLines = [];
   for (let index = tasks.length - 1;index >= 0; index--) {
     const task = tasks[index];
-    const recentLine = (await renderNodeLines({ task, children: [] }, 1, now, task.source === "slack"))[0];
+    const recentLine = (await renderNodeLines({ task, children: [] }, 1, now, task.source === "slack", tasks))[0];
     const candidateLines = [recentLine, ...recentLines];
     const omitted2 = index;
     const marker2 = `… _${omitted2} older task${omitted2 === 1 ? "" : "s"} collapsed_`;
@@ -54693,25 +54734,31 @@ function isAskOutcomeStatus(status) {
 function outcomeText(value, fallback) {
   return value?.trim() ? value : fallback;
 }
+var LINE_START_BLOCK = /^(?:`{3}|~{3}|[-*+]\s|\d+[.)]\s|>|#{1,6}\s|\||(?:-{3,}|\*{3,}|_{3,})[ \t]*(?:\r?\n|$)|(?: {4}|\t))/;
+function withStatusLead(lead, body) {
+  const text = body.replace(/^(?:[ \t]*\r?\n)+/, "");
+  if (LINE_START_BLOCK.test(text))
+    return `${lead}
+
+${body}`;
+  return `${lead} ${text.trimStart()}`;
+}
 async function outcomeContent(task, slackReplySent) {
   if (task.status === "failed") {
-    return `❌ **Failed**
-
-${outcomeText(task.failureReason, "Task failed.")}`;
+    return withStatusLead("❌ **Failed:**", outcomeText(task.failureReason, "Task failed."));
   }
   if (task.status === "cancelled") {
-    return `\uD83D\uDEAB **Cancelled**
-
-${outcomeText(task.failureReason, "Task was cancelled.")}`;
+    return withStatusLead("\uD83D\uDEAB **Cancelled:**", outcomeText(task.failureReason, "Task was cancelled."));
   }
-  const isDeferred = task.tags?.includes("deferred");
+  const isDeferred = isDeferredTask(task);
   if (slackReplySent && task.status === "completed" && !isDeferred) {
     const agentName = task.agentId ? (await getAgentById(task.agentId))?.name ?? "Agent" : "Agent";
     return `✅ ${agentName} completed`;
   }
-  return `✅
-
-${outcomeText(slackTaskOutput(task), "Task completed.")}`;
+  if (isDeferred) {
+    return withStatusLead("⏳", outcomeText(slackTaskOutput(task), "Deferred."));
+  }
+  return withStatusLead("✅", outcomeText(slackTaskOutput(task), "Task completed."));
 }
 async function agentDisplayNameFor(task) {
   return task.agentId ? (await getAgentById(task.agentId))?.name ?? "Agent" : "Agent";
@@ -54719,32 +54766,31 @@ async function agentDisplayNameFor(task) {
 async function childOutcomeContent(task, slackReplySent) {
   const agentName = await agentDisplayNameFor(task);
   if (task.status === "failed") {
-    return `↳ ❌ ${agentName} — failed
-
-${outcomeText(task.failureReason, "Task failed.")}`;
+    return withStatusLead(`↳ ❌ ${agentName} — failed:`, outcomeText(task.failureReason, "Task failed."));
   }
-  if (slackReplySent && !task.tags?.includes("deferred")) {
+  if (slackReplySent && !isDeferredTask(task)) {
     return `↳ ✅ ${agentName} completed`;
   }
-  return `↳ ✅ ${agentName} — result
-
-${outcomeText(slackTaskOutput(task), "Task completed.")}`;
+  if (isDeferredTask(task)) {
+    return withStatusLead(`↳ ⏳ ${agentName} — deferred:`, outcomeText(slackTaskOutput(task), "Deferred."));
+  }
+  return withStatusLead(`↳ ✅ ${agentName} — result:`, outcomeText(slackTaskOutput(task), "Task completed."));
 }
 function isSlackContinuation(task) {
   return task.source === "schedule" && task.taskType === "deferred" && !!task.slackChannelId && !!task.slackThreadTs;
 }
 function isChildCardCandidate(task, delegationActivatedAt) {
-  return !isSlackEtaOnlyNotice(task) && task.source !== "slack" && !isSlackContinuation(task) && !!task.slackChannelId && !!task.slackThreadTs && (task.status === "completed" || task.status === "failed") && task.taskType !== "follow-up" && task.taskType !== "reroute-decision" && task.createdAt >= delegationActivatedAt;
+  return task.source !== "slack" && !isSlackContinuation(task) && !!task.slackChannelId && !!task.slackThreadTs && (task.status === "completed" || task.status === "failed") && task.taskType !== "follow-up" && task.taskType !== "reroute-decision" && task.createdAt >= delegationActivatedAt;
 }
 function taskNeedsDirectOutcome(task, activatedAt) {
-  return !isSlackEtaOnlyNotice(task) && (task.source === "slack" && isAskOutcomeStatus(task.status) || isSlackContinuation(task) && isOutcomeStatus(task.status)) && task.createdAt >= activatedAt;
+  return (task.source === "slack" && isAskOutcomeStatus(task.status) || isSlackContinuation(task) && isOutcomeStatus(task.status)) && task.createdAt >= activatedAt;
 }
 async function conclusionResultsLines(closure) {
   const lines = [];
   for (const member of closure) {
     if (member.taskType === "follow-up" || member.taskType === "reroute-decision")
       continue;
-    if (!isOutcomeStatus(member.status) || isSlackEtaOnlyNotice(member))
+    if (!isOutcomeStatus(member.status))
       continue;
     const glyph = await taskStateGlyph(member, new Date);
     const agentName = await agentDisplayNameFor(member);
@@ -55020,6 +55066,62 @@ async function streamOutcomeCard(task, tree, options) {
     conclusionKind: options?.conclusionKind
   });
 }
+async function resolvedDeferralContent(wake) {
+  if (!isDeferredTask(wake)) {
+    const content = await outcomeContent(wake, wake.slackReplySent);
+    return outcomePresentation(wake, content, attachmentLine(await getTaskAttachments(wake.id)));
+  }
+  const card = await getSlackOutcomeMessage(wake.id);
+  const pointer = card?.permalink ? ` — ${card.permalink}` : ".";
+  return `↪️ Resumed by ${await agentDisplayNameFor(wake)} and deferred again${pointer}`;
+}
+async function isAnsweredByDeferralCard(task, threadTasks) {
+  if (!isSlackContinuation(task) || !task.parentTaskId || isDeferredTask(task))
+    return false;
+  const deferred = threadTasks.find((candidate) => candidate.id === task.parentTaskId);
+  if (!deferred?.deferredAt)
+    return false;
+  const card = await getSlackOutcomeMessage(deferred.id);
+  return !!card?.finalizedAt && !isPendingSlackMessage(card) && !card.deferralAbandonedAt;
+}
+function isTerminalSlackError(error) {
+  const code = error.data?.error;
+  return typeof code === "string" && code.length > 0 && code !== "ratelimited";
+}
+var DEFERRAL_REFRESH_MAX_ATTEMPTS = 5;
+var deferralRefreshAttempts = new Map;
+async function refreshResolvedDeferralCards() {
+  const app2 = getSlackApp();
+  if (!app2)
+    return;
+  for (const { card, wakeTaskId } of await getResolvableDeferralOutcomes()) {
+    try {
+      const wake = await getTaskById(wakeTaskId);
+      if (!wake)
+        continue;
+      const content = await resolvedDeferralContent(wake);
+      await callSlackWithRetry(app2.client, "chat.update", {
+        channel: card.channelId,
+        ts: card.ts,
+        text: content
+      });
+      await markSlackDeferralResolved(card.id);
+      deferralRefreshAttempts.delete(card.id);
+      await finalizeTerminalSlackReactions([wake]);
+    } catch (error) {
+      const attempts = (deferralRefreshAttempts.get(card.id) ?? 0) + 1;
+      deferralRefreshAttempts.set(card.id, attempts);
+      const terminal = isTerminalSlackError(error);
+      if (terminal || attempts >= DEFERRAL_REFRESH_MAX_ATTEMPTS) {
+        await markSlackDeferralResolved(card.id, { abandoned: true });
+        deferralRefreshAttempts.delete(card.id);
+        console.error(`[Slack] Giving up on deferral card ${card.id} after ${attempts} attempt(s)` + `${terminal ? " (Slack refused the rewrite)" : ""}:`, error);
+        continue;
+      }
+      console.error(`[Slack] Failed to resolve deferral card ${card.id} ` + `(attempt ${attempts}/${DEFERRAL_REFRESH_MAX_ATTEMPTS}):`, error);
+    }
+  }
+}
 async function processSlackRenderV2() {
   if (!isSlackRenderV2Enabled())
     return;
@@ -55075,7 +55177,7 @@ async function processSlackRenderV2() {
     for (const task of tasks) {
       if ((await getSlackOutcomeMessage(task.id))?.finalizedAt)
         continue;
-      const isDirectCandidate = taskNeedsDirectOutcome(task, activatedAt) && isOutcomeStatus(task.status);
+      const isDirectCandidate = taskNeedsDirectOutcome(task, activatedAt) && isOutcomeStatus(task.status) && !await isAnsweredByDeferralCard(task, tasks);
       const isChildCandidate = delegationEnabled && delegationActivatedAt !== null && isChildCardCandidate(task, delegationActivatedAt) && !task.slackReplySent;
       if (isDirectCandidate || isChildCandidate) {
         needsOutcome = true;
@@ -55174,6 +55276,8 @@ async function processSlackRenderV2() {
         continue;
       if ((await getSlackOutcomeMessage(task.id))?.finalizedAt)
         continue;
+      if (await isAnsweredByDeferralCard(task, tasks))
+        continue;
       const deferByClosure = task.source === "slack" && delegationEnabled && delegationActivatedAt !== null && task.createdAt >= delegationActivatedAt;
       if (!deferByClosure) {
         if (!outcomeDeliveryGate(task.id))
@@ -55236,6 +55340,7 @@ async function processSlackRenderV2() {
       console.error(`[Slack] Failed to update v2 tree ${tree.id}:`, error);
     }
   }
+  await refreshResolvedDeferralCards();
 }
 function _resetSlackRenderV2ForTests() {
   for (const timer of pendingTreeUpdates.values())
@@ -55249,4 +55354,4 @@ function _resetSlackRenderV2ForTests() {
   outcomeDeliveryFailures.clear();
 }
 
-export { initialize, ensure, isPollTracingEnabled, initOtel, withSpan, startSpan, withSpanContext, withRemoteContext, injectTraceContext, recordSessionCost, recordDbRetentionSweep, recordDbRetentionStatement, require_dist7 as require_dist, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, slackTaskOutput, getAgentDisplayName, getAgentEmoji, isSlackRenderV2Enabled, isSlackDelegationEnabled, callSlackWithRetry, formatV2Duration, renderThreadTree, ensureSlackThreadTree, childOutcomeContent, streamOutcomeCard, processSlackRenderV2, _resetSlackRenderV2ForTests, registerTreeMessage, getSlackApp, initSlackApp, startSlackApp, stopSlackApp };
+export { initialize, ensure, isPollTracingEnabled, initOtel, withSpan, startSpan, withSpanContext, withRemoteContext, injectTraceContext, recordSessionCost, recordDbRetentionSweep, recordDbRetentionStatement, require_dist7 as require_dist, slackTaskOutput, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, getAgentDisplayName, getAgentEmoji, isSlackRenderV2Enabled, isSlackDelegationEnabled, callSlackWithRetry, formatV2Duration, renderThreadTree, ensureSlackThreadTree, withStatusLead, childOutcomeContent, streamOutcomeCard, refreshResolvedDeferralCards, processSlackRenderV2, _resetSlackRenderV2ForTests, registerTreeMessage, getSlackApp, initSlackApp, startSlackApp, stopSlackApp };

package/dist/{cli-tdh4hjr2.js → cli-e0pg4zeh.js}

@@ -1,7 +1,7 @@
 import {
   getDb,
   init_db
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 
 // src/be/seed-pricing.ts
 init_db();

package/dist/{cli-83wkg402.js → cli-e31ehqwy.js}

@@ -5,7 +5,7 @@ import {
   getDb,
   getDbClient,
   init_db
-} from "./cli-djvxhnc4.js";
+} from "./cli-ge67p080.js";
 import {
   init_env_flag,
   isEnvFlagEnabled