@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{cli-j57qkrpq.js → cli-azhgzetg.js}

@@ -45,6 +45,8 @@ import {
   init_reaction_shortcode,
   isPendingSlackMessage,
   isSettledSlackMessage,
+  isSlackThreadAwaitingHuman,
+  listSlackThreadsAwaitingHuman,
   markFinalizedSlackRelaysDelivered,
   markSlackDeferralResolved,
   markSlackRelayAttempted,
@@ -57,19 +59,19 @@ import {
   setSlackMessageTracking,
   slackContextKey,
   updateSlackMessageRecord
-} from "./cli-47m6dkd3.js";
+} from "./cli-qydf22qq.js";
 import {
   init_types,
   isTerminalTaskStatus
-} from "./cli-4198qc9v.js";
-import {
-  getAppUrl,
-  init_constants
-} from "./cli-dv6cdjs2.js";
+} from "./cli-ktmyrtpn.js";
 import {
   getSlackConfiguration,
   init_config
 } from "./cli-n7h1kqpf.js";
+import {
+  getAppUrl,
+  init_constants
+} from "./cli-dv6cdjs2.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
@@ -52904,7 +52906,7 @@ async function initOtel(serviceRole = process.env.AGENT_ROLE || "api") {
     return;
   initialized = true;
   try {
-    const impl = await import("./otel-impl-9mz73q65.js");
+    const impl = await import("./otel-impl-a792rjz0.js");
     await impl.boot(serviceRole, {
       exportConsoleLogs: serviceRole === "api" && isApiLogExportEnabled()
     });
@@ -54341,15 +54343,15 @@ async function initSlackApp() {
     ...clientOptions ? { clientOptions } : {}
   });
   initialized2 = true;
-  const { registerMessageHandler } = await import("./handlers-aqcedbyb.js");
-  const { registerCommandHandler } = await import("./commands-e3bn0p75.js");
-  const { registerActionHandlers } = await import("./actions-p9hz5yat.js");
-  const { registerWorkObjectHandlers } = await import("./work-objects-b76x7deb.js");
+  const { registerMessageHandler } = await import("./handlers-kjdce1w5.js");
+  const { registerCommandHandler } = await import("./commands-8wcq1kn7.js");
+  const { registerActionHandlers } = await import("./actions-e43rxskr.js");
+  const { registerWorkObjectHandlers } = await import("./work-objects-fg6xkb0n.js");
   registerMessageHandler(app);
   registerCommandHandler(app);
   registerActionHandlers(app);
   registerWorkObjectHandlers(app);
-  const { createAssistant } = await import("./assistant-wydfqkb3.js");
+  const { createAssistant } = await import("./assistant-sedkzv3b.js");
   app.assistant(createAssistant());
   return app;
 }
