@desplega.ai/agent-swarm 2.7.2 → 2.7.3

package/src/commands/runner.ts

@@ -5682,6 +5682,38 @@ export async function checkCompletedProcesses(
 
 const TEMPLATE_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
+async function saveGeneratedProfile({
+  apiUrl,
+  apiKey,
+  agentId,
+  role,
+  profileUpdate,
+}: {
+  apiUrl: string;
+  apiKey: string;
+  agentId: string;
+  role: string;
+  profileUpdate: Record<string, string>;
+}): Promise<void> {
+  try {
+    const response = await fetch(`${apiUrl}/api/agents/${agentId}/profile`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "X-Agent-ID": agentId,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(profileUpdate),
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+    }
+    console.log(`[${role}] Generated and saved default identity templates`);
+  } catch (err) {
+    console.warn(scrubSecrets(`[${role}] Could not save generated templates to server: ${err}`));
+  }
+}
+
 async function fetchTemplate(
   templateId: string,
   registryUrl: string,
@@ -6534,30 +6566,15 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         if (!agentClaudeMd) agentClaudeMd = generateDefaultClaudeMd(agentInfo);
 
         // Push generated templates to server
-        try {
-          const profileUpdate: Record<string, string> = {};
-          if (!profile.soulMd) profileUpdate.soulMd = agentSoulMd;
-          if (!profile.identityMd) profileUpdate.identityMd = agentIdentityMd;
-          if (!profile.toolsMd) profileUpdate.toolsMd = agentToolsMd;
-          if (!profile.claudeMd && agentClaudeMd) profileUpdate.claudeMd = agentClaudeMd;
-          if (!profile.setupScript && agentSetupScript)
-            profileUpdate.setupScript = agentSetupScript;
-          if (!profile.heartbeatMd && agentHeartbeatMd)
-            profileUpdate.heartbeatMd = agentHeartbeatMd;
-
-          await fetch(`${apiUrl}/api/agents/${agentId}/profile`, {
-            method: "PUT",
-            headers: {
-              Authorization: `Bearer ${apiKey}`,
-              "X-Agent-ID": agentId,
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify(profileUpdate),
-          });
-          console.log(`[${role}] Generated and saved default identity templates`);
-        } catch {
-          console.warn(`[${role}] Could not save generated templates to server`);
-        }
+        const profileUpdate: Record<string, string> = {};
+        if (!profile.soulMd) profileUpdate.soulMd = agentSoulMd;
+        if (!profile.identityMd) profileUpdate.identityMd = agentIdentityMd;
+        if (!profile.toolsMd) profileUpdate.toolsMd = agentToolsMd;
+        if (!profile.claudeMd && agentClaudeMd) profileUpdate.claudeMd = agentClaudeMd;
+        if (!profile.setupScript && agentSetupScript) profileUpdate.setupScript = agentSetupScript;
+        if (!profile.heartbeatMd && agentHeartbeatMd) profileUpdate.heartbeatMd = agentHeartbeatMd;
+
+        await saveGeneratedProfile({ apiUrl, apiKey, agentId, role, profileUpdate });
       }
 
       // Fetch installed MCP servers for system prompt

package/src/fs/agent-fs-provider.ts

@@ -66,6 +66,9 @@ export type AgentFsComment = {
 /** One entry of a file's `log`. */
 export type AgentFsFileVersion = { version: number; createdAt: string };
 
+/** One member of a drive (`drive-members`). */
+export type AgentFsDriveMember = { userId: string; email: string; displayName?: string | null };
+
 /** An agent-fs org and drive. */
 export type AgentFsDrive = { orgId: string; driveId: string };
 
@@ -300,6 +303,12 @@ export class AgentFsProvider implements FileStorageProvider {
     return Array.isArray(result?.versions) ? (result.versions as AgentFsFileVersion[]) : [];
   }
 
+  /** `drive-members`: the drive's members with their emails. Needs the agent-fs `drive-members` feature. */
+  async getDriveMembers(drive: AgentFsDrive): Promise<AgentFsDriveMember[]> {
+    const result = asRecord(await this.ops({ op: "drive-members" }, drive));
+    return Array.isArray(result?.members) ? (result.members as AgentFsDriveMember[]) : [];
+  }
+
   /** Reply to a root comment. The swarm service account is the author. */
   async replyToComment(
     drive: AgentFsDrive,

package/src/heartbeat/heartbeat.ts

@@ -76,7 +76,12 @@ import {
   REBOOT_RETRY_PIN_TAG,
   resolveLeadOnlyRecoveryAssignment,
 } from "../tasks/worker-follow-up";
-import { type AgentTask, SUPERSEDED_WORKFLOW_TASK_REASON, TERMINAL_TASK_STATUSES } from "../types";
+import {
+  type AgentTask,
+  OPEN_TASK_STATUSES,
+  SUPERSEDED_WORKFLOW_TASK_REASON,
+  TERMINAL_TASK_STATUSES,
+} from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
 import { DEFAULT_OPENROUTER_BASE_URL, getOpenRouterBaseUrl } from "../utils/openrouter-base-url";
@@ -1800,14 +1805,16 @@ export async function checkHeartbeatChecklist(): Promise<void> {
 
   if (isEffectivelyEmpty(heartbeatMd)) return;
 
-  // Dedup: skip if lead already has an active heartbeat-checklist task
+  // Dedup: skip if lead already has an active heartbeat-checklist task.
+  // Unary + keeps agentId/taskType off their indexes, so the seek runs on
+  // status over the few open tasks instead of every past checklist task.
   const existing = await getDbClient().get<{ id: string }>(
     `SELECT id FROM agent_tasks
-       WHERE agentId = ?
-         AND taskType = 'heartbeat-checklist'
-         AND status NOT IN (${TERMINAL_TASK_STATUSES.map(() => "?").join(", ")})
+       WHERE status IN (${OPEN_TASK_STATUSES.map(() => "?").join(", ")})
+         AND +agentId = ?
+         AND +taskType = 'heartbeat-checklist'
        LIMIT 1`,
-    [lead.id, ...TERMINAL_TASK_STATUSES],
+    [...OPEN_TASK_STATUSES, lead.id],
   );
   if (existing) return;
 

package/src/http/agents.ts

@@ -61,6 +61,7 @@ import {
   AgentCredStatusSchema,
   AgentLatestModelSchema,
   AgentSchema,
+  AgentSlackIconSchema,
   AgentStatusSchema,
   AgentWithTasksSchema,
   DeliveryModeSchema,
@@ -530,6 +531,11 @@ const updateAgentProfileRoute = route({
     heartbeatMd: z.string().max(MAX_PROFILE_FILE_LENGTH).optional(),
     /** `null` resets to the deterministic fallback; omit the key to leave untouched. */
     avatar: AgentAvatarSchema.nullable().optional(),
+    // z.lazy keeps `| null` in the OpenAPI body: a named schema's $ref drops it.
+    slackIcon: z
+      .lazy(() => AgentSlackIconSchema)
+      .nullable()
+      .optional(),
     changeSource: z.string().optional(),
     changedByAgentId: z.string().optional(),
     changeReason: z.string().optional(),
@@ -976,11 +982,12 @@ export async function handleAgentsRest(
       body.setupScript === undefined &&
       body.toolsMd === undefined &&
       body.heartbeatMd === undefined &&
-      body.avatar === undefined
+      body.avatar === undefined &&
+      body.slackIcon === undefined
     ) {
       jsonError(
         res,
-        "At least one field (role, description, capabilities, claudeMd, soulMd, identityMd, setupScript, toolsMd, heartbeatMd, or avatar) must be provided",
+        "At least one field (role, description, capabilities, claudeMd, soulMd, identityMd, setupScript, toolsMd, heartbeatMd, avatar, or slackIcon) must be provided",
         400,
       );
       return true;
@@ -1017,6 +1024,7 @@ export async function handleAgentsRest(
           // Only include the key when the client sent it, so `null` (reset)
           // is distinguishable from "not provided" (leave untouched).
           ...(body.avatar !== undefined ? { avatar: body.avatar } : {}),
+          ...(body.slackIcon !== undefined ? { slackIcon: body.slackIcon } : {}),
         },
         versionMeta,
         {

package/src/http/index.ts

@@ -15,8 +15,10 @@ import {
   getSwarmConfigs,
   upsertSwarmConfig,
 } from "../be/db";
+import { startTaskSearchBackfill, stopTaskSearchBackfill } from "../be/db/tasks/search-index";
 import { startDbRetention, stopDbRetention } from "../be/db-retention";
 import { startHumanFreeDrain, stopHumanFreeDrain } from "../be/human-free-drain";
+import { startMcpOverflowSweep, stopMcpOverflowSweep } from "../be/mcp-overflow-sweep";
 import {
   enqueueAuditRow,
   flushAuditBuffer,
@@ -528,6 +530,9 @@ async function shutdown() {
   // Stop the unified OAuth pending-session garbage collector (all flows)
   stopOAuthPendingGc();
 
+  // Stop the expired MCP overflow sweep
+  stopMcpOverflowSweep();
+
   // Stop memory expired-row garbage collector
   stopMemoryGc();
 
@@ -537,6 +542,9 @@ async function shutdown() {
   // Stop the human-free reclassification drain before closing SQLite.
   stopHumanFreeDrain();
 
+  // Stop the task search index backfill after its current batch.
+  await stopTaskSearchBackfill();
+
   // Stop scratch-script retention garbage collector
   stopScratchScriptGc();
 
@@ -866,6 +874,9 @@ httpServer
     // Start the unified OAuth pending-session garbage collector (5-min tick, all flows)
     startOAuthPendingGc();
 
+    // Delete expired MCP overflow values (10-min tick, off the spill path)
+    startMcpOverflowSweep();
+
     // Start expired-memory garbage collector (1-hour tick, immediate first run)
     await startMemoryGc();
 
@@ -877,6 +888,10 @@ httpServer
     // task tree, or a restart mid-drain). Wakes on demand; see human-free-drain.ts.
     startHumanFreeDrain();
 
+    // Index the task rows migration 256 left out, in batches. Task search
+    // stays on LIKE until it finishes. See src/be/db/tasks/search-index.ts.
+    void startTaskSearchBackfill();
+
     // (RBAC audit sink is wired pre-listen — see above httpServer.listen.)
 
     // Background embedding maintenance: re-embed every memory and script

package/src/http/integrations.ts

@@ -7,6 +7,7 @@ import {
   getChatSdkStatus,
   registerTelegramWebhook,
 } from "../integrations/chat-sdk/status";
+import { getSlackAppIconUrl } from "../slack/app-icon";
 import { buildSlackManifest } from "../slack/manifest";
 import { selectCredential } from "../utils/credentials";
 import { ensureHttpPermission } from "./config";
@@ -117,6 +118,20 @@ const slackManifestRoute = route({
   },
 });
 
+const slackAppIconRoute = route({
+  method: "get",
+  path: "/api/integrations/slack/app-icon",
+  pattern: ["api", "integrations", "slack", "app-icon"],
+  summary: "The Slack app's own avatar, shown on posts with no icon override",
+  tags: ["Integrations"],
+  responses: {
+    200: {
+      description: "`imageUrl` is null when Slack is off or the lookup fails.",
+      schema: z.object({ imageUrl: z.string().nullable() }),
+    },
+  },
+});
+
 const chatSdkStatusRoute = route({
   method: "get",
   path: "/api/integrations/chat/status",
@@ -176,6 +191,11 @@ export function createIntegrationsHandler(deps: TestConnectionDeps = {}) {
       return true;
     }
 
+    if (slackAppIconRoute.match(req.method, pathSegments)) {
+      slackAppIconRoute.respond(res, 200, { imageUrl: await getSlackAppIconUrl() });
+      return true;
+    }
+
     if (chatSdkStatusRoute.match(req.method, pathSegments)) {
       chatSdkStatusRoute.respond(res, 200, await getChatSdkStatus());
       return true;

package/src/http/list-total-cache.ts

@@ -0,0 +1,62 @@
+/**
+ * A 30-second cache of list `total`s, keyed by filter set.
+ *
+ * A list total is a COUNT over the same filters as the page, and on the large
+ * tables behind the sessions and task lists it costs as much as the page
+ * itself. Page 1 (offset 0) always counts, so a write (a new session, a
+ * triage move) shows at once where the user looks first. Later pages reuse
+ * that count for 30 s. A cold later page (deep link, expired entry) counts
+ * too, so `total` is always set.
+ */
+
+export const LIST_TOTAL_TTL_MS = 30_000;
+const MAX_ENTRIES = 500;
+
+interface Entry {
+  expiresAt: number;
+  total: Promise<number>;
+}
+
+export interface ListTotalCache {
+  get(
+    filters: Record<string, unknown>,
+    offset: number | undefined,
+    compute: () => Promise<number>,
+  ): Promise<number>;
+}
+
+/** Stable key: sorted object keys, `undefined` fields dropped. */
+function filterKey(value: unknown): string {
+  return JSON.stringify(value, (_key, v) =>
+    v && typeof v === "object" && !Array.isArray(v)
+      ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b)))
+      : v,
+  );
+}
+
+export function createListTotalCache(ttlMs = LIST_TOTAL_TTL_MS): ListTotalCache {
+  const entries = new Map<string, Entry>();
+  return {
+    get(filters, offset, compute) {
+      const key = filterKey(filters);
+      const now = Date.now();
+      const hit = entries.get(key);
+      if (hit && hit.expiresAt > now && (offset ?? 0) > 0) return hit.total;
+      if (hit) entries.delete(key);
+
+      // Cache the promise, so a later page that arrives mid-count shares it.
+      const total = compute();
+      entries.set(key, { expiresAt: now + ttlMs, total });
+      total.catch(() => {
+        if (entries.get(key)?.total === total) entries.delete(key);
+      });
+      // Map iterates in insertion order, so the first key is the oldest.
+      while (entries.size > MAX_ENTRIES) {
+        const oldest = entries.keys().next().value;
+        if (oldest === undefined) break;
+        entries.delete(oldest);
+      }
+      return total;
+    },
+  };
+}

package/src/http/sessions.ts

@@ -75,6 +75,7 @@ import {
 import { getRequestAuth } from "../utils/request-auth-context";
 import { isRuntimePoolsEnabled } from "../utils/runtime-pools-flag";
 import { canMutateTaskNamespace } from "./assets";
+import { createListTotalCache } from "./list-total-cache";
 import { agentFirstPrincipal, authUserId, requireAuthKind } from "./request-principal";
 import { route } from "./route-def";
 import {
@@ -538,6 +539,8 @@ const SessionShowSourceSchema = z
     "Comma-separated root sources to keep (the sessions v2 source filter), e.g. `ui,slack`. Present and empty keeps none; omit to keep every source.",
   );
 
+const sessionTotals = createListTotalCache();
+
 const listSessions = route({
   method: "get",
   path: "/api/sessions",
@@ -1017,8 +1020,12 @@ export async function handleSessions(
         ? await listRecentSessions(baseOpts)
         : await listRecentSessions({ ...baseOpts, slim: true });
     // Filter-aware total: same WHERE as the list query, so the UI pager
-    // reflects the filtered result set.
-    const total = await countSessions(filterOpts);
+    // reflects the filtered result set. Page 1 counts; later pages reuse it
+    // for 30 s (keyed without the request clock).
+    const { now: _now, ...totalKey } = filterOpts;
+    const total = await sessionTotals.get(totalKey, parsed.query.offset, () =>
+      countSessions(filterOpts),
+    );
     listSessions.respond(res, 200, {
       sessions,
       total,

package/src/http/slack-inbound.ts

@@ -22,6 +22,7 @@ const OutcomeCountersSchema = z.object({
   ignored: z.number(),
   failed: z.number(),
   uncertain: z.number(),
+  ackNotReady: z.number(),
   lastOutcomeAt: z.string().nullable(),
   lastFailure: FailureSchema,
 });

package/src/http/status.ts

@@ -134,6 +134,8 @@ export type StatusActivity = z.infer<typeof StatusActivitySchema>;
 
 export const StatusCombSchema = z.object({
   enabled: z.boolean(),
+  /** What is missing when Comb is off (for example no browser-reachable agent-fs URL). Null when on. */
+  reason: z.string().nullable(),
   api_url: z.string().nullable(),
   live_url: z.string(),
   org_id: z.string().nullable(),
@@ -777,6 +779,7 @@ function getCombStatus(serviceUserId: string | null): StatusAgentFs["comb"] {
   const comb = getCombConfig();
   return {
     enabled: comb.enabled,
+    reason: comb.reason,
     api_url: comb.apiUrl,
     live_url: comb.liveUrl,
     org_id: comb.orgId,
@@ -811,7 +814,7 @@ const getStatus = route({
   pattern: ["status"],
   summary: "Identity + setup readiness + live activity for the swarm dashboard",
   description:
-    "Single source of truth consumed by the UI home page. Identity comes from SWARM_* envs; setup milestones each emit `unverified | configured | verified`; automations report `running | needs_setup` from the same runtime preflight used at dispatch; activity counts agents alive in the last 5 min, leads that can take work (status idle or busy), and tasks created in the last 24h; agent_fs reports whether AGENT_FS_API_URL is set, plus the Comb settings (COMB_ENABLED, the browser-facing agent-fs URL, the shared org and drive ids, and the agent-fs user id of the swarm service account); telemetry reports the effective ANONYMIZED_TELEMETRY opt-out state.",
+    "Single source of truth consumed by the UI home page. Identity comes from SWARM_* envs; setup milestones each emit `unverified | configured | verified`; automations report `running | needs_setup` from the same runtime preflight used at dispatch; activity counts agents alive in the last 5 min, leads that can take work (status idle or busy), and tasks created in the last 24h; agent_fs reports whether AGENT_FS_API_URL is set, plus the Comb settings (whether Files is on and, when off, what is missing; the browser-facing agent-fs URL, the shared org and drive ids, and the agent-fs user id of the swarm service account); telemetry reports the effective ANONYMIZED_TELEMETRY opt-out state.",
   tags: ["Status"],
   responses: {
     200: { description: "Status payload", schema: StatusResponseSchema },

package/src/http/tasks.ts

@@ -84,6 +84,7 @@ import {
 import { ensure } from "../utils/business-use";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
+import { createListTotalCache } from "./list-total-cache";
 import {
   agentFirstPrincipal,
   authUserId,
@@ -223,6 +224,8 @@ const SupersedeTaskResponseSchema = z.object({
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
+const taskTotals = createListTotalCache();
+
 const listTasks = route({
   method: "get",
   path: "/api/tasks",
@@ -240,7 +243,12 @@ const listTasks = route({
     workflowRunId: z.string().uuid().optional(),
     key: AssetKeySchema.optional(),
     keyPrefix: AssetKeySchema.optional(),
-    search: z.string().optional(),
+    search: z
+      .string()
+      .optional()
+      .describe(
+        "Search task text and title by word or phrase, with a prefix match on the last word, or a task id by prefix. Not a substring match: '2443' does not find '12443', and '%' and '_' are not wildcards.",
+      ),
     includeHeartbeat: z.enum(["true", "false"]).optional(),
     /** ISO 8601 — return only tasks created on/after this timestamp. */
     createdAfter: z.string().datetime().optional(),
@@ -1015,8 +1023,10 @@ export async function handleTasks(
           ? await getAllTasks(filters, { fields: "timeline" })
           : await getAllTasks(filters, { slim: true });
     // The COUNT(*) re-scans every matching row, so only pagers pay for it.
+    // Page 1 counts; later pages reuse that count for 30 s.
     if (parsed.query.includeTotal === "true") {
-      const total = await getTasksCount(filters);
+      const { limit: _limit, offset: _offset, orderBy: _orderBy, ...totalKey } = filters;
+      const total = await taskTotals.get(totalKey, filters.offset, () => getTasksCount(filters));
       listTasks.respond(res, 200, { tasks, total });
     } else {
       listTasks.respond(res, 200, { tasks });

package/src/providers/amp-adapter.ts

@@ -45,7 +45,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1793104576-gc52692";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1793160055-gbd79f2";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/cursor-adapter.ts

@@ -35,7 +35,7 @@ import type {
 } from "./types";
 
 /** Pinned in package.json and Dockerfile.worker; bump all three together. */
-export const CURSOR_SDK_VERSION = "1.1.0";
+export const CURSOR_SDK_VERSION = "1.2.0";
 
 /** MCP server name; Cursor reports its tools as `mcp` calls with this `providerIdentifier`. */
 const CURSOR_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/dsh-adapter.ts

@@ -37,7 +37,7 @@ import type {
 } from "./types";
 
 // npm's `latest` is older and lacks the JSON/stdin contract used here.
-export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.1-rc.4";
+export const DSH_PACKAGE = "@deepseek-ai/dsh@0.2.2-alpha.2";
 
 export function checkDshCredentials(env: Record<string, string | undefined>): CredStatus {
   return env.DEEPSEEK_API_KEY?.trim() || env.OPENROUTER_API_KEY?.trim()

package/src/queue-stall-alarm.ts

@@ -86,12 +86,15 @@ export async function getQueueStallSnapshot(now = new Date()): Promise<QueueStal
   );
 
   const pickupCutoff = new Date(now.getTime() - QUEUE_STALL_THRESHOLD_MS).toISOString();
+  // Unary + keeps eventType off idx_agent_log_eventType, so the short
+  // createdAt window drives through idx_agent_log_createdAt instead of every
+  // status-change row ever logged.
   const recentPickupCount =
     (
       await getDbClient().get<{ count: number }>(
         `SELECT COUNT(*) AS count
          FROM agent_log
-         WHERE eventType IN ('task_status_change', 'task_claimed')
+         WHERE +eventType IN ('task_status_change', 'task_claimed')
            AND oldValue IN ('pending', 'unassigned')
            AND newValue = 'in_progress'
            AND createdAt >= ?`,

package/src/slack/actions.ts

@@ -8,7 +8,7 @@ import { resolveSlackUserId } from "./enrich";
 import { EXTERNAL_CHANNEL_BLOCKED_REPLY, shouldBlockChannel } from "./external-channel";
 import { ignoreSlackInbound, noteSlackInboundSideEffect } from "./inbound-dispatch";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
-import { getAgentDisplayName, getAgentEmoji } from "./responses";
+import { getAgentDisplayName, getAgentSlackIcon } from "./responses";
 
 type ChatUpdatePayload = ChatUpdateArguments & {
   unfurl_links: false;
@@ -153,7 +153,7 @@ export function registerActionHandlers(app: App): void {
         text: `💬 Follow-up sent to *${agentName}* (${taskLink})`,
         unfurl_links: false,
         unfurl_media: false,
-        ...(lead ? { username: getAgentDisplayName(lead), icon_emoji: getAgentEmoji(lead) } : {}),
+        ...(lead ? { username: getAgentDisplayName(lead), ...getAgentSlackIcon(lead) } : {}),
       });
     } catch (error) {
       console.error("[Slack] Failed to post follow-up confirmation:", error);

package/src/slack/app-icon.ts

@@ -0,0 +1,50 @@
+import { WebClient } from "@slack/web-api";
+import { getSlackApp } from "./app";
+
+const TTL_MS = 60 * 60 * 1000;
+// Per request, with no retries: the lookup ends within two of these, and an
+// aborted auth.test never goes on to bots.info.
+const REQUEST_TIMEOUT_MS = 2_500;
+
+// Keyed by token and API URL, so a reconfigured Slack app is looked up again.
+let cached: { key: string; url: string | null; at: number } | null = null;
+let inFlight: { key: string; promise: Promise<string | null> } | null = null;
+
+async function lookUp(client: WebClient): Promise<string | null> {
+  const auth = await client.auth.test();
+  if (!auth.bot_id) return null;
+  const info = await client.bots.info({ bot: auth.bot_id });
+  const icons = info.bot?.icons;
+  return icons?.image_72 ?? icons?.image_48 ?? icons?.image_36 ?? null;
+}
+
+/**
+ * The avatar Slack shows for this app's posts when no icon is overridden
+ * (`bots.info` for the bot behind the token). Null when Slack is off or the
+ * lookup fails. Cached for an hour; failures are not cached.
+ */
+export async function getSlackAppIconUrl(): Promise<string | null> {
+  // Slack can be turned off at runtime, so check it before the cache.
+  const app = getSlackApp()?.client;
+  if (!app?.token) return null;
+  const key = `${app.slackApiUrl} ${app.token}`;
+  if (cached?.key === key && Date.now() - cached.at < TTL_MS) return cached.url;
+  if (inFlight?.key === key) return await inFlight.promise;
+  const client = new WebClient(app.token, {
+    slackApiUrl: app.slackApiUrl,
+    retryConfig: { retries: 0 },
+    rejectRateLimitedCalls: true,
+    timeout: REQUEST_TIMEOUT_MS,
+  });
+  const promise: Promise<string | null> = lookUp(client)
+    .then((url) => {
+      cached = { key, url, at: Date.now() };
+      return url;
+    })
+    .catch(() => null)
+    .finally(() => {
+      if (inFlight?.promise === promise) inFlight = null;
+    });
+  inFlight = { key, promise };
+  return await promise;
+}

package/src/slack/app.ts

@@ -5,13 +5,15 @@ import { getSlackConfiguration } from "./config";
 import { type SlackConnectionState, setSlackConnectionState } from "./connection-state";
 import { installSlackEgressScrub } from "./egress-scrub";
 import { installSlackExternalChannelGuard } from "./external-channel-egress";
-import { slackInboundOutcomeMiddleware } from "./inbound-dispatch";
+import { recoverSlackInboundAfterRestart, slackInboundOutcomeMiddleware } from "./inbound-dispatch";
+import { installSocketAckRecovery } from "./socket-ack";
 import { getSlackSocketModeBlockReason, SLACK_DEV_SOCKET_MODE_OPT_IN } from "./socket-mode-guard";
 import { startTaskWatcher, stopTaskWatcher } from "./watcher";
 
 let app: App | null = null;
 let receiver: SocketModeReceiver | null = null;
 let initialized = false;
+let inboundDrain: ReturnType<typeof installSocketAckRecovery> | null = null;
 
 const SOCKET_EVENT_STATES: Record<string, SlackConnectionState> = {
   connecting: "connecting",
@@ -105,6 +107,10 @@ export async function initSlackApp(): Promise<App | null> {
     ...(clientOptions ? { clientOptions } : {}),
   });
 
+  // Events whose Socket Mode ack failed are stored as receipts; the drain hands
+  // them back to Bolt, so a crash or a failing listener leaves recoverable work.
+  inboundDrain = installSocketAckRecovery(receiver.client, app);
+
   // Failed validation must remain retryable without requiring stopSlackApp().
   initialized = true;
 
@@ -147,8 +153,12 @@ export async function startSlackApp(): Promise<boolean> {
     // Establish the durable cutoff before Socket Mode can deliver new asks.
     const { isSlackRenderV2Enabled } = await import("./render-v2");
     if (isSlackRenderV2Enabled()) await ensureSlackRenderV2Activation();
+    // Receipts stored before the last restart: interrupted ones turn uncertain,
+    // pending ones are processed once the app can dispatch them.
+    await recoverSlackInboundAfterRestart();
     await app.start();
     console.log("[Slack] Bot connected via Socket Mode");
+    void inboundDrain?.wake();
     await emitBuiltInIntegrationConnectedOnce("slack");
 
     // Start watching for task completions
@@ -161,6 +171,8 @@ export async function startSlackApp(): Promise<boolean> {
 
 export async function stopSlackApp(): Promise<void> {
   stopTaskWatcher();
+  inboundDrain?.stop();
+  inboundDrain = null;
 
   if (app) {
     await app.stop();

package/src/slack/assistant.ts

@@ -46,9 +46,24 @@ async function isExternalAssistantThread(
   return true;
 }
 
-export function createAssistant(): Assistant {
+type ThreadContextStore = NonNullable<
+  ConstructorParameters<typeof Assistant>[0]["threadContextStore"]
+>;
+
+/** `threadContextStore` replaces Bolt's metadata-backed default, which calls the Slack API. */
+export function createAssistant(
+  options: { threadContextStore?: ThreadContextStore } = {},
+): Assistant {
   return new Assistant({
+    ...(options.threadContextStore ? { threadContextStore: options.threadContextStore } : {}),
     threadStarted: async ({ event, body, client, say, setSuggestedPrompts, saveThreadContext }) => {
+      // The greeting is not idempotent: a redelivery after a tolerated socket ack
+      // failure must not post it twice.
+      const eventId = body?.event_id;
+      if (!isAdmittedSlackDelivery() && wasEventSeen(eventId)) {
+        console.log(`[Slack] dropping Slack retry: event_id=${eventId}`);
+        return ignoreSlackInbound("duplicate_event");
+      }
       if (await isExternalAssistantThread(client, event.assistant_thread.channel_id, body)) {
         return ignoreSlackInbound("external_channel");
       }
@@ -75,6 +90,12 @@ export function createAssistant(): Assistant {
     },
 
     threadContextChanged: async ({ event, body, client, saveThreadContext }) => {
+      // Saves are order-dependent: a stale redelivery would overwrite newer context.
+      const eventId = body?.event_id;
+      if (!isAdmittedSlackDelivery() && wasEventSeen(eventId)) {
+        console.log(`[Slack] dropping Slack retry: event_id=${eventId}`);
+        return ignoreSlackInbound("duplicate_event");
+      }
       if (await isExternalAssistantThread(client, event.assistant_thread.channel_id, body)) {
         return ignoreSlackInbound("external_channel");
       }