@desplega.ai/agent-swarm 2.7.4 → 2.7.6

package/src/providers/reasoning-effort.ts

@@ -14,9 +14,11 @@
  */
 
 import {
+  CHATGPT_SUBSCRIPTION_PROVIDER,
   claudeCatalogModelId,
   cursorCatalogRef,
   dshCatalogRef,
+  fxCatalogRef,
   grokCatalogRef,
   REASONING_EFFORT_LEVELS,
   type ReasoningEffortLevel,
@@ -37,7 +39,8 @@ export type ReasoningHarness =
   | "dsh"
   | "cursor"
   | "amp"
-  | "grok";
+  | "grok"
+  | "fx";
 
 export interface ReasoningCapability {
   supported: boolean;
@@ -65,6 +68,7 @@ export type ReasoningEffortApplication =
   | { kind: "amp-effort"; reasoningEffort: ReasoningEffort }
   | { kind: "cursor-effort"; reasoningEffort: ReasoningEffort }
   | { kind: "grok-effort"; reasoningEffort: ReasoningEffort }
+  | { kind: "fx-effort"; reasoningEffort: ReasoningEffort }
   | { kind: "noop" };
 
 // --- Capability lookup --------------------------------------------------------
@@ -102,9 +106,16 @@ function lookupModel(
     ({ providerId, modelId } = cursorCatalogRef(model));
   } else if (harness === "grok") {
     ({ providerId, modelId } = grokCatalogRef(model));
+  } else if (harness === "fx") {
+    // Only the AI Gateway route (`vercel/…`) has an effort control.
+    const ref = fxCatalogRef(model);
+    if (!ref) return undefined;
+    ({ providerId, modelId } = ref);
   } else {
     ({ providerId, modelId } = splitProviderModel(model));
     if (!providerId) return undefined;
+    // A ChatGPT subscription id names an OpenAI catalog model.
+    if (providerId.toLowerCase() === CHATGPT_SUBSCRIPTION_PROVIDER) providerId = "openai";
   }
   const facts = runtimeCatalogModel(providerId, modelId);
   return facts ? { id: modelId, facts } : undefined;
@@ -240,6 +251,10 @@ export function applyReasoningEffort(
       // Grok's `--reasoning-effort` takes the normalized names as-is; see
       // `src/providers/grok-adapter.ts`.
       return { kind: "grok-effort", reasoningEffort: level };
+    case "fx":
+      // fx's `effort` config option takes the normalized names; the adapter
+      // sets it on the AI Gateway route only (see `fxTargetProfile`).
+      return { kind: "fx-effort", reasoningEffort: level };
     default: {
       const _exhaustive: never = harness;
       return _exhaustive;
@@ -256,6 +271,7 @@ const REASONING_HARNESSES: ReadonlySet<string> = new Set<ReasoningHarness>([
   "cursor",
   "amp",
   "grok",
+  "fx",
 ]);
 
 /**

package/src/providers/types.ts

@@ -66,7 +66,8 @@ export interface CostData {
     | "dsh"
     | "cursor"
     | "amp"
-    | "grok";
+    | "grok"
+    | "fx";
 }
 
 import type { ProviderName, SteerMode } from "../types";

package/src/runtime-providers/controller-protocol.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RuntimeProviderKindSchema } from "../types";
+import { RuntimePoolCacheSchema, RuntimeProviderKindSchema } from "../types";
 
 export const CONTROLLER_PROTOCOL_VERSION = 1;
 export const CONTROLLER_COMMAND_TIMEOUT_MS = 60_000;
@@ -16,6 +16,7 @@ const traitsSchema = z.object({
   canProvision: z.boolean(),
   ephemeralDisk: z.boolean(),
   supportsPause: z.boolean(),
+  persistentCache: z.boolean().optional(),
   maxTtlSec: z.number().positive().optional(),
   maxContinuousSec: z.number().positive().optional(),
 });
@@ -31,9 +32,21 @@ const provisionSchema = z.object({
     .object({ cpu: z.number().positive().optional(), memoryMb: z.number().positive().optional() })
     .optional(),
   ttlSec: z.number().positive().optional(),
+  cache: RuntimePoolCacheSchema.extend({
+    key: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]+$/),
+  }).optional(),
 });
 const command = { type: z.literal("cmd"), id: z.string().min(1) };
 export const ControllerCommandSchema = z.discriminatedUnion("op", [
+  z.object({
+    ...command,
+    op: z.literal("release-cache"),
+    payload: z.object({
+      key: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]+$/),
+      poolId: z.string().min(1),
+      ownerId: z.string().min(1),
+    }),
+  }),
   z.object({ ...command, op: z.literal("provision"), payload: provisionSchema }),
   z.object({
     ...command,

package/src/runtime-providers/controller.ts

@@ -1,6 +1,7 @@
 import { scrubSecrets } from "../utils/secret-scrubber";
 import type {
   ProvisionRequest,
+  RuntimeCacheReference,
   RuntimeHandle,
   RuntimeProvider,
   RuntimeProviderTraits,
@@ -25,6 +26,7 @@ export interface ControllerCommands {
   terminate(handle: RuntimeHandle, reason: string): Promise<void>;
   status(handles: RuntimeHandle[]): Promise<Record<string, RuntimeStatus>>;
   list(ownerId: string): Promise<RuntimeHandle[]>;
+  releaseCache?(cache: RuntimeCacheReference): Promise<void>;
   renew?(handle: RuntimeHandle, ttlSec: number): Promise<{ endAt: string }>;
   pause?(handle: RuntimeHandle): Promise<void>;
   resume?(handle: RuntimeHandle): Promise<void>;
@@ -36,6 +38,7 @@ export class BuiltinController implements ControllerCommands {
   readonly renew?: ControllerCommands["renew"];
   readonly pause?: ControllerCommands["pause"];
   readonly resume?: ControllerCommands["resume"];
+  readonly releaseCache?: ControllerCommands["releaseCache"];
 
   constructor(
     readonly id: string,
@@ -47,6 +50,8 @@ export class BuiltinController implements ControllerCommands {
     this.workerApiUrl = workerApiUrl;
     if (provider.renew)
       this.renew = (handle, ttlSec) => this.call(() => provider.renew!(target, handle, ttlSec));
+    if (provider.releaseCache)
+      this.releaseCache = (cache) => this.call(() => provider.releaseCache!(target, cache));
     if (provider.pause) this.pause = (handle) => this.call(() => provider.pause!(target, handle));
     if (provider.resume)
       this.resume = (handle) => this.call(() => provider.resume!(target, handle));

package/src/runtime-providers/docker.ts

@@ -4,6 +4,7 @@ import {
   type ConfigStatus,
   type ProvisionRequest,
   RUNTIME_LABELS,
+  type RuntimeCacheReference,
   type RuntimeHandle,
   type RuntimeProvider,
   type RuntimeStatus,
@@ -63,6 +64,22 @@ class DockerApiError extends Error {
   }
 }
 
+function isCacheMountError(error: unknown): boolean {
+  return error instanceof DockerApiError && /\b(?:mount\w*|volume\w*)\b/i.test(error.message);
+}
+
+type CacheVolume = { Name: string; Labels?: Record<string, string> };
+
+function assertCacheOwner(volume: CacheVolume, cache: RuntimeCacheReference): void {
+  if (
+    volume.Name !== cache.key ||
+    volume.Labels?.[RUNTIME_LABELS.owner] !== cache.ownerId ||
+    volume.Labels?.[RUNTIME_LABELS.poolId] !== cache.poolId ||
+    volume.Labels?.["swarm.cache"] !== "true"
+  )
+    throw new Error(`Cache volume ${cache.key} is not owned by this swarm and pool`);
+}
+
 async function dockerApi<T>(
   target: RuntimeTargetConfig,
   method: string,
@@ -119,7 +136,12 @@ async function dockerApi<T>(
 
 export class DockerRuntimeProvider implements RuntimeProvider {
   readonly kind = "docker" as const;
-  readonly traits = { canProvision: true, ephemeralDisk: true, supportsPause: false };
+  readonly traits = {
+    canProvision: true,
+    ephemeralDisk: true,
+    supportsPause: false,
+    persistentCache: true,
+  };
 
   checkConfig(target: RuntimeTargetConfig): ConfigStatus {
     try {
@@ -132,6 +154,29 @@ export class DockerRuntimeProvider implements RuntimeProvider {
 
   async provision(target: RuntimeTargetConfig, req: ProvisionRequest): Promise<RuntimeHandle> {
     try {
+      let cacheWarning: string | undefined;
+      let cacheMount: { Type: "volume"; Source: string; Target: string } | undefined;
+      if (req.cache) {
+        try {
+          const volume = await dockerApi<CacheVolume>(target, "POST", "/volumes/create", {
+            Name: req.cache.key,
+            Labels: {
+              [RUNTIME_LABELS.owner]: req.ownerId,
+              [RUNTIME_LABELS.poolId]: req.poolId,
+              "swarm.cache": "true",
+            },
+          });
+          // Docker reuses an existing name without replacing its labels.
+          assertCacheOwner(volume, {
+            key: req.cache.key,
+            poolId: req.poolId,
+            ownerId: req.ownerId,
+          });
+          cacheMount = { Type: "volume", Source: req.cache.key, Target: req.cache.mountPath };
+        } catch (error) {
+          cacheWarning = redactWithEnv(scrubSecrets(String(error)), req.env);
+        }
+      }
       const path = `/containers/create?name=${encodeURIComponent(`swarm-rt-${req.runtimeId}`)}`;
       const body = {
         Image: req.image,
@@ -154,40 +199,80 @@ export class DockerRuntimeProvider implements RuntimeProvider {
           NetworkMode: target.DOCKER_NETWORK,
           Memory: req.resources?.memoryMb ? req.resources.memoryMb * 1024 * 1024 : undefined,
           NanoCpus: req.resources?.cpu ? Math.round(req.resources.cpu * 1e9) : undefined,
+          ...(cacheMount ? { Mounts: [cacheMount] } : {}),
         },
       };
-      let created: { Id: string };
-      try {
-        created = await dockerApi(target, "POST", path, body);
-      } catch (err) {
-        if (
-          !(err instanceof DockerApiError) ||
-          err.statusCode !== 404 ||
-          !err.message.includes("No such image")
-        ) {
-          throw err;
+      const createAndStart = async (): Promise<string> => {
+        let created: { Id: string };
+        try {
+          created = await dockerApi(target, "POST", path, body);
+        } catch (err) {
+          if (
+            !(err instanceof DockerApiError) ||
+            err.statusCode !== 404 ||
+            !err.message.includes("No such image")
+          )
+            throw err;
+          const pullParams = new URLSearchParams({ fromImage: req.image });
+          if (
+            !req.image.includes("@") &&
+            req.image.lastIndexOf(":") <= req.image.lastIndexOf("/")
+          ) {
+            pullParams.set("tag", "latest");
+          }
+          await dockerApi(target, "POST", `/images/create?${pullParams}`, undefined, true);
+          created = await dockerApi(target, "POST", path, body);
         }
-        const pullParams = new URLSearchParams({ fromImage: req.image });
-        if (!req.image.includes("@") && req.image.lastIndexOf(":") <= req.image.lastIndexOf("/")) {
-          pullParams.set("tag", "latest");
+        try {
+          await dockerApi(target, "POST", `/containers/${created.Id}/start`);
+        } catch (err) {
+          try {
+            await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true&v=true`);
+          } catch (cleanupError) {
+            if (
+              cacheMount &&
+              isCacheMountError(err) &&
+              !(cleanupError instanceof DockerApiError && cleanupError.statusCode === 404)
+            )
+              throw new Error(
+                `${String(err)}; failed-start cleanup failed: ${String(cleanupError)}`,
+              );
+          }
+          throw err;
         }
-        await dockerApi(target, "POST", `/images/create?${pullParams}`, undefined, true);
-        created = await dockerApi(target, "POST", path, body);
-      }
+        return created.Id;
+      };
+      let externalId: string;
       try {
-        await dockerApi(target, "POST", `/containers/${created.Id}/start`);
+        externalId = await createAndStart();
       } catch (err) {
-        await dockerApi(target, "DELETE", `/containers/${created.Id}?force=true&v=true`).catch(
-          () => {},
-        );
-        throw err;
+        if (!cacheMount || !isCacheMountError(err)) throw err;
+        cacheWarning = redactWithEnv(scrubSecrets(String(err)), req.env);
+        delete body.HostConfig.Mounts;
+        externalId = await createAndStart();
       }
-      return { kind: "docker", externalId: created.Id };
+      return {
+        kind: "docker",
+        externalId,
+        ...(cacheWarning ? { meta: { cacheWarning } } : {}),
+      };
     } catch (err) {
       throw new Error(redactWithEnv(String(err), req.env));
     }
   }
 
+  async releaseCache(target: RuntimeTargetConfig, cache: RuntimeCacheReference): Promise<void> {
+    const path = `/volumes/${encodeURIComponent(cache.key)}`;
+    try {
+      const volume = await dockerApi<CacheVolume>(target, "GET", path);
+      assertCacheOwner(volume, cache);
+      // A volume still attached to any container must remain intact (Docker returns 409).
+      await dockerApi(target, "DELETE", path);
+    } catch (error) {
+      if (!(error instanceof DockerApiError && error.statusCode === 404)) throw error;
+    }
+  }
+
   async terminate(target: RuntimeTargetConfig, handle: RuntimeHandle): Promise<void> {
     try {
       // v=true also removes the container's anonymous volumes (the worker image declares

package/src/runtime-providers/types.ts

@@ -19,6 +19,8 @@ export interface RuntimeProviderTraits {
   ephemeralDisk: boolean;
   /** Provider can pause and resume a runtime. */
   supportsPause: boolean;
+  /** Can mount a persistent cache shared by all runtimes of one pool. */
+  persistentCache?: boolean;
   /** Provider hard cap on runtime lifetime, if any. */
   maxTtlSec?: number;
   /** Continuous runtime limit for the configured infrastructure tier. */
@@ -45,11 +47,23 @@ export interface ProvisionRequest {
   /** Worker env: MCP_BASE_URL, AGENT_ID, API key or scoped token, pool env. */
   env: Record<string, string>;
   resources?: { cpu?: number; memoryMb?: number };
+  /** Provider-neutral cache identity, allocated by the API rather than the operator. */
+  cache?: { key: string; mountPath: string };
   ttlSec?: number;
   /** Ownership labels, used by list() to find runtimes this swarm started. */
   labels: Record<string, string>;
 }
 
+export interface RuntimeCacheReference {
+  key: string;
+  poolId: string;
+  ownerId: string;
+}
+
+export function poolCacheKey(poolId: string, generation?: string): string {
+  return `swarm-cache-${poolId}${generation ? `-${generation}` : ""}`;
+}
+
 export interface RuntimeHandle {
   kind: RuntimeProviderKind;
   /** Container id, sandbox id, or pod name. */
@@ -74,6 +88,8 @@ export interface RuntimeProvider {
   status(target: RuntimeTargetConfig, handle: RuntimeHandle): Promise<RuntimeStatus>;
   /** Every runtime this swarm owns on the target, found by labels. Used to reap orphans. */
   list(target: RuntimeTargetConfig, ownerId: string): Promise<RuntimeHandle[]>;
+  /** Remove an owned pool cache after its runtimes stop; never force detach. */
+  releaseCache?(target: RuntimeTargetConfig, cache: RuntimeCacheReference): Promise<void>;
   renew?(
     target: RuntimeTargetConfig,
     handle: RuntimeHandle,

package/src/scheduler/scheduler.ts

@@ -11,6 +11,7 @@ import {
 import {
   getDbClient,
   getDueScheduledTasks,
+  getLeadAgent,
   getScheduledTaskById,
   getUserById,
   getWorkflow,
@@ -26,8 +27,9 @@ import {
 import { buildScriptCredentialBindingsWithFailures } from "@/be/script-credential-broker";
 import { getScript } from "@/be/scripts/db";
 import { runScriptWithRunCredential } from "@/be/scripts/run-credential";
+import { seededWorkflowState } from "@/be/seed/workflows-seeder";
 import { telemetry } from "@/telemetry";
-import type { AgentTask, ScheduledTask } from "@/types";
+import type { AgentTask, ScheduledTask, Workflow } from "@/types";
 import { getExecutorRegistry as getWorkflowExecutorRegistry } from "@/workflows";
 import { startWorkflowExecution } from "@/workflows/engine";
 import type { ExecutorRegistry } from "@/workflows/executors/registry";
@@ -252,8 +254,7 @@ export async function dispatchScheduleTarget(
       };
       const runId = await startWorkflowExecution(workflow, triggerData, registry, {
         triggerType: "schedule",
-        // The creator, as for script schedules: `targetAgentId` is caller-chosen.
-        triggeredByAgentId: schedule.createdByAgentId,
+        triggeredByAgentId: await scheduledWorkflowPrincipal(schedule, workflow),
         requestedByUserId: schedule.createdBy,
       });
       await throwIfWorkflowNeedsSetup(schedule.id, [runId]);
@@ -295,6 +296,38 @@ export async function dispatchScheduleTarget(
   }
 }
 
+/**
+ * The agent a scheduled workflow run acts as: the schedule's creator, as for
+ * script schedules (`targetAgentId` and trigger data are caller-chosen, so
+ * neither is ever the principal). A creator-less (seeded) schedule that fires
+ * a seeded workflow runs as the lead, resolved at fire time; with no lead the
+ * fire fails instead of running agentless. Operator settings such as inputs
+ * or on/off keep that. Any agent can edit a workflow, so one whose nodes or
+ * params changed never inherits the lead and its fire fails. Workflows the
+ * seeder never wrote keep their previous principal.
+ */
+async function scheduledWorkflowPrincipal(
+  schedule: ScheduledTask,
+  workflow: Workflow,
+): Promise<string | undefined> {
+  if (schedule.createdByAgentId) return schedule.createdByAgentId;
+  if (workflow.createdByAgentId) return undefined;
+  const seeded = await seededWorkflowState(workflow);
+  if (seeded === "unseeded") return undefined;
+  if (seeded === "edited") {
+    throw new Error(
+      `Schedule "${schedule.name}" has no creator and the nodes or params of seeded workflow "${workflow.name}" were edited, so it will not run as the lead. Re-create the schedule as the agent it should run as.`,
+    );
+  }
+  const lead = await getLeadAgent();
+  if (!lead) {
+    throw new Error(
+      `Schedule "${schedule.name}" has no creator and the swarm has no lead to run its workflow as`,
+    );
+  }
+  return lead.id;
+}
+
 async function throwIfWorkflowNeedsSetup(scheduleId: string, runIds: string[]): Promise<void> {
   for (const runId of runIds) {
     const run = await getWorkflowRun(runId);

package/src/script-workflows/workflow-ctx.ts

@@ -44,6 +44,14 @@ type AgentTaskConfig = {
   parentTaskId?: string;
   requestedByUserId?: string;
   outputSchema?: Record<string, unknown>;
+  /**
+   * Dispatch even when the follow-up re-delegation guard blocks this step.
+   * The guard applies only to a run launched from a follow-up task in a Slack
+   * thread, and decides once for the whole run at its first new step: it
+   * blocks a repeat of work already completed in the thread, or a run past the
+   * thread's dispatch cap. A blocked run's later new steps are blocked too.
+   */
+  allowRedelegation?: boolean;
   /**
    * Block until the dispatched task reaches a terminal status and journal
    * its real output. Defaults to `true` — this is the natural semantic for

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

@@ -104,6 +104,7 @@ export const SDK_TOOL_NAME_MAP = {
   slack_downloadFile: "slack-download-file",
   slack_delete: "slack-delete", // external: mutates Slack, destructive
   slack_update: "slack-update", // external: mutates Slack
+  slack_leaveThread: "slack-leave-thread",
 
   // ── chat sdk ──
   chat_reply: "chat-reply", // external: sends to the task's chat thread

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

@@ -63,6 +63,8 @@ declare module "swarm-sdk" {
     parentTaskId?: string;
     requestedByUserId?: string;
     outputSchema?: Record<string, unknown>;
+    /** Dispatch even when the follow-up re-delegation guard blocks this step (a run launched from a follow-up task in a Slack thread, checked at its first new step). */
+    allowRedelegation?: boolean;
     /** Wait for the dispatched task to reach a terminal status before resolving. Default: true. */
     waitForCompletion?: boolean;
     /** Max ms to wait for a terminal status before throwing. Default: 2h. Only used when waitForCompletion is true. */
@@ -493,6 +495,11 @@ declare module "swarm-sdk" {
     slack_downloadFile(args: { url: string }): Promise<unknown>;
     slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;
     slack_update(args: { channelId: string; messageTs: string; message: string }): Promise<unknown>;
+    slack_leaveThread(args: {
+      taskId?: string;
+      channelId?: string;
+      threadTs?: string;
+    }): Promise<unknown>;
 
     // --- write: chat sdk ---
     chat_reply(args: { text: string }): Promise<unknown>;
@@ -755,6 +762,26 @@ declare module "swarm-sdk" {
       label: string,
       config: { prompt: string; model?: string; schema?: Record<string, unknown> },
     ): Promise<unknown>;
+    /**
+     * Dispatch a task and journal its result under `label`.
+     *
+     * Resolves to the task's OUTPUT on success: the stored output string (JSON
+     * text under `outputSchema`, so parse it yourself), or `null` when the task
+     * stored none. It is never a task record: on a string, `result.taskId` and
+     * `result.status` are undefined; on `null`, reading them throws a TypeError.
+     * Other shapes:
+     * - `failOnTaskFailure: false` and the task ends failed/cancelled/superseded:
+     *   `{ taskId, status: "failed", error }`.
+     * - `waitForCompletion: false`: the first call still waits up to ~30s while
+     *   the server polls the task. Done in that window: the output, as on
+     *   success. Failed or cancelled in that window: throws, or
+     *   `{ taskId, status: "failed", error }` with `failOnTaskFailure: false`.
+     *   Still running: `{ taskId, status }`.
+     *
+     * To get a step's task id, query by its context key:
+     * `SELECT id, status, output FROM agent_tasks WHERE contextKey = 'script-run:<runId>:<label>'
+     * AND taskType = 'script-run-step' ORDER BY createdAt DESC, rowid DESC LIMIT 1`.
+     */
     agentTask(label: string, config: AgentTaskStepConfig): Promise<unknown>;
     swarmScript(
       label: string,

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

@@ -98,6 +98,7 @@ declare module "swarm-extension" {
             | "amp"
             | "cursor"
             | "grok"
+            | "fx"
             | undefined;
           leadOnly?: boolean | undefined;
         }
@@ -233,6 +234,7 @@ declare module "swarm-extension" {
       | "amp"
       | "cursor"
       | "grok"
+      | "fx"
       | undefined;
     providerMeta?: Record<string, unknown> | undefined;
     harnessVariant?: string | undefined;
@@ -255,6 +257,7 @@ declare module "swarm-extension" {
             | "amp"
             | "cursor"
             | "grok"
+            | "fx"
             | undefined;
           leadOnly?: boolean | undefined;
         }
@@ -276,6 +279,10 @@ declare module "swarm-extension" {
     runtimeInstanceId?: string | null | undefined;
   };
 
+  export type SteerMode = "steer" | "queue";
+
+  export type SteeringSource = "script" | "slack" | "mcp" | "api" | "ui" | "chat";
+
   export type RequestInfo = {
     sessionId: string | undefined;
     agentId: string | undefined;
@@ -486,6 +493,27 @@ declare module "swarm-extension" {
     leadAgentId: string;
     summary: string;
   }
+  export interface TaskSteerEvent {
+    task: AgentTask;
+    message: string;
+    mode: SteerMode;
+    source: SteeringSource;
+    sender: {
+      kind: "user" | "agent" | "system";
+      userId?: string;
+      agentId?: string;
+    };
+    messageTimestamps?: string[];
+    /** Slack ingress metadata; not persisted or writable through modify. */
+    slack?: {
+      channelId: string;
+      threadTs: string;
+      userId?: string;
+    };
+  }
+  export interface TaskSteerModify {
+    message: string;
+  }
   export type TaskFollowUpModify = Partial<
     Pick<CreateTaskOptions, "agentId" | "priority" | "followUpConfig">
   > & {
@@ -718,6 +746,11 @@ declare module "swarm-extension" {
       modify: TaskFollowUpModify;
       result: PreResult<TaskFollowUpModify>;
     };
+    "pre.task.steer": {
+      event: TaskSteerEvent;
+      modify: TaskSteerModify;
+      result: PreResult<TaskSteerModify>;
+    };
     "pre.slack.route": {
       event: SlackRouteEvent;
       modify: SlackRouteModify;

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

@@ -45,6 +45,8 @@ declare module "swarm-sdk" {
     parentTaskId?: string;
     requestedByUserId?: string;
     outputSchema?: Record<string, unknown>;
+    /** Dispatch even when the follow-up re-delegation guard blocks this step (a run launched from a follow-up task in a Slack thread, checked at its first new step). */
+    allowRedelegation?: boolean;
     /** Wait for the dispatched task to reach a terminal status before resolving. Default: true. */
     waitForCompletion?: boolean;
     /** Max ms to wait for a terminal status before throwing. Default: 2h. Only used when waitForCompletion is true. */
@@ -475,6 +477,11 @@ declare module "swarm-sdk" {
     slack_downloadFile(args: { url: string }): Promise<unknown>;
     slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;
     slack_update(args: { channelId: string; messageTs: string; message: string }): Promise<unknown>;
+    slack_leaveThread(args: {
+      taskId?: string;
+      channelId?: string;
+      threadTs?: string;
+    }): Promise<unknown>;
 
     // --- write: chat sdk ---
     chat_reply(args: { text: string }): Promise<unknown>;
@@ -737,6 +744,26 @@ declare module "swarm-sdk" {
       label: string,
       config: { prompt: string; model?: string; schema?: Record<string, unknown> },
     ): Promise<unknown>;
+    /**
+     * Dispatch a task and journal its result under `label`.
+     *
+     * Resolves to the task's OUTPUT on success: the stored output string (JSON
+     * text under `outputSchema`, so parse it yourself), or `null` when the task
+     * stored none. It is never a task record: on a string, `result.taskId` and
+     * `result.status` are undefined; on `null`, reading them throws a TypeError.
+     * Other shapes:
+     * - `failOnTaskFailure: false` and the task ends failed/cancelled/superseded:
+     *   `{ taskId, status: "failed", error }`.
+     * - `waitForCompletion: false`: the first call still waits up to ~30s while
+     *   the server polls the task. Done in that window: the output, as on
+     *   success. Failed or cancelled in that window: throws, or
+     *   `{ taskId, status: "failed", error }` with `failOnTaskFailure: false`.
+     *   Still running: `{ taskId, status }`.
+     *
+     * To get a step's task id, query by its context key:
+     * `SELECT id, status, output FROM agent_tasks WHERE contextKey = 'script-run:<runId>:<label>'
+     * AND taskType = 'script-run-step' ORDER BY createdAt DESC, rowid DESC LIMIT 1`.
+     */
     agentTask(label: string, config: AgentTaskStepConfig): Promise<unknown>;
     swarmScript(
       label: string,

package/src/server-user.ts

@@ -130,6 +130,7 @@ export function createUserServer(user: User): McpServer {
       offerMode: false,
       leadOnly: false,
       allowDuplicate: false,
+      allowRedelegation: false,
       overrideSlackContext: false,
     });
   });

package/src/server.ts

@@ -11,6 +11,7 @@ import { MCP_MAX_TOOL_INPUT_ELEMENTS } from "./mcp-limits";
 import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
 import { getSlackConfiguration } from "./slack/config";
+import { isSlackLeaveThreadDisabled } from "./slack/left-threads";
 import { registerAcceptSteerTool } from "./tools/accept-steer";
 import { registerAppActionRunTool } from "./tools/app-action-run";
 import { registerAppDiffTool } from "./tools/app-diff";
@@ -162,6 +163,7 @@ import { registerSlackCreateChannelTool } from "./tools/slack-create-channel";
 import { registerSlackDeleteTool } from "./tools/slack-delete";
 import { registerSlackDownloadFileTool } from "./tools/slack-download-file";
 import { registerSlackInviteToChannelTool } from "./tools/slack-invite-to-channel";
+import { registerSlackLeaveThreadTool } from "./tools/slack-leave-thread";
 import { registerSlackListChannelsTool } from "./tools/slack-list-channels";
 import { registerSlackPostTool } from "./tools/slack-post";
 import { registerSlackReadTool } from "./tools/slack-read";
@@ -693,6 +695,11 @@ export async function createServer(
     registerSlackDownloadFileTool(server);
     registerSlackDeleteTool(server);
     registerSlackUpdateTool(server);
+    // The scripts bridge builds its full-surface server once and caches it, so
+    // it always registers the tool; the handler refuses while the flag is set.
+    if (opts.fullSurface === true || !isSlackLeaveThreadDisabled()) {
+      registerSlackLeaveThreadTool(server);
+    }
   }
 
   // End of default-enabled capabilities