@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/cli-pf9q3696.js

@@ -0,0 +1,172 @@
+// src/prompts/memories.ts
+var SIMILARITY_THRESHOLD = 0.4;
+var RATE_TOOL_HINT = `
+
+When a memory above genuinely helps you solve this task — or actively
+misleads you — call \`memory_rate\` with the memory id and useful=true/false.
+This trains the swarm to surface better memories next time. Use sparingly:
+2-5 ratings per task is plenty.`;
+function renderMemoriesPrompt(memories) {
+  const useful = memories.filter((m) => m.similarity > SIMILARITY_THRESHOLD);
+  if (useful.length === 0)
+    return null;
+  const memoryContext = useful.map((m) => `- **${m.name}** (id: ${m.id}): ${m.content.substring(0, 300)}`).join(`
+`);
+  let prompt = `
+
+### Relevant Past Knowledge
+
+These memories from your previous sessions may be useful. Use \`memory-get\` with the memory ID to retrieve full details.
+
+${memoryContext}
+`;
+  if (isExplicitSelfRaterEnabled()) {
+    prompt += RATE_TOOL_HINT;
+  }
+  return prompt;
+}
+function isExplicitSelfRaterEnabled() {
+  const ratersEnabled = (process.env.MEMORY_RATERS ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  return ratersEnabled.includes("explicit-self");
+}
+
+// src/utils/skill-fs-writer.ts
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var SWARM_MARKER_FILE = ".swarm-managed";
+function reconcileManagedSkillFiles(skillDir, currentRelativeFiles) {
+  if (!existsSync(join(skillDir, SWARM_MARKER_FILE)))
+    return 0;
+  let removed = 0;
+  const walk = (dir, relativeDir = "") => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    let hasEntries = false;
+    for (const entry of entries) {
+      const relativePath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const childHasEntries = walk(fullPath, relativePath);
+        if (!childHasEntries) {
+          try {
+            rmSync(fullPath, { recursive: true, force: true });
+          } catch {
+            hasEntries = true;
+          }
+        } else {
+          hasEntries = true;
+        }
+        continue;
+      }
+      if (relativePath === "SKILL.md" || relativePath === SWARM_MARKER_FILE || currentRelativeFiles.has(relativePath)) {
+        hasEntries = true;
+        continue;
+      }
+      try {
+        rmSync(fullPath, { force: true });
+        removed++;
+      } catch {
+        hasEntries = true;
+      }
+    }
+    return hasEntries;
+  };
+  walk(skillDir);
+  return removed;
+}
+function writeSkillsToFilesystem(entries, harnessType = "all", home) {
+  const errors = [];
+  let synced = 0;
+  let removed = 0;
+  const skillDirs = [];
+  if (harnessType === "claude" || harnessType === "all") {
+    skillDirs.push(join(home, ".claude", "skills"));
+  }
+  if (harnessType === "pi" || harnessType === "all") {
+    skillDirs.push(join(home, ".pi", "agent", "skills"));
+  }
+  if (harnessType === "codex" || harnessType === "all") {
+    skillDirs.push(join(home, ".codex", "skills"));
+  }
+  if (harnessType === "opencode" || harnessType === "all") {
+    skillDirs.push(join(home, ".opencode", "skills"));
+  }
+  if (harnessType === "agents" || harnessType === "all") {
+    skillDirs.push(join(home, ".agents", "skills"));
+  }
+  for (const dir of skillDirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const writtenNames = new Set;
+  for (const skill of entries) {
+    if (!skill.isActive || !skill.isEnabled)
+      continue;
+    if (skill.isComplex && skill.files.length === 0)
+      continue;
+    if (!skill.content)
+      continue;
+    const safeName = skill.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!safeName)
+      continue;
+    writtenNames.add(safeName);
+    const currentBundledFilePaths = new Set(skill.files.filter((file) => !file.isBinary).map((file) => file.path));
+    for (const baseDir of skillDirs) {
+      const skillDir = join(baseDir, safeName);
+      const skillFile = join(skillDir, "SKILL.md");
+      const markerFile = join(skillDir, SWARM_MARKER_FILE);
+      try {
+        mkdirSync(skillDir, { recursive: true });
+        removed += reconcileManagedSkillFiles(skillDir, currentBundledFilePaths);
+        writeFileSync(skillFile, skill.content, "utf-8");
+        writeFileSync(markerFile, "", "utf-8");
+        synced++;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        errors.push(`${skill.name} -> ${skillDir}: ${msg}`);
+        console.error(`[skill-fs-writer] Failed to write SKILL.md for ${skill.name} to ${skillDir}: ${msg}`);
+      }
+      for (const file of skill.files) {
+        if (file.isBinary) {
+          console.log(`[skill-fs-writer] Skipping binary skill file ${skill.name}/${file.path}`);
+          continue;
+        }
+        const targetPath = join(skillDir, file.path);
+        try {
+          mkdirSync(dirname(targetPath), { recursive: true });
+          writeFileSync(targetPath, file.content, "utf-8");
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : "Unknown error";
+          errors.push(`${skill.name}/${file.path} -> ${targetPath}: ${msg}`);
+          console.error(`[skill-fs-writer] Failed to write bundled file ${skill.name}/${file.path} to ${targetPath}: ${msg}`);
+        }
+      }
+    }
+  }
+  for (const baseDir of skillDirs) {
+    if (!existsSync(baseDir))
+      continue;
+    try {
+      const existing = readdirSync(baseDir, { withFileTypes: true });
+      for (const entry of existing) {
+        if (!entry.isDirectory())
+          continue;
+        if (writtenNames.has(entry.name))
+          continue;
+        const skillDir = join(baseDir, entry.name);
+        if (!existsSync(join(skillDir, SWARM_MARKER_FILE)))
+          continue;
+        try {
+          rmSync(skillDir, { recursive: true, force: true });
+          removed++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { synced, removed, errors };
+}
+
+export { SIMILARITY_THRESHOLD, renderMemoriesPrompt, writeSkillsToFilesystem };

package/dist/{cli-xm87hzbw.js → cli-pgj4a5fb.js}

@@ -2,7 +2,7 @@ import {
   init_resolver,
   init_session_templates,
   resolveTemplateAsync
-} from "./cli-3apbzgyk.js";
+} from "./cli-z61ykvam.js";
 
 // src/prompts/steering-delivery.ts
 init_session_templates();

package/dist/{cli-jezx9b9c.js → cli-ppm4975n.js}

@@ -1,7 +1,7 @@
 import {
   contentSha256,
   init_profile_sync
-} from "./cli-zvz62chv.js";
+} from "./cli-fm4ytsdk.js";
 import {
   OpenAI,
   init_openai
@@ -11,7 +11,7 @@ import {
   getDbClient,
   init_db,
   isSqliteVecAvailable
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   __esm,
   __export,
@@ -93,6 +93,9 @@ class OpenAIEmbeddingProvider {
     this.dimensions = config?.dimensions ?? EMBEDDING_DIMENSIONS;
     this.name = config?.model ? `openai/${config.model}` : process.env.EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL;
   }
+  isConfigured() {
+    return !!this.apiKey;
+  }
   getClient() {
     if (!this.apiKey)
       return null;
@@ -1082,6 +1085,9 @@ function getEmbeddingProvider() {
   }
   return embeddingProvider;
 }
+function resetEmbeddingProvider() {
+  embeddingProvider = null;
+}
 function getMemoryStore() {
   if (!memoryStore) {
     const { SqliteMemoryStore: SqliteMemoryStore2 } = (init_sqlite_store(), __toCommonJS(exports_sqlite_store));
@@ -1090,4 +1096,4 @@ function getMemoryStore() {
   return memoryStore;
 }
 
-export { cosineSimilarity, serializeEmbedding, deserializeEmbedding, init_embedding, CANDIDATE_SET_MULTIPLIER, isGraphExpansionEnabled, EMBEDDING_DIMENSIONS, init_constants, computeScore, rerank, init_reranker, rowToCandidate, init_sqlite_store, getEmbeddingProvider, getMemoryStore };
+export { CANDIDATE_SET_MULTIPLIER, isGraphExpansionEnabled, EMBEDDING_DIMENSIONS, init_constants, cosineSimilarity, serializeEmbedding, deserializeEmbedding, init_embedding, computeScore, rerank, init_reranker, rowToCandidate, init_sqlite_store, getEmbeddingProvider, resetEmbeddingProvider, getMemoryStore };

package/dist/{cli-3z634pqe.js → cli-q88st9aj.js}

@@ -4,11 +4,11 @@ import {
   getEmbeddingProvider,
   init_embedding,
   serializeEmbedding
-} from "./cli-jezx9b9c.js";
+} from "./cli-ppm4975n.js";
 import {
   getDbClient,
   init_db
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   init_secret_scrubber,
   scrubSecrets

package/dist/{cli-3sysyjve.js → cli-r2q6pevn.js}

@@ -1,14 +1,14 @@
 import {
   require_follow_redirects
 } from "./cli-q51yprfq.js";
-import {
-  init_task_attachment_links,
-  taskAttachmentDisplayUrl
-} from "./cli-9d8ntetj.js";
 import {
   require_jws,
   require_p_retry
 } from "./cli-yatxqynm.js";
+import {
+  init_task_attachment_links,
+  taskAttachmentDisplayUrl
+} from "./cli-2658f6at.js";
 import {
   SLACK_REACTION_CONFIG_KEYS,
   SLACK_REACTION_DEFAULTS,
@@ -49,11 +49,11 @@ import {
   setSlackMessageTracking,
   slackContextKey,
   updateSlackMessageRecord
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   getAppUrl,
   init_constants
-} from "./cli-e29gmdmw.js";
+} from "./cli-dv6cdjs2.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
@@ -54475,7 +54475,7 @@ async function initOtel(serviceRole = process.env.AGENT_ROLE || "api") {
     return;
   initialized = true;
   try {
-    const impl = await import("./otel-impl-b93gxnz5.js");
+    const impl = await import("./otel-impl-943c96er.js");
     await impl.boot(serviceRole);
     realWithSpan = impl.withSpan;
     realStartSpan = impl.startSpan;
@@ -54845,9 +54845,9 @@ function collectAttachmentNodes(roots) {
 function buildTreeBlocks(roots) {
   console.log(`[Slack] Building tree blocks for ${roots.length} root(s): ${roots.map((r) => r.taskId.slice(0, 8)).join(", ")}`);
   const treeTexts = roots.map(renderTree);
-  const blocks = [sectionBlock(treeTexts.join(`
+  const blocks = treeTexts.length > 0 ? [sectionBlock(treeTexts.join(`
 
-`))];
+`))] : [];
   const attachmentNodes = collectAttachmentNodes(roots);
   const visibleAttachmentNodes = attachmentNodes.slice(0, SLACK_TREE_ATTACHMENT_BLOCKS_MAX);
   for (const node of visibleAttachmentNodes) {
@@ -55793,13 +55793,15 @@ async function initSlackApp() {
     logLevel: import_bolt.LogLevel.DEBUG,
     ...slackApiUrl ? { clientOptions: { slackApiUrl } } : {}
   });
-  const { registerMessageHandler } = await import("./handlers-nsg0bcye.js");
-  const { registerCommandHandler } = await import("./commands-n755g391.js");
-  const { registerActionHandlers } = await import("./actions-9d2694yk.js");
+  const { registerMessageHandler } = await import("./handlers-tw90pkh5.js");
+  const { registerCommandHandler } = await import("./commands-9v4psyq1.js");
+  const { registerActionHandlers } = await import("./actions-2bgpyhww.js");
+  const { registerWorkObjectHandlers } = await import("./work-objects-wangt792.js");
   registerMessageHandler(app);
   registerCommandHandler(app);
   registerActionHandlers(app);
-  const { createAssistant } = await import("./assistant-edb6n9nn.js");
+  registerWorkObjectHandlers(app);
+  const { createAssistant } = await import("./assistant-bavke5p7.js");
   app.assistant(createAssistant());
   return app;
 }
@@ -55808,7 +55810,7 @@ async function startSlackApp() {
     await initSlackApp();
   }
   if (app) {
-    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-hyd45w8b.js");
+    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-8zjntgf5.js");
     if (isSlackRenderV2Enabled2())
       await ensureSlackRenderV2Activation();
     await app.start();
@@ -55982,7 +55984,7 @@ var lastTreeText = new Map;
 var lastTreeUpdateAt = new Map;
 var cachedTeamId;
 function isSlackRenderV2Enabled() {
-  return isEnvFlagEnabled("SLACK_RENDER_V2", false);
+  return isEnvFlagEnabled("SLACK_RENDER_V2", true);
 }
 function isSlackDelegationEnabled() {
   return isEnvFlagEnabled("SLACK_RENDER_V2_DELEGATION", false);
@@ -56011,6 +56013,61 @@ async function callSlackWithRetry(client, method, payload) {
     }
   }
 }
+var OUTCOME_DELIVERY_MAX_ATTEMPTS = 5;
+var OUTCOME_DELIVERY_BASE_DELAY_MS = 30000;
+var OUTCOME_DELIVERY_MAX_DELAY_MS = 30 * 60000;
+var outcomeDeliveryFailures = new Map;
+function outcomeDeliveryGate(taskId) {
+  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) {
+  outcomeDeliveryFailures.delete(taskId);
+}
+async function noteOutcomeDeliveryFailure(task, error) {
+  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);
+  }
+}
+async function surfaceOutcomeDeliveryGiveUp(task, error) {
+  const app2 = getSlackApp();
+  if (!app2 || !task.slackChannelId || !task.slackThreadTs)
+    return;
+  try {
+    await app2.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(app2.client, task.slackChannelId, task.slackThreadTs);
+}
+async function clearAssistantStatus(client, channelId, threadTs) {
+  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() {
   return Number(process.env.SLACK_TREE_STALL_MIN) || 15;
 }
@@ -56449,7 +56506,8 @@ ${outcomeText(task.failureReason, "Task failed.")}`;
 
 ${outcomeText(task.failureReason, "Task was cancelled.")}`;
   }
-  if (slackReplySent && task.status === "completed") {
+  const isDeferred = task.tags?.includes("deferred");
+  if (slackReplySent && task.status === "completed" && !isDeferred) {
     const agentName = task.agentId ? (await getAgentById(task.agentId))?.name ?? "Agent" : "Agent";
     return `✅ ${agentName} completed`;
   }
@@ -56467,18 +56525,21 @@ async function childOutcomeContent(task, slackReplySent) {
 
 ${outcomeText(task.failureReason, "Task failed.")}`;
   }
-  if (slackReplySent) {
+  if (slackReplySent && !task.tags?.includes("deferred")) {
     return `↳ ✅ ${agentName} completed`;
   }
   return `↳ ✅ ${agentName} — result
 
 ${outcomeText(task.output, "Task completed.")}`;
 }
+function isSlackContinuation(task) {
+  return task.source === "schedule" && task.taskType === "deferred" && !!task.slackChannelId && !!task.slackThreadTs;
+}
 function isChildCardCandidate(task, delegationActivatedAt) {
-  return task.source !== "slack" && !!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 taskNeedsAskOutcome(task, activatedAt) {
-  return task.source === "slack" && isAskOutcomeStatus(task.status) && task.createdAt >= activatedAt;
+function taskNeedsDirectOutcome(task, activatedAt) {
+  return (task.source === "slack" && isAskOutcomeStatus(task.status) || isSlackContinuation(task) && isOutcomeStatus(task.status)) && task.createdAt >= activatedAt;
 }
 async function conclusionResultsLines(closure) {
   const lines = [];
@@ -56564,7 +56625,11 @@ function attachmentLine(attachments) {
   if (!attachment)
     return;
   const url = taskAttachmentDisplayUrl(attachment);
-  return /^https?:\/\//.test(url) ? `\uD83D\uDCCE [${attachment.name}](${url})` : undefined;
+  if (!/^https?:\/\//.test(url))
+    return;
+  const label = attachment.name.replace(/\s+/g, " ").trim().replace(/[\\[\]()]/g, "\\$&");
+  const destination = url.replace(/[\s\\<>]/g, encodeURIComponent).replace(/\(/g, "%28").replace(/\)/g, "%29");
+  return `\uD83D\uDCCE [${label}](${destination})`;
 }
 function fenceAt(line) {
   const match = line.match(/^[ \t]{0,3}(`{3,}|~{3,})/);
@@ -56700,10 +56765,26 @@ async function streamOutcomeCard(task, tree, options) {
     reservationWasCreated = reserved.created;
   }
   let streamedFreshContent = false;
+  let deliveredViaFallback = false;
   if (isPendingSlackMessage(outcome)) {
     const reconciled = reservationWasCreated ? undefined : await findReservedSlackMessage(app2.client, outcome, presentation);
     streamedFreshContent = !reconciled;
-    const started = reconciled ?? await callSlackWithRetry(app2.client, "chat.startStream", startPayload);
+    let started = reconciled;
+    if (!started) {
+      try {
+        started = await callSlackWithRetry(app2.client, "chat.startStream", startPayload);
+      } catch (error) {
+        console.error(`[Slack] chat.startStream failed for task ${task.id}; falling back to chat.postMessage:`, error);
+        started = await callSlackWithRetry(app2.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");
     }
@@ -56714,23 +56795,26 @@ async function streamOutcomeCard(task, tree, options) {
       throw new Error("Failed to persist the outcome stream timestamp");
     outcome = persisted;
   }
-  if (!streamedFreshContent) {
-    await callSlackWithRetry(app2.client, "chat.update", {
-      channel: task.slackChannelId,
-      ts: outcome.ts,
-      text: presentation
-    });
-  }
-  try {
-    await callSlackWithRetry(app2.client, "chat.stopStream", {
-      channel: task.slackChannelId,
-      ts: outcome.ts,
-      blocks: await outcomeFooter(task, tasks, duration)
-    });
-  } catch (error) {
-    if (!isStreamAlreadyStopped(error))
-      throw error;
+  if (!deliveredViaFallback) {
+    if (!streamedFreshContent) {
+      await callSlackWithRetry(app2.client, "chat.update", {
+        channel: task.slackChannelId,
+        ts: outcome.ts,
+        text: presentation
+      });
+    }
+    try {
+      await callSlackWithRetry(app2.client, "chat.stopStream", {
+        channel: task.slackChannelId,
+        ts: outcome.ts,
+        blocks: await outcomeFooter(task, tasks, duration)
+      });
+    } catch (error) {
+      if (!isStreamAlreadyStopped(error))
+        throw error;
+    }
   }
+  await clearAssistantStatus(app2.client, task.slackChannelId, task.slackThreadTs);
   const permalink = await resolvePermalink(app2.client, task.slackChannelId, outcome.ts);
   return await updateSlackMessageRecord(outcome.id, {
     permalink,
@@ -56793,9 +56877,9 @@ async function processSlackRenderV2() {
     for (const task of tasks) {
       if ((await getSlackOutcomeMessage(task.id))?.finalizedAt)
         continue;
-      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;
       }
@@ -56869,9 +56953,12 @@ async function processSlackRenderV2() {
         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);
@@ -56879,27 +56966,29 @@ async function processSlackRenderV2() {
         }
         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")
+      if (!taskNeedsDirectOutcome(task, activatedAt))
         continue;
       if ((await getSlackOutcomeMessage(task.id))?.finalizedAt)
         continue;
-      if (!isAskOutcomeStatus(task.status) || task.createdAt < activatedAt)
-        continue;
-      const deferByClosure = delegationEnabled && delegationActivatedAt !== null && task.createdAt >= delegationActivatedAt;
+      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)
+          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;
       }
@@ -56921,12 +57010,15 @@ async function processSlackRenderV2() {
       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) => askConclusionContent(task, closure, state, slackReplySent),
           conclusionKind: state === "timedOut" ? "timeout" : "complete"
         });
         if (outcome) {
+          noteOutcomeDeliverySuccess(task.id);
           const app3 = getSlackApp();
           if (app3 && task.slackChannelId && task.slackTriggerMessageTs) {
             const reaction = conclusionReactionChoice(state, task, closure);
@@ -56937,7 +57029,7 @@ async function processSlackRenderV2() {
         }
         outcomeCreated ||= !!outcome;
       } catch (error) {
-        console.error(`[Slack] Failed to stream ask conclusion for task ${task.id}:`, error);
+        await noteOutcomeDeliveryFailure(task, error);
       }
     }
     try {
@@ -56956,6 +57048,7 @@ function _resetSlackRenderV2ForTests() {
   lastTreeUpdateAt.clear();
   treeUpdateTails.clear();
   cachedTeamId = undefined;
+  outcomeDeliveryFailures.clear();
 }
 
-export { initialize, ensure, require_dist7 as require_dist, isPollTracingEnabled, initOtel, withSpan, startSpan, withSpanContext, withRemoteContext, injectTraceContext, recordSessionCost, recordDbRetentionSweep, recordDbRetentionStatement, ackSlackMessage, getTaskLink, markdownToSlack, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, 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, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, getAgentDisplayName, getAgentEmoji, isSlackRenderV2Enabled, isSlackDelegationEnabled, callSlackWithRetry, formatV2Duration, renderThreadTree, ensureSlackThreadTree, childOutcomeContent, streamOutcomeCard, processSlackRenderV2, _resetSlackRenderV2ForTests, registerTreeMessage, getSlackApp, initSlackApp, startSlackApp, stopSlackApp };

package/dist/{cli-07jd68a1.js → cli-re8z5p8p.js}

@@ -6,7 +6,7 @@ import {
 // src/utils/multi-runtime.ts
 init_env_flag();
 function isMultiRuntimeEnabled(env = process.env) {
-  return parseEnvFlag(env.MULTI_RUNTIME_ENABLED, false);
+  return parseEnvFlag(env.MULTI_RUNTIME_ENABLED, true);
 }
 function swarmRuntimeInstanceId(env = process.env) {
   return env.SWARM_RUNTIME_INSTANCE_ID || undefined;