@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/dist/{cli-6skz3rk8.js → cli-7tgcstn2.js}

@@ -1,13 +1,18 @@
 import {
   PermissionVerbSchema
-} from "./cli-cmp8g3sw.js";
+} from "./cli-gbfwcd3k.js";
 import {
   getDb,
   getDbClient,
   init_db
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
+import {
+  init_env_flag,
+  isEnvFlagEnabled
+} from "./cli-ej6gbxfb.js";
 
 // src/be/rbac-roles.ts
+init_env_flag();
 init_db();
 var DEFAULT_ROLE_ID = "rbac-role-admin";
 var BUILTIN_ROLES = [
@@ -217,8 +222,8 @@ function ensureRbacSeedsSynced(opts) {
 function describeRbacFlag() {
   const raw = process.env.RBAC_ENABLED;
   if (raw === undefined)
-    return "unset (off)";
-  return `${raw} (${raw === "true" ? "on" : "off"})`;
+    return "unset (on)";
+  return `${raw} (${isEnvFlagEnabled("RBAC_ENABLED", true) ? "on" : "off"})`;
 }
 function printRolesTable(rows) {
   const tableRows = rows.map((row) => [

package/dist/{cli-01g3x1ca.js → cli-9004vfdf.js}

@@ -5,20 +5,20 @@ import {
   createPoolStarvationDecisionTask,
   createRerouteDecisionTask,
   createResumeFollowUp,
+  dispatchPre,
   expireStaleRuntimeInstances,
+  extensionIdForAgent,
+  getExecutorRegistry,
   getNextResumeGeneration,
   getPinCandidateAgent,
   getResumeGeneration,
+  recoverIncompleteRuns,
   repointTrackerSyncBySwarmId,
   resolveLeadOnlyRecoveryAssignment
-} from "./cli-y3pq4v9g.js";
+} from "./cli-5tpgq60f.js";
 import {
   isMultiRuntimeEnabled
-} from "./cli-07jd68a1.js";
-import {
-  getExecutorRegistry,
-  recoverIncompleteRuns
-} from "./cli-ddfw1mc4.js";
+} from "./cli-re8z5p8p.js";
 import {
   MAX_EMPTY_POLLS,
   assignUnassignedTaskPending,
@@ -61,13 +61,13 @@ import {
   releaseStaleReviewingTasks,
   supersedeTask,
   updateAgentStatus
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   init_registry,
   init_resolver,
   registerTemplate,
   resolveTemplate
-} from "./cli-3apbzgyk.js";
+} from "./cli-z61ykvam.js";
 import {
   init_secret_scrubber,
   scrubSecrets
@@ -206,6 +206,7 @@ function maxResumeGenerations() {
   return Number(process.env.HEARTBEAT_MAX_RESUME_GENERATIONS) || 3;
 }
 var RESUME_BUDGET_EXHAUSTED_REASON = "resume_budget_exhausted";
+var REMEDIATION_ACTIONS = new Set(["supersede-resume", "fail", "record"]);
 var HEARTBEAT_RESUME_PIN_GRACE_MIN = (() => {
   const raw = process.env.HEARTBEAT_RESUME_PIN_GRACE_MIN;
   if (raw === undefined)
@@ -244,6 +245,7 @@ async function preflightGate() {
 async function codeLevelTriage() {
   const findings = {
     stalledTasks: [],
+    extensionSkipped: [],
     autoFailedTasks: [],
     autoResumedTasks: [],
     pinnedResumes: [],
@@ -283,85 +285,128 @@ async function detectAndRemediateStalledTasks(findings) {
     if (newestPendingSteeringAt > 0 && pendingSteeringAgeMs < STEERING_STALL_GRACE_MIN * 60 * 1000) {
       continue;
     }
+    let classification;
+    let remediationOpts;
+    let proposed;
     if (!session) {
       if (taskAgeMs >= stallThresholdNoSessionMin() * 60 * 1000) {
-        await remediateCrashedWorkerTask(findings, task, {
+        classification = "no-session";
+        remediationOpts = {
           supersedeReason: "Auto-superseded by heartbeat: worker session not found (no active session for task)",
           legacyFailReason: "Auto-failed by heartbeat: worker session not found (no active session for task)",
           shortLabel: "no active session"
-        });
+        };
+        proposed = await defaultRemediationDecision(task, remediationOpts);
       }
     } else {
       const isStaleHeartbeat = sessionHeartbeatAgeMs >= stallThresholdStaleHeartbeatMin() * 60 * 1000;
       if (isStaleHeartbeat) {
         if (taskAgeMs >= stallThresholdStaleHeartbeatMin() * 60 * 1000) {
-          await remediateCrashedWorkerTask(findings, task, {
+          classification = "stale-session";
+          remediationOpts = {
             supersedeReason: "Auto-superseded by heartbeat: worker session heartbeat is stale (likely crashed)",
             legacyFailReason: "Auto-failed by heartbeat: worker session heartbeat is stale (likely crashed)",
             shortLabel: "stale session heartbeat",
             cleanupActiveSession: true
-          });
+          };
+          proposed = await defaultRemediationDecision(task, remediationOpts);
         }
       } else {
         if (taskAgeMs >= stallThresholdMinutes() * 60 * 1000) {
-          findings.stalledTasks.push(task);
+          classification = "fresh-stalled";
+          remediationOpts = {
+            supersedeReason: "Auto-superseded by heartbeat: task stalled despite a fresh session heartbeat",
+            legacyFailReason: "Auto-failed by heartbeat: task stalled despite a fresh session heartbeat",
+            shortLabel: "fresh session heartbeat"
+          };
+          proposed = {
+            action: "record",
+            reason: "Task stalled despite a fresh session heartbeat"
+          };
         }
       }
     }
+    if (!classification || !remediationOpts || !proposed)
+      continue;
+    const dispatched = await dispatchPre("pre.heartbeat.remediate", {
+      task,
+      ...session ? { session } : {},
+      classification,
+      proposedAction: proposed.action,
+      reason: proposed.reason,
+      taskAgeMs,
+      ...sessionHeartbeatAgeMs === null ? {} : { sessionHeartbeatAgeMs }
+    }, { skipExtensionId: extensionIdForAgent(task.creatorAgentId) });
+    if (dispatched.action === "block") {
+      findings.stalledTasks.push(task);
+      findings.extensionSkipped.push({
+        taskId: task.id,
+        extension: dispatched.extension,
+        reason: dispatched.reason
+      });
+      continue;
+    }
+    if (dispatched.action === "modify") {
+      const action = dispatched.data.proposedAction;
+      if (isRemediationAction(action)) {
+        proposed = { ...proposed, action };
+      } else {
+        console.warn("[Heartbeat] Extension returned an invalid remediation action:", scrubSecrets(String(action)));
+      }
+    }
+    if (proposed.action === "record") {
+      findings.stalledTasks.push(task);
+      continue;
+    }
+    await remediateCrashedWorkerTask(findings, task, remediationOpts, proposed);
   }
 }
-async function remediateCrashedWorkerTask(findings, task, opts) {
-  if (!task.agentId)
-    return;
+function isRemediationAction(value) {
+  return typeof value === "string" && REMEDIATION_ACTIONS.has(value);
+}
+function decideRemediation(task, facts) {
+  if (task.workflowRunStepId != null) {
+    return { action: "fail", reason: "superseded_workflow_task" };
+  }
+  if (facts.skipAutoResume || facts.alreadyResumed) {
+    return { action: "fail", reason: facts.legacyFailReason };
+  }
+  if (facts.resumeBudgetExhausted) {
+    return { action: "fail", reason: RESUME_BUDGET_EXHAUSTED_REASON };
+  }
+  return { action: "supersede-resume", reason: facts.supersedeReason };
+}
+async function defaultRemediationDecision(task, opts) {
   const skipAutoResume = SKIP_AUTO_RESUME_TYPES.has(task.taskType ?? "");
   const isWorkflowStep = task.workflowRunStepId != null;
   const alreadyResumed = !skipAutoResume && !isWorkflowStep && await hasNonTerminalResumeChild(task.id);
-  if (isWorkflowStep) {
-    const failed = await failTask(task.id, "superseded_workflow_task");
-    if (failed) {
-      findings.autoFailedTasks.push({
-        taskId: task.id,
-        agentId: task.agentId,
-        reason: "superseded_workflow_task"
-      });
-      if (opts.cleanupActiveSession)
-        await deleteActiveSession(task.id);
-      console.log(`[Heartbeat] Workflow-step task ${task.id.slice(0, 8)} failed — engine will handle retry (${opts.shortLabel})`);
-      const remaining2 = await getActiveTaskCount(task.agentId);
-      if (remaining2 === 0)
-        await restoreAgentIdleAfterRemediation(task.agentId);
-    }
-    return;
-  }
-  if (skipAutoResume || alreadyResumed) {
-    const failed = await failTask(task.id, opts.legacyFailReason);
-    if (failed) {
-      findings.autoFailedTasks.push({
-        taskId: task.id,
-        agentId: task.agentId,
-        reason: opts.legacyFailReason
-      });
-      if (opts.cleanupActiveSession)
-        await deleteActiveSession(task.id);
-      console.log(`[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — ${opts.shortLabel} (${skipAutoResume ? "skipRetry taskType" : "resume already exists"})`);
-      const remaining2 = await getActiveTaskCount(task.agentId);
-      if (remaining2 === 0)
-        await restoreAgentIdleAfterRemediation(task.agentId);
-    }
+  const resumeBudgetExhausted = getNextResumeGeneration(task) > maxResumeGenerations();
+  return decideRemediation(task, {
+    skipAutoResume,
+    alreadyResumed,
+    resumeBudgetExhausted,
+    supersedeReason: opts.supersedeReason,
+    legacyFailReason: opts.legacyFailReason
+  });
+}
+async function remediateCrashedWorkerTask(findings, task, opts, decision) {
+  if (!task.agentId)
     return;
-  }
-  const nextResumeGeneration = getNextResumeGeneration(task);
-  if (nextResumeGeneration > maxResumeGenerations()) {
-    const failed = await failTask(task.id, RESUME_BUDGET_EXHAUSTED_REASON);
+  if (decision.action === "fail") {
+    const failed = await failTask(task.id, decision.reason);
     if (failed) {
       findings.autoFailedTasks.push({
         taskId: task.id,
         agentId: task.agentId,
-        reason: RESUME_BUDGET_EXHAUSTED_REASON
+        reason: decision.reason
       });
       if (opts.cleanupActiveSession)
         await deleteActiveSession(task.id);
-      console.warn(`[Heartbeat] Auto-failed task ${task.id.slice(0, 8)} — ${RESUME_BUDGET_EXHAUSTED_REASON} (${opts.shortLabel})`);
+      const message = `[Heartbeat] Auto-failed task ${task.id.slice(0, 8)}: ${decision.reason} (${opts.shortLabel})`;
+      if (decision.reason === RESUME_BUDGET_EXHAUSTED_REASON)
+        console.warn(message);
+      else
+        console.log(message);
       const remaining2 = await getActiveTaskCount(task.agentId);
       if (remaining2 === 0)
         await restoreAgentIdleAfterRemediation(task.agentId);
@@ -370,7 +415,7 @@ async function remediateCrashedWorkerTask(findings, task, opts) {
   }
   await beforeHeartbeatSupersedeForTests?.(task);
   const superseded = await supersedeTask(task.id, {
-    reason: opts.supersedeReason,
+    reason: decision.reason,
     resumeTaskId: null
   });
   if (!superseded) {
@@ -388,7 +433,7 @@ async function remediateCrashedWorkerTask(findings, task, opts) {
       taskId: task.id,
       resumeTaskId: resume.task.id,
       agentId: task.agentId,
-      reason: opts.supersedeReason
+      reason: decision.reason
     });
     if (resume.task.agentId === task.agentId) {
       findings.pinnedResumes.push({ taskId: resume.task.id, agentId: task.agentId });
@@ -520,6 +565,7 @@ async function runRebootSweep() {
             parentTaskId: task.id,
             agentId: preferredAgentId,
             routingReason: preferredAgentId === undefined ? undefined : preferredAgentId === task.agentId ? "continuity" : "reroute_fault",
+            routingSource: preferredAgentId === undefined ? undefined : "engine_default",
             tags,
             priority: task.priority,
             source: task.source,
@@ -893,6 +939,7 @@ async function checkHeartbeatChecklist() {
   await createTaskExtended(result.text, {
     agentId: lead.id,
     routingReason: "skill",
+    routingSource: "engine_default",
     taskType: "heartbeat-checklist",
     tags: ["checklist", "auto-generated"],
     priority: 60
@@ -908,6 +955,7 @@ async function runHeartbeatSweep() {
     if (!await preflightGate()) {
       const cleanupOnlyFindings = {
         stalledTasks: [],
+        extensionSkipped: [],
         autoFailedTasks: [],
         autoResumedTasks: [],
         pinnedResumes: [],
@@ -954,6 +1002,9 @@ function logFindings(findings) {
   if (findings.stalledTasks.length > 0) {
     parts.push(`stalled=${findings.stalledTasks.length}`);
   }
+  if (findings.extensionSkipped.length > 0) {
+    parts.push(`extension_skipped=${findings.extensionSkipped.length}`);
+  }
   if (findings.workerHealthFixes.length > 0) {
     parts.push(`health_fixes=${findings.workerHealthFixes.length}`);
   }
@@ -1028,6 +1079,7 @@ async function createBootTriageTask() {
   await createTaskExtended(result.text, {
     agentId: lead.id,
     routingReason: "skill",
+    routingSource: "engine_default",
     taskType: "boot-triage",
     tags: ["boot", "triage", "auto-generated"],
     priority: 70

package/dist/{cli-1c94wvcw.js → cli-a1z3h107.js}

@@ -1,13 +1,15 @@
-import {
-  createAdditiveBuffer,
-  extractSlackMessageText
-} from "./cli-sdzq01t9.js";
 import {
   rewriteSlackMentions
-} from "./cli-9br8ypfv.js";
+} from "./cli-czjtgfys.js";
 import {
-  createTaskWithSiblingAwareness
-} from "./cli-ayvy5kde.js";
+  bufferedFileFailures,
+  buildEffectiveText,
+  createAdditiveBuffer,
+  createSlackTaskWithFiles,
+  extractSlackMessageText,
+  fetchSlackFiles,
+  notifySlackFileFailures
+} from "./cli-5tpgq60f.js";
 import {
   buildBufferFlushBlocks,
   ensureSlackThreadTree,
@@ -16,7 +18,7 @@ import {
   getSlackApp,
   isSlackRenderV2Enabled,
   registerTreeMessage
-} from "./cli-3sysyjve.js";
+} from "./cli-r2q6pevn.js";
 import {
   createLogEntry,
   getAgentById,
@@ -29,11 +31,15 @@ import {
   init_steering,
   requestSteering,
   slackContextKey
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 import {
   init_steering_enabled,
   isSteeringEnabled
-} from "./cli-3apbzgyk.js";
+} from "./cli-z61ykvam.js";
+import {
+  __callDispose,
+  __using
+} from "./cli-bc05qbss.js";
 
 // src/slack/event-dedup.ts
 var DEFAULT_TTL_MS = 300000;
@@ -83,7 +89,7 @@ init_db();
 init_steering();
 init_steering_enabled();
 async function configuredSteeringTarget(channelId, threadTs) {
-  switch (process.env.SLACK_THREAD_STEERING) {
+  switch (process.env.SLACK_THREAD_STEERING ?? "lead") {
     case "lead":
       return getLatestLeadTaskInThread(channelId, threadTs);
     case "all":
@@ -148,13 +154,14 @@ var slackBuffer = createAdditiveBuffer({
     await slackFlush(items, key, reason === "manual");
   }
 });
-function bufferThreadMessage(channelId, threadTs, text, userId, ts) {
+function bufferThreadMessage(channelId, threadTs, text, userId, ts, files) {
   slackBuffer.enqueue(makeKey(channelId, threadTs), {
     text,
     userId,
     ts,
     channelId,
-    threadTs
+    threadTs,
+    files
   });
 }
 function getBufferMessageCount(key) {
@@ -194,106 +201,124 @@ async function getThreadContextForBuffer(channelId, threadTs) {
   }
 }
 async function slackFlush(items, key, immediate) {
-  if (items.length === 0)
-    return;
-  const split = splitKey(key);
-  if (!split) {
-    console.warn(`[Slack] Buffer flush: malformed key ${key}`);
-    return;
-  }
-  const { channelId, threadTs } = split;
-  const originalRequesterId = items[0].userId;
-  console.log(`[Slack] Flushing buffer: ${key} (${items.length} messages, immediate=${immediate})`);
-  const combinedText = await rewriteSlackMentions(items.map((m) => m.text).join(`
+  let __stack = [];
+  try {
+    if (items.length === 0)
+      return;
+    const split = splitKey(key);
+    if (!split) {
+      console.warn(`[Slack] Buffer flush: malformed key ${key}`);
+      return;
+    }
+    const { channelId, threadTs } = split;
+    const originalRequesterId = items[0].userId;
+    console.log(`[Slack] Flushing buffer: ${key} (${items.length} messages, immediate=${immediate})`);
+    const app = getSlackApp();
+    const files = items.flatMap((item) => item.files ?? []);
+    const inbound = __using(__stack, app ? await fetchSlackFiles(app.client, files) : {
+      files,
+      fetched: [],
+      failed: bufferedFileFailures(files),
+      async[Symbol.asyncDispose]() {}
+    }, 1);
+    const resolvedFiles = new Map(inbound.files.map((file) => [file.id, file]));
+    const combinedText = await rewriteSlackMentions(items.map((item) => buildEffectiveText(item.text, item.files?.map((file) => resolvedFiles.get(file.id) ?? file), inbound.failed)).join(`
 ---
 `));
-  const description = `[Thread follow-up — ${items.length} message(s) buffered]
+    const description = `[Thread follow-up — ${items.length} message(s) buffered]
 
 ${combinedText}`;
-  const latestActiveTask = await getLatestActiveTaskInThread(channelId, threadTs);
-  if (latestActiveTask) {
-    console.log(`[Slack] Dependency chaining: latest active task ${latestActiveTask.id} (status: ${latestActiveTask.status})`);
-  }
-  const steering = await requestSlackThreadSteering({
-    channelId,
-    threadTs,
-    message: combinedText,
-    messageTimestamps: items.map((item) => item.ts)
-  });
-  if (steering) {
-    console.log(`[Slack] Buffer flushed → steering ${steering.result.outcome} for task ${steering.task.id}`);
-    const app2 = getSlackApp();
-    const agent = steering.task.agentId ? await getAgentById(steering.task.agentId) : undefined;
-    if (app2) {
-      if (!isSlackRenderV2Enabled()) {
-        try {
-          await app2.client.chat.postMessage({
-            channel: channelId,
-            thread_ts: threadTs,
-            text: formatSlackSteeringAck(steering.result),
-            unfurl_links: false,
-            unfurl_media: false,
-            ...agent ? { username: getAgentDisplayName(agent), icon_emoji: getAgentEmoji(agent) } : {}
-          });
-        } catch (error) {
-          console.error("[Slack] Failed to post steering feedback:", error);
+    const latestActiveTask = await getLatestActiveTaskInThread(channelId, threadTs);
+    if (latestActiveTask) {
+      console.log(`[Slack] Dependency chaining: latest active task ${latestActiveTask.id} (status: ${latestActiveTask.status})`);
+    }
+    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 agent = steering.task.agentId ? await getAgentById(steering.task.agentId) : undefined;
+      if (app) {
+        if (!isSlackRenderV2Enabled()) {
+          try {
+            await app.client.chat.postMessage({
+              channel: channelId,
+              thread_ts: threadTs,
+              text: formatSlackSteeringAck(steering.result),
+              unfurl_links: false,
+              unfurl_media: false,
+              ...agent ? { username: getAgentDisplayName(agent), icon_emoji: getAgentEmoji(agent) } : {}
+            });
+          } catch (error) {
+            console.error("[Slack] Failed to post steering feedback:", error);
+          }
         }
       }
+      return;
     }
-    return;
-  }
-  const lead = await getLeadAgent();
-  const threadContext = await getThreadContextForBuffer(channelId, threadTs);
-  const fullDescription = threadContext ? `<thread_context>
+    const lead = await getLeadAgent();
+    const threadContext = await getThreadContextForBuffer(channelId, threadTs);
+    const fullDescription = threadContext ? `<thread_context>
 ${threadContext}
 </thread_context>
 
 ${description}` : description;
-  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 })
-  });
-  console.log(`[Slack] Buffer flushed → task ${task.id} (dependsOn: ${dependsOn ? dependsOn.join(", ") : "none"})`);
-  if (isSlackRenderV2Enabled()) {
-    await ensureSlackThreadTree([task.id]);
-    return;
-  }
-  const app = getSlackApp();
-  if (app) {
-    const hasDependency = !immediate && !!latestActiveTask;
-    const blocks = buildBufferFlushBlocks({
-      messageCount: items.length,
-      taskId: task.id,
-      hasDependency
-    });
-    const fallbackText = hasDependency ? `${items.length} follow-up message(s) queued pending completion of current task` : `${items.length} follow-up message(s) batched into task`;
-    try {
-      const result = await app.client.chat.postMessage({
-        channel: channelId,
-        thread_ts: threadTs,
-        text: fallbackText,
-        unfurl_links: false,
-        unfurl_media: false,
-        ...lead ? { username: getAgentDisplayName(lead), icon_emoji: getAgentEmoji(lead) } : {},
-        blocks
+    const dependsOn = !immediate && latestActiveTask ? [latestActiveTask.id] : undefined;
+    const mostRecentTask = await getMostRecentTaskInThread(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"})`);
+    if (isSlackRenderV2Enabled()) {
+      await ensureSlackThreadTree([task.id]);
+      return;
+    }
+    if (app) {
+      const hasDependency = !immediate && !!latestActiveTask;
+      const blocks = buildBufferFlushBlocks({
+        messageCount: items.length,
+        taskId: task.id,
+        hasDependency
       });
-      if (result.ts && task) {
-        await registerTreeMessage(task.id, channelId, threadTs, result.ts);
-        console.log(`[Slack] Registered batched task ${task.id.slice(0, 8)} tree message from buffer flush`);
+      const fallbackText = hasDependency ? `${items.length} follow-up message(s) queued pending completion of current task` : `${items.length} follow-up message(s) batched into task`;
+      try {
+        const result = await app.client.chat.postMessage({
+          channel: channelId,
+          thread_ts: threadTs,
+          text: fallbackText,
+          unfurl_links: false,
+          unfurl_media: false,
+          ...lead ? { username: getAgentDisplayName(lead), icon_emoji: getAgentEmoji(lead) } : {},
+          blocks
+        });
+        if (result.ts && task) {
+          await registerTreeMessage(task.id, channelId, threadTs, result.ts);
+          console.log(`[Slack] Registered batched task ${task.id.slice(0, 8)} tree message from buffer flush`);
+        }
+      } catch (error) {
+        console.error("[Slack] Failed to post buffer flush feedback:", error);
       }
-    } catch (error) {
-      console.error("[Slack] Failed to post buffer flush feedback:", error);
     }
+  } catch (_catch) {
+    var _err = _catch, _hasErr = 1;
+  } finally {
+    var _promise = __callDispose(__stack, _err, _hasErr);
+    _promise && await _promise;
   }
 }
 

package/dist/{cli-9br8ypfv.js → cli-czjtgfys.js}

@@ -4,12 +4,12 @@ import {
   linkIdentity,
   recordUnmappedIdentity,
   resolveIdentity
-} from "./cli-j4d4f6hv.js";
+} from "./cli-5tpgq60f.js";
 import {
   getKv,
   init_db,
   upsertKv
-} from "./cli-qgd4sqz5.js";
+} from "./cli-s14agm5s.js";
 
 // src/slack/enrich.ts
 init_db();

package/dist/{cli-5my3bjsd.js → cli-d3p82erb.js}

@@ -1,15 +1,12 @@
+import {
+  fetchInstalledMcpServers
+} from "./cli-tng3131n.js";
 import {
   require_cross_spawn
 } from "./cli-5bfdm1ah.js";
 import {
   resolveSlashSkillPrompt
 } from "./cli-r94z9p1z.js";
-import {
-  readPkgVersion
-} from "./cli-2djtr51b.js";
-import {
-  fetchInstalledMcpServers
-} from "./cli-tng3131n.js";
 import {
   CTX_MODE_NUDGE_EVERY
 } from "./cli-zm7njwzd.js";
@@ -18,12 +15,15 @@ import {
   clampContextPercent,
   getContextWindowSize
 } from "./cli-s25avqg9.js";
+import {
+  readPkgVersion
+} from "./cli-2djtr51b.js";
 import {
   applyReasoningEffort
 } from "./cli-4yc5d8fk.js";
 import {
   swarmRuntimeInstanceId
-} from "./cli-07jd68a1.js";
+} from "./cli-re8z5p8p.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterBaseUrl

package/dist/{cli-e29gmdmw.js → cli-dv6cdjs2.js}

@@ -42,7 +42,8 @@ function buildAgentFsLiveUrl(opts) {
     return null;
   const host = getAgentFsLiveUrl();
   const normalizedPath = path.replace(/^\/+/, "");
-  return `${host}/file/~/${orgId}/${driveId}/${normalizedPath}`;
+  const encodedPath = normalizedPath.split("/").map((segment) => encodeURIComponent(segment).replace(/%25([0-9a-f]{2})/gi, "%$1")).join("/");
+  return `${host}/file/~/${orgId}/${driveId}/${encodedPath}`;
 }
 var MAX_PROFILE_FILE_LENGTH, DEFAULT_APP_URL = "https://app.agent-swarm.dev", DEFAULT_AGENT_FS_LIVE_URL = "https://live.agent-fs.dev";
 var init_constants = __esm(() => {