@desplega.ai/agent-swarm 2.7.5 → 2.7.7

package/src/pages/version.ts

@@ -35,6 +35,9 @@ export async function snapshotPage(
     passwordHash: page.passwordHash,
     body: page.body,
     needsCredentials: page.needsCredentials,
+    theme: page.theme,
+    themeTokens: page.themeTokens,
+    designVersion: page.designVersion,
   };
 
   return createPageVersion({

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.1793275344-g17bf52";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1793450357-gd44904";
 
 /** 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/codex-adapter.ts

@@ -2053,6 +2053,7 @@ export async function createInProcessCodexSession(
     const appServerFactory = opts.appServerFactory ?? ((options) => new CodexAppServer(options));
     const client = appServerFactory({
       ...(codexPathOverride ? { codexPath: codexPathOverride } : {}),
+      ...(gateway ? { configOverrides: codexGatewayConfig(gateway) } : {}),
       env,
       onStderr: (line) => {
         if (liveSession) liveSession.emitTransportStderr(line);

package/src/providers/codex-app-server.ts

@@ -26,6 +26,7 @@ export interface CodexAppServerOptions {
   env: Readonly<Record<string, string | undefined>>;
   requestTimeoutMs?: number;
   onStderr?: (line: string) => void;
+  configOverrides?: Readonly<Record<string, CodexConfigValue | undefined>>;
 }
 
 type PendingRequest = {
@@ -53,6 +54,25 @@ export class CodexAppServerRpcError extends Error {
   }
 }
 
+/** `-c key=<TOML value>` pairs, one per top-level key; tables become inline tables. */
+export function configOverrideArgs(
+  overrides: Readonly<Record<string, CodexConfigValue | undefined>> = {},
+): string[] {
+  return Object.entries(overrides).flatMap(([key, value]) =>
+    value === undefined ? [] : ["-c", `${key}=${tomlValue(value)}`],
+  );
+}
+
+function tomlValue(value: CodexConfigValue): string {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return `[${value.map(tomlValue).join(", ")}]`;
+  const fields = Object.entries(value as Record<string, CodexConfigValue | undefined>).flatMap(
+    ([key, field]) => (field === undefined ? [] : [`${JSON.stringify(key)} = ${tomlValue(field)}`]),
+  );
+  return `{ ${fields.join(", ")} }`;
+}
+
 /** Thin JSONL client for one `codex app-server --listen stdio://` process. */
 export class CodexAppServer {
   private readonly proc: ReturnType<typeof Bun.spawn>;
@@ -79,7 +99,13 @@ export class CodexAppServer {
     this.onStderr = options.onStderr;
 
     const codexPath = options.codexPath ?? resolveCodexPath(options.env.PATH);
-    const command = [codexPath, "app-server", "--listen", "stdio://"];
+    const command = [
+      codexPath,
+      ...configOverrideArgs(options.configOverrides),
+      "app-server",
+      "--listen",
+      "stdio://",
+    ];
 
     const env = Object.fromEntries(
       Object.entries(options.env).filter(

package/src/providers/fx-adapter.ts

@@ -21,7 +21,7 @@ import type {
  * Dockerfile.worker; bump the two together). Every ACP shape this adapter
  * relies on was measured against it.
  */
-export const FX_PINNED_VERSION = "0.0.15";
+export const FX_PINNED_VERSION = "0.0.16";
 
 /** OpenAI's Chat Completions prefix; fx appends `/chat/completions`. */
 export const FX_OPENAI_BASE_URL = "https://api.openai.com/v1";

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

@@ -8,6 +8,13 @@
 
 import type { ExtensionFactory, McpServerConfig } from "@earendil-works/pi-coding-agent";
 import { buildRatingsFromLlm, fetchRetrievalsForTask, postRatings } from "../be/memory/raters/llm";
+import {
+  advanceIdentityBaselines,
+  contentSha256,
+  PROFILE_FILE_IO,
+  type ProfileFileIO,
+  readIdentityBaselines,
+} from "../commands/profile-sync";
 import { checkToolLoop, clearToolHistory } from "../hooks/tool-loop-detection";
 import { renderGoalReminder } from "../prompts/goal-reminder";
 import { isSessionSummarySkipped } from "../utils/env-flag";
@@ -100,11 +107,16 @@ export async function fetchTaskDetails(
   }
 }
 
-/** Sync identity files (SOUL.md, IDENTITY.md, TOOLS.md) to server */
+/**
+ * Sync identity files (SOUL.md, IDENTITY.md, TOOLS.md) to server. A file whose
+ * hash still equals its baseline was not edited and is skipped, so a stale copy
+ * never overwrites a DB-side edit made during the session.
+ */
 export async function syncIdentityFilesToServer(
   config: SwarmHooksConfig,
   changeSource: "self_edit" | "session_sync" = "session_sync",
   signal?: AbortSignal,
+  io: ProfileFileIO = PROFILE_FILE_IO,
 ): Promise<void> {
   const updates: Record<string, string> = {};
   const paths: Record<string, string> = {
@@ -112,15 +124,14 @@ export async function syncIdentityFilesToServer(
     identityMd: "/workspace/IDENTITY.md",
     toolsMd: "/workspace/TOOLS.md",
   };
+  const baselines = await readIdentityBaselines(io.readFile);
 
   for (const [key, path] of Object.entries(paths)) {
     try {
-      const file = Bun.file(path);
-      if (await file.exists()) {
-        const content = await file.text();
-        if (content.trim() && content.length <= 65536) {
-          updates[key] = content;
-        }
+      const content = await io.readFile(path);
+      if (content === undefined || baselines?.[key] === contentSha256(content)) continue;
+      if (content.trim() && content.length <= 65536) {
+        updates[key] = content;
       }
     } catch {
       /* skip */
@@ -130,28 +141,27 @@ export async function syncIdentityFilesToServer(
   if (Object.keys(updates).length === 0) return;
 
   try {
-    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+    const resp = await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
       method: "PUT",
       headers: apiHeaders(config),
       body: JSON.stringify({ ...updates, changeSource }),
       signal,
     });
+    if (resp.ok) await advanceIdentityBaselines(updates, io);
   } catch {
     /* silently fail */
   }
 }
 
 /** Sync setup script to server */
-async function syncSetupScriptToServer(
+export async function syncSetupScriptToServer(
   config: SwarmHooksConfig,
   changeSource: "self_edit" | "session_sync" = "session_sync",
+  io: ProfileFileIO = PROFILE_FILE_IO,
 ): Promise<void> {
   try {
-    const file = Bun.file("/workspace/start-up.sh");
-    if (!(await file.exists())) return;
-
-    const raw = await file.text();
-    if (!raw.trim()) return;
+    const raw = await io.readFile("/workspace/start-up.sh");
+    if (!raw?.trim()) return;
 
     const markerStart = "# === Agent-managed setup (from DB) ===";
     const markerEnd = "# === End agent-managed setup ===";
@@ -166,12 +176,17 @@ async function syncSetupScriptToServer(
     }
 
     if (!content || content.length > 65536) return;
+    const baselines = await readIdentityBaselines(io.readFile);
+    if (baselines?.setupScript === contentSha256(content)) return;
 
-    await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
+    const resp = await fetch(`${config.apiUrl}/api/agents/${config.agentId}/profile`, {
       method: "PUT",
       headers: apiHeaders(config),
       body: JSON.stringify({ setupScript: content, changeSource }),
     });
+    if (resp.ok) {
+      await advanceIdentityBaselines({ setupScript: content }, io);
+    }
   } catch {
     /* silently fail */
   }

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/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/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. */
@@ -760,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-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. */
@@ -742,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/slack/commands.ts

@@ -2,6 +2,7 @@ import type { App } from "@slack/bolt";
 import { getAllAgents, getAllTasks } from "../be/db";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { EXTERNAL_CHANNEL_BLOCKED_REPLY, shouldBlockChannel } from "./external-channel";
+import { isSlackLeaveThreadDisabled } from "./left-threads";
 
 export function registerCommandHandler(app: App): void {
   app.command("/agent-swarm-status", async ({ ack, respond, command, client }) => {
@@ -88,9 +89,12 @@ export function registerCommandHandler(app: App): void {
 • Follow-up tasks auto-depend on the active task in the thread for natural sequencing`);
     }
 
+    const leaveLine = isSlackLeaveThreadDisabled()
+      ? ""
+      : "\n• `!leave` in a thread - Make the swarm ignore that thread until someone @mentions it";
     sections.push(`*Commands:*
 • \`/agent-swarm-status\` - Show all agents and their current status
-• \`/agent-swarm-help\` - Show this help message`);
+• \`/agent-swarm-help\` - Show this help message${leaveLine}`);
 
     const blocks = [
       {

package/src/slack/handlers.ts

@@ -52,7 +52,13 @@ import {
   leaveExternalChannel,
   shouldBlockChannel,
 } from "./external-channel";
-import { shouldSkipLeftSlackThread } from "./left-threads";
+import {
+  isSlackLeaveThreadCommand,
+  isSlackLeaveThreadDisabled,
+  leaveSlackThread,
+  SLACK_LEFT_THREAD_CONFIRMATION,
+  shouldSkipLeftSlackThread,
+} from "./left-threads";
 import {
   collectSlackMessageFiles,
   extractSlackMessageText,
@@ -491,7 +497,36 @@ export function registerMessageHandler(app: App): void {
     // Check if bot was mentioned (in original text only)
     const botMentioned = !!cachedBotUserId && !!msg.text?.includes(`<@${cachedBotUserId}>`);
 
-    // A thread the swarm left (slack-leave-thread) stays silent until someone
+    // `!leave` in a thread the swarm is in: a human makes the swarm leave it,
+    // in code, with no workflow event, buffering, task, or model call.
+    // Any task bound to the thread counts, assigned or not, as does a thread
+    // the swarm started. Checked before the left-thread gate so `@bot !leave`
+    // leaves rather than rejoining. The confirmation is ephemeral, to the
+    // sender only.
+    if (
+      msg.thread_ts &&
+      !isSlackLeaveThreadDisabled() &&
+      isSlackLeaveThreadCommand(msg.text, cachedBotUserId) &&
+      ((await getMostRecentTaskInThread(msg.channel, msg.thread_ts)) !== null ||
+        (await wasThreadStartedBySwarm(client, msg.channel, msg.thread_ts)))
+    ) {
+      noteSlackInboundSideEffect("thread_leave");
+      await leaveSlackThread(msg.channel, msg.thread_ts, { slackUserId: msg.user });
+      console.log(`[Slack] Left thread ${msg.channel}/${msg.thread_ts}: !leave from ${msg.user}`);
+      try {
+        await client.chat.postEphemeral({
+          channel: msg.channel,
+          user: msg.user,
+          thread_ts: msg.thread_ts,
+          text: SLACK_LEFT_THREAD_CONFIRMATION,
+        });
+      } catch (error) {
+        console.error("[Slack] Failed to confirm !leave:", error);
+      }
+      return;
+    }
+
+    // A thread the swarm left (slack-leave-thread or `!leave`) stays silent until someone
     // @mentions the bot. Checked before the workflow event, buffering, routing,
     // or any AI call.
     if (await shouldSkipLeftSlackThread(msg.channel, msg.thread_ts, botMentioned)) {