@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/providers/codex-adapter.ts

@@ -30,13 +30,22 @@
 
 import { existsSync as nodeExistsSync } from "node:fs";
 import { join } from "node:path";
+import {
+  CODEX_GATEWAY_API_KEY,
+  deriveDefaultRoute,
+  type ModelRoute,
+  routeCredentialStatus,
+  routeUnsetEnv,
+} from "@desplega/model-routing";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { getApiKey } from "../utils/api-key";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
   computeContextUsedUnified,
 } from "../utils/context-window";
+import { selectCredential } from "../utils/credentials";
 import { isEnvFlagEnabled, isSessionSummarySkipped } from "../utils/env-flag";
 import { SessionErrorTracker } from "../utils/error-tracker";
 import { summarizeSession as runSummarize } from "../utils/internal-ai";
@@ -81,6 +90,32 @@ import type {
 
 type CodexConfig = Record<string, CodexConfigValue | undefined>;
 
+/** `model_provider` id of the generated gateway block. */
+const CODEX_GATEWAY_PROVIDER_ID = "swarm-gateway";
+
+/**
+ * Config overrides that send Codex through the gateway route. Codex 0.164
+ * ignores `OPENAI_BASE_URL` and env keys for its built-in `openai` provider, so
+ * the gateway needs its own provider block. Verified on 0.164 against a local
+ * gateway: Codex sends `Authorization: Bearer $CODEX_GATEWAY_API_KEY` to
+ * `<base_url>/responses` and never the auth.json OAuth token. `wire_api`
+ * defaults to `responses` (`chat` is rejected); it is set to state intent.
+ */
+export function codexGatewayConfig(route: ModelRoute): CodexConfig {
+  return {
+    model_provider: CODEX_GATEWAY_PROVIDER_ID,
+    model_providers: {
+      [CODEX_GATEWAY_PROVIDER_ID]: {
+        name: "Swarm gateway",
+        base_url: route.baseUrl,
+        env_key: CODEX_GATEWAY_API_KEY,
+        wire_api: "responses",
+        requires_openai_auth: false,
+      },
+    },
+  };
+}
+
 /** Plugin id the worker image installs (`codex plugin add context-mode@context-mode`). */
 const CONTEXT_MODE_CODEX_PLUGIN = "context-mode@context-mode";
 
@@ -186,7 +221,10 @@ export type CodexThreadFactory = (options: {
 }) => Promise<CodexThread> | CodexThread;
 
 /**
- * Codex satisfies its credential requirement by ANY of:
+ * A gateway route (`CODEX_GATEWAY_BASE_URL` + `CODEX_GATEWAY_API_KEY`) wins
+ * and alone decides readiness: a gateway URL without its key is not ready,
+ * whatever OAuth or auth.json is present. Otherwise Codex satisfies its
+ * credential requirement by ANY of:
  *   1. `~/.codex/auth.json` already exists on disk (the canonical state once
  *      `codex login` has run).
  *   2. `OPENAI_API_KEY` is set — the entrypoint will run
@@ -203,6 +241,13 @@ export function checkCodexCredentials(
   env: Record<string, string | undefined>,
   opts: CredCheckOptions = {},
 ): CredStatus {
+  const gateway = deriveDefaultRoute("codex", env);
+  if (gateway) {
+    const status = routeCredentialStatus(gateway, env);
+    return status.ready
+      ? { ready: true, missing: [], satisfiedBy: "env", hint: status.hint }
+      : { ready: false, missing: status.missing, hint: status.hint };
+  }
   const homeDir = opts.homeDir ?? env.HOME ?? "/root";
   const existsSync = opts.fs?.existsSync ?? nodeExistsSync;
   const authFile = `${homeDir}/.codex/auth.json`;
@@ -995,6 +1040,8 @@ export class CodexSession implements ProviderSession {
    * summary path which materially relies on this ordering for testability.
    */
   private pendingResult: ProviderResult | null = null;
+  /** Fed each main-thread request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     thread: CodexThread,
@@ -1015,6 +1062,13 @@ export class CodexSession implements ProviderSession {
       skillsDir ?? process.env.CODEX_SKILLS_DIR ?? join(codexUserHome(), ".codex", "skills");
     this.summarizeDeps = summarizeDeps;
     this.logFileHandle = Bun.file(config.logFile).writer();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.resolvedModel,
+      // `turn/steer` only joins the active turn, so a late note never starts one.
+      canDeliver: () => this.acceptsSteering && !this.settled && !this.aborted,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
     // Mirrors the resolution `buildCodexConfig` already applied when
     // constructing `mergedConfig` — cheap, pure, and keeps the applied-level
     // feedback co-located with `settle()` rather than threading an extra
@@ -1425,6 +1479,8 @@ export class CodexSession implements ProviderSession {
         break;
       case "context.updated":
         this.emitContextUsage(event.usage, event.contextWindow ?? this.contextWindow);
+        // Codex input tokens already include the cached read and write subsets.
+        void this.observeContextBound(event.usage.input_tokens);
         break;
       case "error": {
         const { message } = this.formatTerminalError(event.message, event.codexErrorInfo);
@@ -1953,14 +2009,21 @@ export async function createInProcessCodexSession(
     preSessionEvents.push(event);
   };
 
-  const mergedConfig = await buildCodexConfig(config, resolvedModel, bufferedEmit);
+  const routeEnv = config.env ?? process.env;
+  const gateway = deriveDefaultRoute("codex", routeEnv);
+  const mergedConfig = {
+    ...(await buildCodexConfig(config, resolvedModel, bufferedEmit)),
+    ...(gateway ? codexGatewayConfig(gateway) : {}),
+  };
 
   // Auth resolution. `codex_oauth` (in the swarm config store) wins over
   // `OPENAI_API_KEY` so users can keep an OpenAI key set for embeddings
   // without it shadowing their ChatGPT login. The entrypoint already runs
   // this same precedence at boot — this block handles local dev (where
   // the entrypoint didn't run) and any case where auth.json is stale.
-  const authMode = await resolveCodexAuthMode(config, bufferedEmit);
+  // A gateway route skips it: no OAuth is restored for a session whose traffic
+  // goes to the gateway.
+  const authMode = gateway ? null : await resolveCodexAuthMode(config, bufferedEmit);
 
   // The app-server receives an explicit environment. Construct a
   // minimal env explicitly so the spawned Codex CLI can find its binary
@@ -1987,7 +2050,14 @@ export async function createInProcessCodexSession(
     ...buildOtelTraceparentEnv(config.env ?? process.env),
     SWARM_CODEX_APP_SERVER: "1",
   };
-  if (authMode === "chatgpt") delete env.OPENAI_API_KEY;
+  if (gateway) {
+    for (const key of routeUnsetEnv("codex", gateway)) delete env[key];
+    const gatewayKey = routeEnv[CODEX_GATEWAY_API_KEY];
+    if (gatewayKey) env[CODEX_GATEWAY_API_KEY] = gatewayKey;
+  } else if (authMode === "chatgpt") delete env.OPENAI_API_KEY;
+  else if (env.OPENAI_API_KEY) {
+    env.OPENAI_API_KEY = selectCredential(env.OPENAI_API_KEY, undefined, "OPENAI_API_KEY").selected;
+  }
 
   const codexPathOverride = process.env.CODEX_PATH_OVERRIDE;
 
@@ -2139,6 +2209,11 @@ class CodexSubprocessSession implements ProviderSession {
     };
 
     const apiKey = getApiKey();
+    const providerKeys: Record<string, string> = {};
+    for (const keyVar of ["OPENAI_API_KEY", "OPENROUTER_API_KEY", "ANTHROPIC_API_KEY"]) {
+      const value = config.env?.[keyVar] ?? process.env[keyVar];
+      if (value) providerKeys[keyVar] = selectCredential(value, undefined, keyVar).selected;
+    }
 
     this.proc = registerProcessGroup(
       Bun.spawn(argv, {
@@ -2156,13 +2231,7 @@ class CodexSubprocessSession implements ProviderSession {
           ...(process.env.MCP_BASE_URL ? { MCP_BASE_URL: process.env.MCP_BASE_URL } : {}),
           ...(apiKey ? { AGENT_SWARM_API_KEY: apiKey, API_KEY: apiKey } : {}),
           // Embedding / summarization paths read these:
-          ...(process.env.OPENAI_API_KEY ? { OPENAI_API_KEY: process.env.OPENAI_API_KEY } : {}),
-          ...(process.env.OPENROUTER_API_KEY
-            ? { OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY }
-            : {}),
-          ...(process.env.ANTHROPIC_API_KEY
-            ? { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY }
-            : {}),
+          ...providerKeys,
           ...(process.env.CODEX_PATH_OVERRIDE
             ? { CODEX_PATH_OVERRIDE: process.env.CODEX_PATH_OVERRIDE }
             : {}),
@@ -2463,6 +2532,9 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   async createSession(config: ProviderSessionConfig): Promise<ProviderSession> {
+    if (deriveDefaultRoute("codex", config.env ?? process.env)) {
+      console.log("\x1b[2m[codex]\x1b[0m Using credential: gateway");
+    }
     if (this.bypassSubprocess) {
       return createInProcessCodexSession(config, {
         skillsDir: this.skillsDir,

package/src/providers/opencode-adapter.ts

@@ -21,6 +21,7 @@ import {
   providerKeyVars,
 } from "@desplega/model-catalog";
 import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
@@ -534,6 +535,8 @@ export class OpencodeSession implements ProviderSession {
   // Assistant text by message, in part order; the runner keeps the last emit.
   private textByMessage = new Map<string, string[]>();
   private transcript: string[] = [];
+  /** Fed each step's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
 
   constructor(
     private readonly host: OpenCode.Interface,
@@ -547,6 +550,20 @@ export class OpencodeSession implements ProviderSession {
     this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.completionResolve = resolve;
     });
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(swarm.env ?? process.env),
+      model: () => this.model,
+      canDeliver: () => !this.completed && !this.aborted,
+      // A steer is promoted at the next step boundary mid-work; `resume: false`
+      // leaves an idle session idle. Same route as OpenCode's own Plan reminder.
+      inject: (note) =>
+        host.sessions.synthetic({
+          sessionID: _sessionId,
+          text: note,
+          delivery: "steer",
+          resume: false,
+        }),
+    });
   }
 
   get sessionId(): string {
@@ -685,6 +702,7 @@ export class OpencodeSession implements ProviderSession {
         // Per-step usage drives the dashboard's context gauge.
         const t = ev.data.tokens;
         const contextUsed = t.input + t.cache.read + t.cache.write + t.output;
+        void this.observeContextBound(t.input + t.cache.read + t.cache.write);
         const contextTotal = getContextWindowSize(this.model || "default");
         if (contextTotal > 0 && contextUsed > 0) {
           this.emit({

package/src/providers/pi-mono-adapter.ts

@@ -61,6 +61,7 @@ import { type TSchema, Type } from "typebox";
 import "./pi-codemode-runtime";
 // Registers the reprompt template in the code registry (the runner loads it too).
 import "../commands/templates";
+import { contextBoundNoteThreshold, createContextBoundNote } from "../hooks/context-bound-note";
 import { resolveTemplateAsync } from "../prompts/resolver";
 import { CORE_TOOLS } from "../tools/tool-config";
 import { classifyAwsSdkError } from "../utils/aws-error-classifier";
@@ -907,6 +908,17 @@ function safeLabel(value: unknown): string {
   return typeof value === "string" && /^[A-Za-z0-9_-]{1,32}$/.test(value) ? value : "other";
 }
 
+/** Prompt size of the request behind an assistant message: input + cache read + cache write. */
+function requestContextTokens(message: unknown): number | undefined {
+  const usage = (
+    message as { usage?: { input?: unknown; cacheRead?: unknown; cacheWrite?: unknown } }
+  )?.usage;
+  if (typeof usage?.input !== "number") return undefined;
+  const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
+  const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0;
+  return usage.input + cacheRead + cacheWrite;
+}
+
 function describeAssistantTurn(message: unknown): AssistantTurnShape {
   const msg = (message ?? {}) as {
     content?: unknown;
@@ -1008,6 +1020,14 @@ export class PiMonoSession implements ProviderSession {
   private abortRequested = false;
   /** Removes this session's own models.json once the session ends. */
   private disposeModels: () => Promise<void>;
+  /** Fed each assistant request's prompt size; steers the one-time context-bound note. */
+  private readonly observeContextBound: (contextTokens: number | undefined) => Promise<void>;
+  /**
+   * From a tool-call reply until its turn ends. Pi reads steering after the
+   * turn's tool results; a steer queued later waits for the next reply, and
+   * when that is the final one it starts another turn.
+   */
+  private toolTurnOpen = false;
 
   constructor(
     agentSession: AgentSession,
@@ -1024,6 +1044,12 @@ export class PiMonoSession implements ProviderSession {
     this.logFileHandle = Bun.file(config.logFile).writer();
     this._sessionId = agentSession.sessionId;
     this.sessionStartedAt = Date.now();
+    this.observeContextBound = createContextBoundNote({
+      threshold: contextBoundNoteThreshold(config.env ?? process.env),
+      model: () => this.reportedModel(),
+      canDeliver: () => this.toolTurnOpen && !this.sessionEnded && !this.abortRequested,
+      inject: (note) => this.deliverSteering({ mode: "steer", text: note }),
+    });
 
     // Emit session_init immediately
     const piVersion = readPkgVersion("@earendil-works/pi-coding-agent");
@@ -1098,6 +1124,12 @@ export class PiMonoSession implements ProviderSession {
           }
           // A successful assistant turn means any prior error has recovered.
           this.terminalError = null;
+          // Only on tool-call turns: a steer after the final reply would start
+          // another turn.
+          if (turn.hasToolCall) {
+            this.toolTurnOpen = true;
+            void this.observeContextBound(requestContextTokens(event.message));
+          }
           if (!turn.hasText && !turn.hasToolCall) {
             // Nothing else records these turns: no text and no tool call leaves
             // no trace in session logs. Block types only, never content.
@@ -1152,6 +1184,9 @@ export class PiMonoSession implements ProviderSession {
         }
         break;
       }
+      case "turn_end":
+        this.toolTurnOpen = false;
+        break;
       case "tool_execution_start": {
         const status = (event.args as { status?: unknown } | null)?.status;
         if (

package/src/runtime-providers/docker.ts

@@ -177,7 +177,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
       try {
         await dockerApi(target, "POST", `/containers/${created.Id}/start`);
       } catch (err) {
-        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true`).catch(() => {});
+        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true&v=true`).catch(
+          () => {},
+        );
         throw err;
       }
       return { kind: "docker", externalId: created.Id };
@@ -188,7 +190,9 @@ export class DockerRuntimeProvider implements RuntimeProvider {
 
   async terminate(target: RuntimeTargetConfig, handle: RuntimeHandle): Promise<void> {
     try {
-      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true`);
+      // v=true also removes the container's anonymous volumes (the worker image declares
+      // VOLUME /logs); named volumes are never removed by it.
+      await dockerApi(target, "DELETE", `/containers/${handle.externalId}?force=true&v=true`);
     } catch (err) {
       if (!(err instanceof DockerApiError) || err.statusCode !== 404) throw err;
     }

package/src/scheduler/scheduler.ts

@@ -91,8 +91,9 @@ async function executeScheduleScript(schedule: ScheduledTask): Promise<void> {
     agentId,
     scriptName: schedule.scriptName,
     // A pointer, not a copy: script schedules fire as often as every minute and
-    // script_runs has no retention sweep, so copying the source on every fire
-    // would grow the table by tens of MB a day. script_versions keeps the text.
+    // script_runs retention (SCRIPT_RUNS_RETENTION_DAYS) is off by default, so
+    // copying the source on every fire would grow the table by tens of MB a
+    // day. script_versions keeps the text.
     source: `// Scheduled run of '${script.name}' v${script.version} (global, contentHash ${script.contentHash}) by schedule '${schedule.name}'.\n// Full source: script_versions row for this version.\n`,
     args,
     startedAt: new Date().toISOString(),

package/src/scripts-runtime/swarm-sdk.ts

@@ -319,7 +319,13 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
     case "workflow_getRun": {
       const id = typeof body.id === "string" ? body.id : undefined;
       if (!id) throw new Error("workflow_getRun requires string `id`");
-      return { method: "GET", path: `/api/workflow-runs/${encodeURIComponent(id)}` };
+      if (body.fields !== undefined && body.fields !== "full" && body.fields !== "slim") {
+        throw new Error('workflow_getRun `fields` must be "full" or "slim"');
+      }
+      return {
+        method: "GET",
+        path: appendQuery(`/api/workflow-runs/${encodeURIComponent(id)}`, { fields: body.fields }),
+      };
     }
     case "workflow_delete": {
       const id = typeof body.id === "string" ? body.id : undefined;

package/src/scripts-runtime/types/stdlib.d.ts

@@ -378,7 +378,7 @@ declare module "swarm-sdk" {
       limit?: number;
       offset?: number;
     }): Promise<unknown>;
-    workflow_getRun(args: { id: string }): Promise<unknown>;
+    workflow_getRun(args: { id: string; fields?: "full" | "slim" }): Promise<unknown>;
     // --- prompt templates ---
     prompt_list(args?: {
       eventType?: string;

package/src/scripts-runtime/types/swarm-extension.d.ts

@@ -9,16 +9,16 @@ declare module "swarm-extension" {
       | "schedule"
       | "slack"
       | "agentmail"
-      | "mcp"
-      | "api"
-      | "ui"
       | "github"
       | "gitlab"
       | "azure-devops"
       | "bitbucket"
-      | "system"
       | "linear"
       | "jira"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "system"
       | "comb"
       | "chat"
       | undefined;
@@ -127,16 +127,16 @@ declare module "swarm-extension" {
       | "schedule"
       | "slack"
       | "agentmail"
-      | "mcp"
-      | "api"
-      | "ui"
       | "github"
       | "gitlab"
       | "azure-devops"
       | "bitbucket"
-      | "system"
       | "linear"
       | "jira"
+      | "mcp"
+      | "api"
+      | "ui"
+      | "system"
       | "comb"
       | "chat";
     tags: string[];
@@ -401,6 +401,45 @@ declare module "swarm-extension" {
     description: string;
     origin: TaskCreateOrigin;
     requestInfo?: RequestInfo;
+    /** Slack ingress metadata; not persisted or writable through modify. */
+    slack?: {
+      trigger: "mention" | "thread-buffer";
+      messages: {
+        ts: string;
+        userId: string;
+        text: string;
+      }[];
+    };
+  }
+  /** A pre.task.create hook blocked a task before it was created. */
+  export interface TaskBlockedEvent {
+    /** The extension that blocked, or whose model/agent rewrite was rejected. */
+    extension: {
+      id: string;
+      name: string;
+    };
+    /** The scrubbed block reason. */
+    reason: string;
+    origin: TaskCreateOrigin;
+    source?: AgentTask["source"];
+    requester: {
+      userId?: string;
+      agentId?: string;
+      slackUserId?: string;
+    };
+    context?: {
+      contextKey?: string;
+      scheduleId?: string;
+      workflowRunId?: string;
+      workflowRunStepId?: string;
+      parentTaskId?: string;
+      vcsRepo?: string;
+      vcsNumber?: number;
+      slackChannelId?: string;
+      slackThreadTs?: string;
+    };
+    /** The original task description, scrubbed and cut to 500 characters. */
+    description: string;
   }
   export type TaskCreateModify = Partial<
     Pick<
@@ -704,6 +743,11 @@ declare module "swarm-extension" {
       modify: never;
       result: void;
     };
+    "post.task.blocked": {
+      event: TaskBlockedEvent;
+      modify: never;
+      result: void;
+    };
     "post.task.completed": {
       event: TaskCompletedEvent;
       modify: never;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -360,7 +360,7 @@ declare module "swarm-sdk" {
       limit?: number;
       offset?: number;
     }): Promise<unknown>;
-    workflow_getRun(args: { id: string }): Promise<unknown>;
+    workflow_getRun(args: { id: string; fields?: "full" | "slim" }): Promise<unknown>;
     // --- prompt templates ---
     prompt_list(args?: {
       eventType?: string;

package/src/slack/assistant.ts

@@ -213,6 +213,10 @@ export function createAssistant(): Assistant {
           buildEffectiveText(messageText, inbound.files, inbound.failed, inbound.notes),
           cachedBotUserId ?? undefined,
         );
+        const slack = {
+          trigger: "mention" as const,
+          messages: [{ ts: message.ts, userId, text: messageText }],
+        };
 
         if (workingAgent && workingAgent.status !== "offline") {
           // Otherwise, create a follow-up task for the working agent
@@ -236,6 +240,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -285,6 +290,7 @@ export function createAssistant(): Assistant {
               contextKey: slackContextKey({ channelId, threadTs }),
             },
             inbound,
+            slack,
           );
           await ackSlackMessage(
             client,
@@ -318,6 +324,7 @@ export function createAssistant(): Assistant {
             contextKey: slackContextKey({ channelId, threadTs }),
           },
           inbound,
+          slack,
         );
         await ackSlackMessage(client, channelId, message.ts, reactionName("accepted"), "accepted");
         await notifySlackFileFailures(client, channelId, threadTs, unattached);

package/src/slack/channel-labels.ts

@@ -0,0 +1,74 @@
+import type { WebClient } from "@slack/web-api";
+import { rememberSessionLabel } from "../be/db/session-labels";
+import { getSlackApp } from "./app";
+import { callSlackWithRetry, slackErrorCode } from "./render-v2";
+
+const LABEL_TTL_MS = 24 * 60 * 60 * 1000;
+const FAILURE_TTL_MS = 10 * 60 * 1000;
+const FAILURE_CACHE_MAX = 500;
+const LOOKUP_QUEUE_MAX = 50;
+const inFlight = new Set<string>();
+const failedUntil = new Map<string, number>();
+let pending = Promise.resolve();
+
+async function channelLabel(client: WebClient, id: string): Promise<string> {
+  const result = await callSlackWithRetry(client, "conversations.info", {
+    channel: id.toUpperCase(),
+  });
+  const channel = result.channel as
+    | { name?: string; is_im?: boolean; is_mpim?: boolean; user?: string }
+    | undefined;
+  if (result.ok === false || !channel) throw new Error("Channel lookup failed");
+  if (channel.is_mpim) return "Group DM";
+  if (channel.is_im && channel.user) {
+    const result = await callSlackWithRetry(client, "users.info", { user: channel.user });
+    const user = result.user as
+      | { profile?: { display_name?: string; real_name?: string }; real_name?: string }
+      | undefined;
+    const name = user?.profile?.display_name || user?.real_name || user?.profile?.real_name;
+    if (result.ok !== false && name) return `DM · ${name}`;
+  } else if (channel.name) {
+    return `#${channel.name}`;
+  }
+  throw new Error("Channel label unavailable");
+}
+
+const CHANNEL_GROUP_KEY = /^shared\/slack\/([^/]+)\/$/;
+
+/**
+ * Queue a Slack lookup for each channel group key (`shared/slack/<channel>/`)
+ * without delaying the tree response. Other keys are ignored.
+ */
+export function warmSlackChannelLabels(groupKeys: string[]): void {
+  const client = getSlackApp()?.client;
+  if (!client) return;
+  for (const groupKey of groupKeys) {
+    const id = CHANNEL_GROUP_KEY.exec(groupKey)?.[1];
+    if (!id) continue;
+    if (inFlight.has(id) || (failedUntil.get(id) ?? 0) > Date.now()) continue;
+    failedUntil.delete(id);
+    if (inFlight.size >= LOOKUP_QUEUE_MAX) continue;
+    // Reserve failure capacity for queued work. Live failures must retain their TTL.
+    if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) {
+      const now = Date.now();
+      for (const [failedId, until] of failedUntil) {
+        if (until <= now) failedUntil.delete(failedId);
+      }
+      if (failedUntil.size + inFlight.size >= FAILURE_CACHE_MAX) continue;
+    }
+    inFlight.add(id);
+    pending = pending.then(async () => {
+      try {
+        const label = await channelLabel(client, id);
+        await rememberSessionLabel(groupKey, label, LABEL_TTL_MS);
+      } catch (error) {
+        failedUntil.set(id, Date.now() + FAILURE_TTL_MS);
+        console.warn(
+          `[Slack] Could not cache a session channel label: ${slackErrorCode(error) ?? "unknown error"}`,
+        );
+      } finally {
+        inFlight.delete(id);
+      }
+    });
+  }
+}

package/src/slack/handlers.ts

@@ -679,6 +679,11 @@ export function registerMessageHandler(app: App): void {
       routingThreadContext,
     );
 
+    const slack = {
+      trigger: "mention" as const,
+      messages: [{ ts: msg.ts, userId: msg.user, text: msg.text ?? "" }],
+    };
+
     if (matches.length === 0) {
       if (!botMentioned && !isImplicitMention) return ignoreSlackInbound("not_addressed");
 
@@ -742,6 +747,7 @@ export function registerMessageHandler(app: App): void {
           contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
         },
         inbound,
+        slack,
       );
       await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
       await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
@@ -864,6 +870,7 @@ export function registerMessageHandler(app: App): void {
               contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
             },
             inbound,
+            slack,
           );
           const { task } = created;
           unattached.push(...created.unattached);
@@ -888,6 +895,7 @@ export function registerMessageHandler(app: App): void {
             contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
           },
           inbound,
+          slack,
         );
         const { task } = created;
         unattached.push(...created.unattached);

package/src/slack/inbound-files.ts

@@ -22,6 +22,7 @@ import { join } from "node:path";
 import type { WebClient } from "@slack/web-api";
 import { getTaskAttachments, getTaskById, promoteDraftTask, refreshDraftTaskLease } from "../be/db";
 import { MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload } from "../be/task-attachment-store";
+import type { TaskCreateEvent } from "../extensions/contract";
 import { providerPath } from "../fs/provider";
 import { getFileStorageProvider } from "../fs/registry";
 import { resolveTemplate } from "../prompts/resolver";
@@ -320,17 +321,19 @@ export async function createSlackTaskWithFiles(
   description: string,
   options: CreateTaskOptions,
   inbound: InboundSlackFiles,
+  slack?: TaskCreateEvent["slack"],
 ): Promise<{ task: AgentTask; unattached: SlackFileFailure[] }> {
   noteSlackInboundSideEffect("task_created");
+  const context = { origin: "slack" as const, slack };
   if (inbound.fetched.length === 0) {
-    const task = await createTaskWithSiblingAwareness(description, options, { origin: "slack" });
+    const task = await createTaskWithSiblingAwareness(description, options, context);
     return { task, unattached: inbound.failed };
   }
 
   const task = await createTaskWithSiblingAwareness(
     description,
     { ...options, status: "draft" },
-    { origin: "slack" },
+    context,
   );
   const unattached = [...inbound.failed];
   // Uploads run one after another and can outlast the abandoned-draft sweep's

package/src/slack/thread-buffer.ts

@@ -313,6 +313,10 @@ async function slackFlush(
         contextKey: slackContextKey({ channelId, threadTs }),
       },
       inbound,
+      {
+        trigger: "thread-buffer",
+        messages: items.map(({ ts, userId, text }) => ({ ts, userId, text })),
+      },
     );
   } catch (error) {
     if (!(error instanceof TaskCreationBlockedError)) throw error;