@@ -54358,7 +54360,7 @@ async function startSlackApp() {
     await initSlackApp();
   }
   if (app) {
-    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-gryrh9h8.js");
+    const { isSlackRenderV2Enabled: isSlackRenderV2Enabled2 } = await import("./render-v2-mm7zswb8.js");
     if (isSlackRenderV2Enabled2())
       await ensureSlackRenderV2Activation();
     await app.start();
@@ -54540,6 +54542,334 @@ function closureState(ask, closure, now, settleSec, timeoutMin) {
 
 // src/slack/render-v2.ts
 init_reaction_shortcode();
+
+// src/slack/session-status.ts
+init_db();
+init_types();
+init_secret_scrubber();
+var import_bolt2 = __toESM(require_dist7(), 1);
+var REFRESH_MS = 30 * 60000;
+var DEFAULT_CALL_TIMEOUT_MS = 8000;
+var TRANSPORT_MARGIN_MS = 500;
+var callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS;
+var RETRY_BASE_MS = 30000;
+var RETRY_MAX_MS = 10 * 60000;
+var UNAVAILABLE_COOLDOWN_MS = 60 * 60000;
+var CALLS_PER_TICK = 8;
+var ORPHAN_GRACE_MS = 2 * 60000;
+var WORKSPACE_ERRORS = new Set([
+  "missing_scope",
+  "not_allowed_token_type",
+  "feature_disabled",
+  "not_authed",
+  "invalid_auth",
+  "account_inactive",
+  "token_revoked",
+  "token_expired",
+  "access_denied",
+  "no_permission",
+  "accesslimited",
+  "enterprise_is_restricted",
+  "ekm_access_denied",
+  "org_login_required",
+  "method_deprecated",
+  "deprecated_endpoint",
+  "unknown_method"
+]);
+var TRANSIENT_ERRORS = new Set([
+  "ratelimited",
+  "rate_limited",
+  "internal_error",
+  "service_unavailable",
+  "fatal_error",
+  "request_timeout"
+]);
+var threads = new Map;
+var keyTails = new Map;
+var warned = new Set;
+var unavailableUntil = 0;
+function threadKey(channelId, threadTs) {
+  return `${channelId}:${threadTs}`;
+}
+function splitKey(key) {
+  const at = key.indexOf(":");
+  return { channelId: key.slice(0, at), threadTs: key.slice(at + 1) };
+}
+function errorCode(error) {
+  const code = error?.data?.error;
+  return typeof code === "string" && code.length > 0 ? code : undefined;
+}
+function warnOnce(key, message) {
+  if (warned.has(key))
+    return;
+  warned.add(key);
+  console.warn(scrubSecrets(`[Slack] ${message}`));
+}
+
+class CallTimeoutError extends Error {
+  constructor(ms) {
+    super(`timed out after ${ms}ms`);
+    this.name = "CallTimeoutError";
+  }
+}
+function withTimeout(promise, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new CallTimeoutError(ms)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+var transports = new WeakMap;
+function statusTransport(client) {
+  if (!(client instanceof import_bolt2.webApi.WebClient))
+    return client;
+  let transport = transports.get(client);
+  if (!transport) {
+    const timeout = Math.max(callTimeoutMs - TRANSPORT_MARGIN_MS, 1);
+    transport = new import_bolt2.webApi.WebClient(client.token ?? process.env.SLACK_BOT_TOKEN, {
+      slackApiUrl: client.slackApiUrl,
+      retryConfig: { retries: 0 },
+      rejectRateLimitedCalls: true,
+      timeout,
+      requestInterceptor: (config) => ({ ...config, signal: AbortSignal.timeout(timeout) })
+    });
+    transports.set(client, transport);
+  }
+  return transport;
+}
+function withThreadLock(key, fn) {
+  const run = (keyTails.get(key) ?? Promise.resolve()).then(fn);
+  const tail = run.catch(() => {
+    return;
+  });
+  keyTails.set(key, tail);
+  tail.then(() => {
+    if (keyTails.get(key) === tail)
+      keyTails.delete(key);
+  });
+  return run;
+}
+function decideSlackSessionStatus(tasks, awaitingHuman) {
+  if (tasks.some((task) => !isTerminalTaskStatus(task.status)))
+    return "processing";
+  return awaitingHuman ? "suspended" : "active";
+}
+async function desiredStatus(channelId, threadTs) {
+  const tasks = await getSlackTasksInThread(channelId, threadTs);
+  const running = tasks.some((task) => !isTerminalTaskStatus(task.status));
+  const awaitingHuman = running ? false : await isSlackThreadAwaitingHuman(channelId, threadTs);
+  return decideSlackSessionStatus(tasks, awaitingHuman);
+}
+function classify(error) {
+  const code = errorCode(error);
+  if (!code)
+    return { kind: "transient", code: "no_slack_verdict" };
+  if (WORKSPACE_ERRORS.has(code))
+    return { kind: "unavailable", code };
+  if (TRANSIENT_ERRORS.has(code))
+    return { kind: "transient", code };
+  return { kind: "refused", code };
+}
+function retryAfterMs(error) {
+  const seconds = error?.retryAfter;
+  return typeof seconds === "number" && seconds > 0 ? seconds * 1000 : undefined;
+}
+async function applyStatus(client, channelId, threadTs, desired, budget) {
+  const key = threadKey(channelId, threadTs);
+  const now = Date.now();
+  const entry = threads.get(key);
+  if (now < unavailableUntil || entry?.refused) {
+    if (desired === "active")
+      threads.delete(key);
+    return "unavailable";
+  }
+  if (desired === "active") {
+    if (!entry || entry.status === "active" && !entry.uncertain) {
+      threads.delete(key);
+      return "idle";
+    }
+  } else if (entry && entry.status === desired && !entry.uncertain && now - entry.setAt < REFRESH_MS) {
+    return "current";
+  }
+  if (entry && now < entry.retryAt)
+    return "unavailable";
+  if (budget) {
+    if (budget.remaining <= 0) {
+      if (entry)
+        threads.set(key, { ...entry, deferred: true });
+      return "unavailable";
+    }
+    budget.remaining--;
+  }
+  const pending = statusTransport(client).apiCall("agents.sessions.setStatus", {
+    channel_id: channelId,
+    thread_ts: threadTs,
+    status: desired
+  });
+  try {
+    const result = await withTimeout(pending, callTimeoutMs);
+    if (result?.ok === false)
+      throw { data: { error: result.error ?? "unknown_error" } };
+  } catch (error) {
+    if (error instanceof CallTimeoutError) {
+      pending.then((late) => {
+        if (late?.ok !== false) {
+          noteLateWrite(client, channelId, threadTs, desired);
+        }
+      }, () => {});
+    }
+    const failure = classify(error);
+    if (failure.kind === "unavailable") {
+      unavailableUntil = now + UNAVAILABLE_COOLDOWN_MS;
+      warnOnce(`unavailable:${failure.code}`, `Native session status is unavailable (${failure.code}). Keeping the reaction and tree message${failure.code === "missing_scope" ? "; the bot token needs the chat:write scope" : ""}. Will probe again in ${UNAVAILABLE_COOLDOWN_MS / 60000} min.`);
+    } else if (failure.kind === "refused") {
+      threads.set(key, {
+        status: entry?.status ?? "active",
+        setAt: entry?.setAt ?? 0,
+        failures: 0,
+        retryAt: 0,
+        refused: true,
+        uncertain: false
+      });
+      warnOnce(`refused:${failure.code}`, `Slack refused a session status for ${channelId}/${threadTs} (${failure.code}). Leaving that thread on the reaction and tree message.`);
+    } else {
+      const failures = (entry?.failures ?? 0) + 1;
+      const backoff = Math.min(RETRY_BASE_MS * 2 ** (failures - 1), RETRY_MAX_MS);
+      threads.set(key, {
+        status: entry?.status ?? "active",
+        setAt: entry?.setAt ?? 0,
+        failures,
+        retryAt: now + Math.max(backoff, retryAfterMs(error) ?? 0),
+        refused: false,
+        uncertain: true
+      });
+      warnOnce(`transient:${failure.code}`, `Setting the session status failed (${failure.code}); retrying with backoff.`);
+    }
+    return "unavailable";
+  }
+  if (desired === "active")
+    threads.delete(key);
+  else {
+    threads.set(key, {
+      status: desired,
+      setAt: now,
+      failures: 0,
+      retryAt: 0,
+      refused: false,
+      uncertain: false
+    });
+  }
+  return "applied";
+}
+async function noteLateWrite(client, channelId, threadTs, landed) {
+  try {
+    const key = threadKey(channelId, threadTs);
+    await withThreadLock(key, async () => {
+      if (landed === "active")
+        threads.delete(key);
+      else {
+        threads.set(key, {
+          status: landed,
+          setAt: Date.now(),
+          failures: 0,
+          retryAt: 0,
+          refused: false,
+          uncertain: false
+        });
+      }
+    });
+    await reconcileSlackSessionStatus({ channelId, threadTs, client });
+  } catch (error) {
+    warnOnce("late-write", `Reconciling a late session status write failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function clearLegacyDmStatus(client, channelId, threadTs) {
+  if (!channelId.startsWith("D"))
+    return;
+  try {
+    await client.apiCall("assistant.threads.setStatus", {
+      channel_id: channelId,
+      thread_ts: threadTs,
+      status: ""
+    });
+  } catch (error) {
+    warnOnce("legacy-clear", `Failed to clear the assistant status for ${channelId}/${threadTs}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function reconcileSlackSessionStatus(input) {
+  try {
+    const client = input.client ?? getSlackApp()?.client;
+    if (!client)
+      return;
+    const { channelId, threadTs } = input;
+    await withThreadLock(threadKey(channelId, threadTs), async () => {
+      const desired = await desiredStatus(channelId, threadTs);
+      const result = await applyStatus(client, channelId, threadTs, desired, input.budget);
+      if (input.outcomeDelivered && result === "unavailable") {
+        await clearLegacyDmStatus(client, channelId, threadTs);
+      }
+    });
+  } catch (error) {
+    warnOnce("reconcile", `Session status sync failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function markSlackSessionProcessing(input) {
+  try {
+    const client = input.client ?? getSlackApp()?.client;
+    if (!client)
+      return false;
+    const { channelId, threadTs } = input;
+    return await withThreadLock(threadKey(channelId, threadTs), async () => {
+      const result = await applyStatus(client, channelId, threadTs, "processing");
+      return result === "applied" || result === "current";
+    });
+  } catch {
+    return false;
+  }
+}
+function beginSlackStatusTick() {
+  const budget = { remaining: CALLS_PER_TICK };
+  const visited = new Set;
+  return {
+    budget,
+    reconcile: async (channelId, threadTs) => {
+      visited.add(threadKey(channelId, threadTs));
+      await reconcileSlackSessionStatus({ channelId, threadTs, budget });
+    },
+    finish: async () => {
+      try {
+        const targets = new Map;
+        const now = Date.now();
+        for (const [key, entry] of threads) {
+          const inGrace = entry.status === "processing" && !entry.uncertain && !entry.deferred && now - entry.setAt < ORPHAN_GRACE_MS;
+          if (inGrace)
+            continue;
+          targets.set(key, splitKey(key));
+        }
+        for (const thread of await listSlackThreadsAwaitingHuman()) {
+          targets.set(threadKey(thread.channelId, thread.threadTs), thread);
+        }
+        for (const [key, thread] of targets) {
+          if (visited.has(key))
+            continue;
+          await reconcileSlackSessionStatus({ ...thread, budget });
+        }
+      } catch (error) {
+        warnOnce("tick-finish", `Session status sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  };
+}
+function _resetSlackSessionStatusForTests() {
+  callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS;
+  transports = new WeakMap;
+  threads.clear();
+  keyTails.clear();
+  warned.clear();
+  unavailableUntil = 0;
+}
+
+// src/slack/render-v2.ts
 var TREE_UPDATE_DEBOUNCE_MS = 500;
 var TREE_UPDATE_MIN_INTERVAL_MS = 3000;
 var MAX_SLACK_RETRIES = 3;
@@ -54603,7 +54933,7 @@ function outcomeDeliveryGate(taskId, card) {
     return false;
   return Date.now() >= (outcomeDeliveryNextAttemptAt.get(taskId) ?? 0);
 }
-async function reconcileStuckOutcomeDelivery(task, card) {
+async function reconcileStuckOutcomeDelivery(task, card, statusBudget) {
   if (!card || card.deliveryAbandonedAt)
     return;
   if (card.deliveryAttempts < OUTCOME_DELIVERY_MAX_ATTEMPTS)
@@ -54614,16 +54944,16 @@ async function reconcileStuckOutcomeDelivery(task, card) {
   if (!abandoned)
     return;
   console.error(`[Slack] Recovered a stuck outcome delivery for task ${task.id} left at ` + `${card.deliveryAttempts} attempt(s) without a give-up; surfacing failure and clearing the working indicator`);
-  await surfaceOutcomeDeliveryGiveUp(task, lastError, card.deliveryAttempts);
+  await surfaceOutcomeDeliveryGiveUp(task, lastError, card.deliveryAttempts, statusBudget);
 }
-async function checkOutcomeDeliveryGate(task, card) {
-  await reconcileStuckOutcomeDelivery(task, card);
+async function checkOutcomeDeliveryGate(task, card, statusBudget) {
+  await reconcileStuckOutcomeDelivery(task, card, statusBudget);
   return outcomeDeliveryGate(task.id, card);
 }
 function noteOutcomeDeliverySuccess(taskId) {
   outcomeDeliveryNextAttemptAt.delete(taskId);
 }
-async function noteOutcomeDeliveryFailure(task, tree, error) {
+async function noteOutcomeDeliveryFailure(task, tree, error, statusBudget) {
   const detail = describeSlackError(error);
   const summary = scrubSecrets(slackErrorSummary(error));
   if (!task.slackChannelId || !task.slackThreadTs) {
@@ -54654,9 +54984,9 @@ async function noteOutcomeDeliveryFailure(task, tree, error) {
   if (!abandoned)
     return;
   console.error(`[Slack] Giving up on outcome delivery for task ${task.id} after ${attempts} attempt(s)` + `${terminal ? " (Slack refused the delivery)" : ""}; surfacing failure and clearing the working indicator`);
-  await surfaceOutcomeDeliveryGiveUp(task, summary, attempts);
+  await surfaceOutcomeDeliveryGiveUp(task, summary, attempts, statusBudget);
 }
-async function surfaceOutcomeDeliveryGiveUp(task, summary, attempts) {
+async function surfaceOutcomeDeliveryGiveUp(task, summary, attempts, statusBudget) {
   const app2 = getSlackApp();
   if (!app2 || !task.slackChannelId || !task.slackThreadTs)
     return;
@@ -54669,20 +54999,16 @@ async function surfaceOutcomeDeliveryGiveUp(task, summary, attempts) {
   } catch (postError) {
     console.error(`[Slack] Give-up notice failed to post for task ${task.id}:`, scrubSecrets(postError instanceof Error ? postError.message : String(postError)));
   }
-  await clearAssistantStatus(app2.client, task.slackChannelId, task.slackThreadTs);
+  await clearAssistantStatus(app2.client, task.slackChannelId, task.slackThreadTs, statusBudget);
 }
-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);
-  }
+async function clearAssistantStatus(client, channelId, threadTs, statusBudget) {
+  await reconcileSlackSessionStatus({
+    client,
+    channelId,
+    threadTs,
+    budget: statusBudget,
+    outcomeDelivered: true
+  });
 }
 function slackTreeStallMinutes() {
   return Number(process.env.SLACK_TREE_STALL_MIN) || 15;
@@ -54996,10 +55322,15 @@ async function createThreadTree(task) {
   lastTreeUpdateAt.set(record.id, Date.now());
   return record;
 }
-async function ensureSlackThreadTree(taskIds) {
+async function ensureSlackThreadTree(taskIds, statusBudget) {
   const task = (await Promise.all(taskIds.map(getTaskById))).find((candidate) => !!candidate);
   if (!task?.slackChannelId || !task.slackThreadTs)
     return null;
+  await reconcileSlackSessionStatus({
+    channelId: task.slackChannelId,
+    threadTs: task.slackThreadTs,
+    budget: statusBudget
+  });
   const contextKey = task.contextKey ?? slackContextKey({
     channelId: task.slackChannelId,
     threadTs: task.slackThreadTs
@@ -55015,7 +55346,7 @@ async function ensureSlackThreadTree(taskIds) {
       if (!isSlackMessageNotFound(error))
         throw error;
       await discardTreeRecord(existing);
-      return ensureSlackThreadTree(taskIds);
+      return ensureSlackThreadTree(taskIds, statusBudget);
     }
   }
   const creationKey = physicalThreadKey(task.slackChannelId, task.slackThreadTs);
@@ -55050,12 +55381,12 @@ async function withTreeUpdateLock(channelId, threadTs, work) {
       treeUpdateTails.delete(key);
   }
 }
-async function replaceMissingTree(tree) {
+async function replaceMissingTree(tree, statusBudget) {
   await discardTreeRecord(tree);
   const taskIds = (await getSlackTasksInThread(tree.channelId, tree.threadTs)).map((task) => task.id);
-  return taskIds.length > 0 ? ensureSlackThreadTree(taskIds) : null;
+  return taskIds.length > 0 ? ensureSlackThreadTree(taskIds, statusBudget) : null;
 }
-async function updateThreadTree(tree, bypassThrottle = false) {
+async function updateThreadTree(tree, bypassThrottle = false, statusBudget) {
   const result = await withTreeUpdateLock(tree.channelId, tree.threadTs, async () => {
     const app2 = getSlackApp();
     if (!app2)
@@ -55101,7 +55432,7 @@ async function updateThreadTree(tree, bypassThrottle = false) {
     return "updated";
   });
   if (result === "missing") {
-    await replaceMissingTree(tree);
+    await replaceMissingTree(tree, statusBudget);
     return false;
   }
   return result === "updated";
@@ -55454,7 +55785,7 @@ async function streamOutcomeCard(task, tree, options) {
       });
     }
   }
-  await clearAssistantStatus(app2.client, task.slackChannelId, task.slackThreadTs);
+  await clearAssistantStatus(app2.client, task.slackChannelId, task.slackThreadTs, options?.statusBudget);
   const permalink = await resolvePermalink(app2.client, task.slackChannelId, outcome.ts);
   return await updateSlackMessageRecord(outcome.id, {
     permalink,
@@ -55553,13 +55884,14 @@ async function processSlackRenderV2() {
   const activatedAt = await ensureSlackRenderV2Activation();
   const delegationEnabled = isSlackDelegationEnabled();
   const delegationActivatedAt = delegationEnabled ? await ensureSlackDelegationActivation() : null;
+  const statusTick = beginSlackStatusTick();
   for (const task of await getSlackTasksMissingTree()) {
     if (!isSlackRenderV2Enabled())
       return;
     if (!task.slackChannelId || !task.slackThreadTs)
       continue;
     try {
-      await ensureSlackThreadTree([task.id]);
+      await ensureSlackThreadTree([task.id], statusTick.budget);
     } catch (error) {
       console.error(`[Slack] Failed to create v2 tree for task ${task.id}:`, error);
     }
@@ -55571,7 +55903,7 @@ async function processSlackRenderV2() {
     const initialTasks = await getSlackTasksInThread(tree.channelId, tree.threadTs);
     if (isPendingSlackMessage(tree)) {
       try {
-        const recovered = await ensureSlackThreadTree(initialTasks.map((task) => task.id));
+        const recovered = await ensureSlackThreadTree(initialTasks.map((task) => task.id), statusTick.budget);
         if (!recovered)
           continue;
         tree = recovered;
@@ -55587,7 +55919,7 @@ async function processSlackRenderV2() {
       } catch (error) {
         if (isSlackMessageNotFound(error)) {
           try {
-            await replaceMissingTree(tree);
+            await replaceMissingTree(tree, statusTick.budget);
           } catch (replacementError) {
             console.error(`[Slack] Failed to replace missing v2 tree ${tree.id}:`, replacementError);
           }
@@ -55619,7 +55951,7 @@ async function processSlackRenderV2() {
           continue;
         }
         try {
-          const replacement = await replaceMissingTree(tree);
+          const replacement = await replaceMissingTree(tree, statusTick.budget);
           if (!replacement)
             continue;
           tree = replacement;
@@ -55680,10 +56012,13 @@ async function processSlackRenderV2() {
         continue;
       if (askId && await childCardCountFor(askId) >= CHILD_CARDS_PER_ASK)
         continue;
-      if (!await checkOutcomeDeliveryGate(task, card))
+      if (!await checkOutcomeDeliveryGate(task, card, statusTick.budget))
         continue;
       try {
-        const outcome = await streamOutcomeCard(task, tree, { buildContent: childOutcomeContent });
+        const outcome = await streamOutcomeCard(task, tree, {
+          buildContent: childOutcomeContent,
+          statusBudget: statusTick.budget
+        });
         if (outcome) {
           noteOutcomeDeliverySuccess(task.id);
           childCardsThisTick++;
@@ -55693,7 +56028,7 @@ async function processSlackRenderV2() {
         }
         outcomeCreated ||= !!outcome;
       } catch (error) {
-        await noteOutcomeDeliveryFailure(task, tree, error);
+        await noteOutcomeDeliveryFailure(task, tree, error, statusTick.budget);
       }
     }
     for (const task of tasks) {
@@ -55708,17 +56043,17 @@ async function processSlackRenderV2() {
         continue;
       const deferByClosure = task.source === "slack" && delegationEnabled && delegationActivatedAt !== null && task.createdAt >= delegationActivatedAt;
       if (!deferByClosure) {
-        if (!await checkOutcomeDeliveryGate(task, card))
+        if (!await checkOutcomeDeliveryGate(task, card, statusTick.budget))
           continue;
         try {
-          const outcome = await streamOutcomeCard(task, tree);
+          const outcome = await streamOutcomeCard(task, tree, { statusBudget: statusTick.budget });
           if (outcome) {
             noteOutcomeDeliverySuccess(task.id);
             await finalizeTerminalSlackReactions([task]);
           }
           outcomeCreated ||= !!outcome;
         } catch (error) {
-          await noteOutcomeDeliveryFailure(task, tree, error);
+          await noteOutcomeDeliveryFailure(task, tree, error, statusTick.budget);
         }
         continue;
       }
@@ -55741,12 +56076,13 @@ async function processSlackRenderV2() {
       const state2 = closureState(task, closure, new Date, settleSec, timeoutMin);
       if (state2 === "open")
         continue;
-      if (!await checkOutcomeDeliveryGate(task, card))
+      if (!await checkOutcomeDeliveryGate(task, card, statusTick.budget))
         continue;
       try {
         const outcome = await streamOutcomeCard(task, tree, {
           buildContent: (_t, slackReplySent) => askConclusionContent(task, closure, state2, slackReplySent),
-          conclusionKind: state2 === "timedOut" ? "timeout" : "complete"
+          conclusionKind: state2 === "timedOut" ? "timeout" : "complete",
+          statusBudget: statusTick.budget
         });
         if (outcome) {
           noteOutcomeDeliverySuccess(task.id);
@@ -55760,16 +56096,18 @@ async function processSlackRenderV2() {
         }
         outcomeCreated ||= !!outcome;
       } catch (error) {
-        await noteOutcomeDeliveryFailure(task, tree, error);
+        await noteOutcomeDeliveryFailure(task, tree, error, statusTick.budget);
       }
     }
     try {
-      await updateThreadTree(tree, outcomeCreated);
+      await updateThreadTree(tree, outcomeCreated, statusTick.budget);
     } catch (error) {
       console.error(`[Slack] Failed to update v2 tree ${tree.id}:`, error);
     }
+    await statusTick.reconcile(tree.channelId, tree.threadTs);
   }
   await refreshResolvedDeferralCards();
+  await statusTick.finish();
 }
 function _resetSlackRenderV2ForTests() {
   for (const timer of pendingTreeUpdates.values())
@@ -55782,7 +56120,8 @@ function _resetSlackRenderV2ForTests() {
   cachedTeamId = undefined;
   outcomeDeliveryNextAttemptAt.clear();
   outcomeReservedWithoutAttempt.clear();
+  _resetSlackSessionStatusForTests();
 }
-var _noteOutcomeDeliveryFailureForTests = noteOutcomeDeliveryFailure;
+var _noteOutcomeDeliveryFailureForTests = (task, tree, error) => noteOutcomeDeliveryFailure(task, tree, error, undefined);
 
-export { initialize, ensure, require_dist7 as require_dist, getSlackConnectionState, isPollTracingEnabled, initOtel, withSpan, startSpan, withSpanContext, withRemoteContext, injectTraceContext, recordSessionCost, recordDbRetentionSweep, recordDbRetentionStatement, slackTaskOutput, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildCaptionBlock, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, taskCitationIssues, stripInvalidTaskCitations, taskCitationSourceGroups, renderTaskCitations, taskCitationWarnings, MAX_TASK_CITATIONS, CitationInputSchema, TaskCitationSchema, upsertTaskCitations, getTaskCitations, getTaskCitationsForTasks, hasTaskCitationCheckRefusal, getAgentDisplayName, getAgentEmoji, isSlackRenderV2Enabled, isSlackDelegationEnabled, callSlackWithRetry, formatV2Duration, renderThreadTree, ensureSlackThreadTree, withStatusLead, childOutcomeContent, streamOutcomeCard, slackErrorCode2 as slackErrorCode, isTerminalSlackError, describeSlackError, slackErrorSummary, refreshResolvedDeferralCards, processSlackRenderV2, _resetSlackRenderV2ForTests, _noteOutcomeDeliveryFailureForTests, registerTreeMessage, getSlackApp, initSlackApp, startSlackApp, stopSlackApp };
+export { initialize, ensure, require_dist7 as require_dist, getSlackConnectionState, isPollTracingEnabled, initOtel, withSpan, startSpan, withSpanContext, withRemoteContext, injectTraceContext, recordSessionCost, recordDbRetentionSweep, recordDbRetentionStatement, slackTaskOutput, ackSlackMessage, getTaskLink, getTaskUrl, markdownToSlack, buildCaptionBlock, buildCancelledBlocks, buildBufferFlushBlocks, buildTreeBlocks, taskCitationIssues, stripInvalidTaskCitations, taskCitationSourceGroups, renderTaskCitations, taskCitationWarnings, MAX_TASK_CITATIONS, CitationInputSchema, TaskCitationSchema, upsertTaskCitations, getTaskCitations, getTaskCitationsForTasks, hasTaskCitationCheckRefusal, getAgentDisplayName, getAgentEmoji, markSlackSessionProcessing, isSlackRenderV2Enabled, isSlackDelegationEnabled, callSlackWithRetry, formatV2Duration, renderThreadTree, ensureSlackThreadTree, withStatusLead, childOutcomeContent, streamOutcomeCard, slackErrorCode2 as slackErrorCode, isTerminalSlackError, describeSlackError, slackErrorSummary, refreshResolvedDeferralCards, processSlackRenderV2, _resetSlackRenderV2ForTests, _noteOutcomeDeliveryFailureForTests, registerTreeMessage, getSlackApp, initSlackApp, startSlackApp, stopSlackApp };