@desplega.ai/agent-swarm 2.7.4 → 2.7.6

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

@@ -3,8 +3,11 @@
  *
  * 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
+ * itself. By default page 1 (offset 0) always counts, so a write (a new
+ * session, a triage move) shows at once where the user looks first. A list
+ * whose count is expensive and whose total may lag can pass
+ * `firstPageTtlMs`: page 1 then reuses a count younger than that, so
+ * dashboard tabs that poll the same list share one count. Later pages reuse
  * that count for 30 s. A cold later page (deep link, expired entry) counts
  * too, so `total` is always set.
  */
@@ -13,7 +16,7 @@ export const LIST_TOTAL_TTL_MS = 30_000;
 const MAX_ENTRIES = 500;
 
 interface Entry {
-  expiresAt: number;
+  countedAt: number;
   total: Promise<number>;
 }
 
@@ -34,19 +37,23 @@ function filterKey(value: unknown): string {
   );
 }
 
-export function createListTotalCache(ttlMs = LIST_TOTAL_TTL_MS): ListTotalCache {
+export function createListTotalCache(
+  ttlMs = LIST_TOTAL_TTL_MS,
+  firstPageTtlMs = 0,
+): 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;
+      const maxAge = (offset ?? 0) > 0 ? ttlMs : Math.min(ttlMs, firstPageTtlMs);
+      if (hit && hit.countedAt + maxAge > now) return hit.total;
       if (hit) entries.delete(key);
 
-      // Cache the promise, so a later page that arrives mid-count shares it.
+      // Cache the promise, so a request that arrives mid-count shares it.
       const total = compute();
-      entries.set(key, { expiresAt: now + ttlMs, total });
+      entries.set(key, { countedAt: now, total });
       total.catch(() => {
         if (entries.get(key)?.total === total) entries.delete(key);
       });

package/src/http/mcp-bridge.ts

@@ -32,6 +32,10 @@ async function getBridgeServer(): Promise<McpServer> {
   return _bridgeServer;
 }
 
+export function resetBridgeServerForTesting(): void {
+  _bridgeServer = null;
+}
+
 type RegisteredTool = {
   handler: (argsOrExtra: unknown, extra?: unknown) => unknown | Promise<unknown>;
   inputSchema?: AnySchema;

package/src/http/memory.ts

@@ -1568,17 +1568,31 @@ const MEMORY_GC_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 let memoryGcTimer: ReturnType<typeof setInterval> | null = null;
 
 const SEARCH_RETRIEVAL_TTL_DAYS = 90;
+/** Rows per purge statement. The purge yields the event loop between batches. */
+const SEARCH_RETRIEVAL_PURGE_BATCH = 2000;
 
-async function purgeStaleSearchRetrievals(): Promise<number> {
+export async function purgeStaleSearchRetrievals(
+  batchSize = SEARCH_RETRIEVAL_PURGE_BATCH,
+): Promise<number> {
   try {
     const cutoff = new Date(
       Date.now() - SEARCH_RETRIEVAL_TTL_DAYS * 24 * 60 * 60 * 1000,
     ).toISOString();
-    const result = await getDbClient().run(
-      "DELETE FROM memory_retrieval WHERE eventType = 'search' AND retrievedAt < ?",
-      [cutoff],
-    );
-    return result.changes;
+    let purged = 0;
+    for (;;) {
+      // `+eventType` keeps the planner on the retrievedAt range. Without
+      // sqlite_stat1 it prefers the eventType equality, which reads every
+      // search row to test its date, even when nothing is stale.
+      const result = await getDbClient().run(
+        `DELETE FROM memory_retrieval WHERE rowid IN (
+          SELECT rowid FROM memory_retrieval
+          WHERE +eventType = 'search' AND retrievedAt < ? LIMIT ?)`,
+        [cutoff, batchSize],
+      );
+      purged += result.changes;
+      if (result.changes < batchSize) return purged;
+      await new Promise<void>((resolve) => setImmediate(resolve));
+    }
   } catch (err) {
     console.error("[memory-gc] Search retrieval purge failed:", (err as Error).message);
     return 0;
@@ -1602,11 +1616,22 @@ async function runMemoryGcTick(label: "Initial" | "Periodic"): Promise<void> {
   }
 }
 
-export async function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): Promise<void> {
+/** The first purge waits this long, so it does not compete with boot work. */
+const MEMORY_GC_INITIAL_DELAY_MS = 2 * 60 * 1000;
+let memoryGcInitialTimer: ReturnType<typeof setTimeout> | null = null;
+
+export async function startMemoryGc(
+  intervalMs = MEMORY_GC_INTERVAL_MS,
+  initialDelayMs = MEMORY_GC_INITIAL_DELAY_MS,
+): Promise<void> {
   if (memoryGcTimer) return;
 
-  // Run immediately on startup to clear any backlog
-  await runMemoryGcTick("Initial");
+  // Clear any backlog soon after startup, but off the boot path.
+  memoryGcInitialTimer = setTimeout(() => {
+    memoryGcInitialTimer = null;
+    void runMemoryGcTick("Initial");
+  }, initialDelayMs);
+  if (typeof memoryGcInitialTimer?.unref === "function") memoryGcInitialTimer.unref();
 
   memoryGcTimer = setInterval(() => {
     void runMemoryGcTick("Periodic");
@@ -1615,6 +1640,10 @@ export async function startMemoryGc(intervalMs = MEMORY_GC_INTERVAL_MS): Promise
 }
 
 export function stopMemoryGc(): void {
+  if (memoryGcInitialTimer) {
+    clearTimeout(memoryGcInitialTimer);
+    memoryGcInitialTimer = null;
+  }
   if (memoryGcTimer) {
     clearInterval(memoryGcTimer);
     memoryGcTimer = null;

package/src/http/script-runs.ts

@@ -13,10 +13,12 @@ import {
   getLatestScriptRunStepTaskByContextKey,
   getScriptRun,
   getScriptRunByIdempotencyKey,
+  getScriptRunFollowUpGuard,
   getScriptRunJournalStep,
   getTaskById,
   listScriptRunJournalSteps,
   listScriptRuns,
+  setScriptRunFollowUpGuard,
   updateScriptRun,
   updateScriptRunIfNotTerminal,
   updateScriptRunIfRunning,
@@ -24,6 +26,7 @@ import {
 } from "../be/db";
 import { explicitModelErrorForAgent } from "../be/model-validation";
 import { refuseSourceWithSecrets } from "../be/scripts/source-secrets";
+import { can } from "../rbac";
 import { lintWorkflowLabels } from "../script-workflows/label-lint";
 import { scriptRunMaxAgentTasks, scriptRunMaxSteps } from "../script-workflows/limits";
 import {
@@ -32,6 +35,12 @@ import {
   terminateScriptRunProcess,
 } from "../script-workflows/supervisor";
 import {
+  evaluateFollowUpRedelegation,
+  type FollowUpRedelegationBlock,
+  followUpThreadForSourceTask,
+} from "../tasks/follow-up-redelegation-guard";
+import {
+  type AgentTask,
   AgentTaskStatusSchema,
   RoutingReasonSchema,
   ScriptRunJournalEntrySchema,
@@ -111,6 +120,8 @@ const agentTaskBodySchema = z.object({
   parentTaskId: z.string().uuid().optional(),
   requestedByUserId: z.string().optional(),
   outputSchema: z.record(z.string(), z.unknown()).optional(),
+  /** Dispatch even when the follow-up re-delegation guard blocks it (same flag as send-task). */
+  allowRedelegation: z.boolean().optional(),
 });
 
 const scriptRunCreatedSchema = z.object({
@@ -298,10 +309,70 @@ const agentTaskRoute = route({
       description: "Agent task created or still running",
       schema: z.object({ taskId: z.string(), status: AgentTaskStatusSchema }),
     },
+    403: {
+      description:
+        "Script run belongs to another agent, or the run's agent may not create a child task under parentTaskId",
+    },
     404: { description: "Script run not found" },
+    409: { description: "Agent task failed, was cancelled, or was superseded" },
+    422: { description: "Blocked by the follow-up re-delegation guard" },
   },
 });
 
+/**
+ * Send-task's task.parent.attach decision for a `ctx.step.agentTask` step: a
+ * step inherits its parent's contextKey (its Slack or chat thread) and
+ * requester, so the run's agent needs the right to hold a child under it.
+ * Returns the 403 message, or null when allowed. A parent id with no task row
+ * passes: a step under it inherits nothing, as on send-task.
+ */
+async function stepParentRefusal(runAgentId: string, parentTaskId: string): Promise<string | null> {
+  const parentTask = await getTaskById(parentTaskId);
+  if (!parentTask) return null;
+  const runAgent = await getAgentById(runAgentId);
+  const decision = can({
+    principal: { kind: "agent", agentId: runAgentId, isLead: runAgent?.isLead ?? false },
+    verb: "task.parent.attach",
+    resource: {
+      kind: "task",
+      taskId: parentTask.id,
+      requestedByUserId: parentTask.requestedByUserId,
+      creatorAgentId: parentTask.creatorAgentId,
+      agentId: parentTask.agentId,
+    },
+    source: "http",
+  });
+  return decision.allow
+    ? null
+    : `You don't have context for parent task ${parentTaskId}. Only its assignee, its creator, or a lead can create a child task under it.`;
+}
+
+/**
+ * The launching session's task (X-Source-Task-Id), kept only when it belongs
+ * to the launching agent so a run cannot borrow another agent's session.
+ */
+async function resolveRunSourceTaskId(
+  req: IncomingMessage,
+  agentId: string,
+): Promise<string | undefined> {
+  const raw = req.headers["x-source-task-id"];
+  const sourceTaskId = Array.isArray(raw) ? raw[0] : raw;
+  if (!sourceTaskId) return undefined;
+  const task = await getTaskById(sourceTaskId);
+  return task?.agentId === agentId ? task.id : undefined;
+}
+
+/** One `ctx.step.agentTask` dispatch: the step task, or the guard rule that blocked it. */
+type StepDispatch =
+  | {
+      task: AgentTask;
+      /** True when this call inserted the step, false on a replay. */
+      created?: boolean;
+      blocked?: undefined;
+      override?: FollowUpRedelegationBlock["rule"];
+    }
+  | { task?: undefined; blocked: FollowUpRedelegationBlock; override?: undefined };
+
 async function requireAgent(res: ServerResponse, agentId: string | undefined) {
   if (!agentId) {
     jsonError(res, "X-Agent-ID required for script runs API", 400);
@@ -408,6 +479,7 @@ export async function handleScriptRuns(
     // Cap check and insert commit together: N concurrent POSTs otherwise all
     // read cap-1 active runs and all insert, exceeding the cap.
     const cap = scriptRunConcurrencyCap();
+    const sourceTaskId = await resolveRunSourceTaskId(req, agent.id);
     const creation = await getDbClient().transaction(async () => {
       if ((await countActiveScriptRuns()) >= cap) return null;
       return await createScriptRun({
@@ -418,6 +490,7 @@ export async function handleScriptRuns(
         scriptName: parsed.body.scriptName,
         idempotencyKey: parsed.body.idempotencyKey,
         requestedByUserId: parsed.body.requestedByUserId,
+        sourceTaskId,
         createdBy: parsed.body.requestedByUserId,
       });
     });
@@ -629,9 +702,29 @@ export async function handleScriptRuns(
       return true;
     }
 
+    // Only the run's own harness dispatches its steps (it sends the run's
+    // agent id). Step tasks carry that agent as creator, so another agent
+    // must not create them.
+    if (agentId !== run.agentId) {
+      jsonError(res, "Script run belongs to another agent", 403);
+      return true;
+    }
+
+    // The requested parent, checked before any lookup or insert so a refused
+    // call creates nothing.
+    if (parsed.body.parentTaskId) {
+      const refusal = await stepParentRefusal(run.agentId, parsed.body.parentTaskId);
+      if (refusal) {
+        jsonError(res, refusal, 403);
+        return true;
+      }
+    }
+
     const contextKey = `script-run:${run.id}:${parsed.body.stepKey}`;
     let task = await getLatestScriptRunStepTaskByContextKey(contextKey);
+    let dispatchedHere = false;
     if (!task) {
+      const taskDescription = parsed.body.template ?? parsed.body.task ?? parsed.body.stepKey;
       const modelError = await explicitModelErrorForAgent({
         model: parsed.body.model,
         allowCustomModel: parsed.body.allowCustomModel,
@@ -641,10 +734,47 @@ export async function handleScriptRuns(
         jsonError(res, modelError, 400);
         return true;
       }
+      const followUpThread = await followUpThreadForSourceTask(run.sourceTaskId);
+      // The replay lookup, the guard decision and the insert share one write
+      // transaction. It serializes this step against the run's other steps,
+      // other runs and send-task dispatches into the same thread.
+      let dispatched: StepDispatch;
       try {
-        task = await createTaskExtended(
-          parsed.body.template ?? parsed.body.task ?? parsed.body.stepKey,
-          {
+        dispatched = await getDbClient().transaction(async (): Promise<StepDispatch> => {
+          const replayed = await getLatestScriptRunStepTaskByContextKey(contextKey);
+          if (replayed) return { task: replayed };
+
+          // Follow-up re-delegation guard, as in send-task. A run is one
+          // dispatch: its first new step decides for the whole run, and every
+          // later step follows that decision. Later steps never compare against
+          // the run's own completed steps, a long run cannot use up the thread's
+          // loop cap, and parallel steps are dispatched all or none.
+          let override: FollowUpRedelegationBlock["rule"] | undefined;
+          if (followUpThread) {
+            const decision = await getScriptRunFollowUpGuard(run.id);
+            if (decision !== "passed") {
+              const blocked: FollowUpRedelegationBlock | null =
+                decision === null
+                  ? await evaluateFollowUpRedelegation({
+                      ...followUpThread,
+                      creatorAgentId: run.agentId,
+                      taskDescription,
+                      targetAgentId: parsed.body.agentId,
+                    })
+                  : {
+                      rule: decision,
+                      message: `Blocked by the follow-up re-delegation guard (${decision} rule): an earlier step of this script run was blocked, and a run counts as one dispatch. If it must run, pass allowRedelegation: true.`,
+                    };
+              if (blocked && !parsed.body.allowRedelegation) {
+                if (decision === null) await setScriptRunFollowUpGuard(run.id, blocked.rule);
+                return { blocked };
+              }
+              override = blocked?.rule;
+              await setScriptRunFollowUpGuard(run.id, "passed");
+            }
+          }
+
+          const created = await createTaskExtended(taskDescription, {
             agentId: parsed.body.agentId,
             routingReason:
               parsed.body.routingReason ?? (parsed.body.agentId ? "human_pinned" : undefined),
@@ -660,6 +790,20 @@ export async function handleScriptRuns(
             offeredTo: parsed.body.offerMode ? parsed.body.agentId : undefined,
             taskType: "script-run-step",
             source: "mcp",
+            // Counts the run toward the launcher's follow-up loop cap.
+            creatorAgentId: run.agentId,
+            // With no parent, the step inherits the launching session's Slack
+            // thread, as a send-task from that session does.
+            sourceTaskId: run.sourceTaskId,
+            // A guarded run's steps are its dispatches into the follow-up's
+            // thread, whatever their parent, so the guard sees them there.
+            ...(followUpThread
+              ? {
+                  slackChannelId: followUpThread.channelId,
+                  slackThreadTs: followUpThread.threadTs,
+                  slackUserId: followUpThread.userId,
+                }
+              : {}),
             dir: parsed.body.dir,
             vcsRepo: parsed.body.vcsRepo,
             model: parsed.body.model,
@@ -667,8 +811,9 @@ export async function handleScriptRuns(
             requestedByUserId: parsed.body.requestedByUserId ?? run.requestedByUserId,
             outputSchema: parsed.body.outputSchema,
             contextKey,
-          },
-        );
+          });
+          return { task: created, created: true, override };
+        });
       } catch (error) {
         if (error instanceof ExtensionAgentAssignmentError) {
           jsonError(res, error.message, 400);
@@ -676,6 +821,30 @@ export async function handleScriptRuns(
         }
         throw error;
       }
+      if (dispatched.override) {
+        console.log(
+          `[script-runs] follow-up re-delegation override: rule=${dispatched.override} runId=${run.id} creatorAgentId=${run.agentId} sourceTaskId=${run.sourceTaskId} thread=${followUpThread?.channelId}/${followUpThread?.threadTs}`,
+        );
+      }
+      if (!dispatched.task) {
+        json(res, { error: dispatched.blocked.message, rule: dispatched.blocked.rule }, 422);
+        return true;
+      }
+      task = dispatched.task;
+      dispatchedHere = dispatched.created === true;
+    }
+
+    // A replay answers from the selected step, whatever parent this call sent
+    // (or omitted), so authorize the parent the step actually holds. Every
+    // replay lookup above lands here before any output is returned. A step this
+    // call just dispatched was authorized above; refusing it now would leave
+    // the work running behind a 403.
+    if (!dispatchedHere && task.parentTaskId) {
+      const refusal = await stepParentRefusal(run.agentId, task.parentTaskId);
+      if (refusal) {
+        jsonError(res, refusal, 403);
+        return true;
+      }
     }
 
     const deadline = Date.now() + 30_000;

package/src/http/status.ts

@@ -45,6 +45,7 @@ import { getSlackConnectionState } from "../slack/connection-state";
 import { isTelemetryEnabled } from "../telemetry";
 import { type AgentCredStatus, AutomationIntegrationIdSchema, ProviderNameSchema } from "../types";
 import { isRuntimePoolsEnabled } from "../utils/runtime-pools-flag";
+import { resolveAppUrl } from "./config-values";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -116,6 +117,12 @@ export const StatusIdentitySchema = z.object({
    * cloud installs can be sliced server-side.
    */
   org_id: z.string().nullable(),
+  /**
+   * The swarm's public dashboard URL (`APP_URL`, then `DASHBOARD_URL`, with
+   * swarm_config precedence). Null when neither is set. The dashboard reads
+   * links to it in agent output as its own. Absent on older APIs.
+   */
+  dashboard_url: z.string().nullable().optional(),
 });
 export type StatusIdentity = z.infer<typeof StatusIdentitySchema>;
 
@@ -334,7 +341,7 @@ export async function rollupCredStatusForProvider(provider: string): Promise<Cre
 
 // ─── Identity ────────────────────────────────────────────────────────────────
 
-function buildIdentity(): StatusIdentity {
+function buildIdentity(dashboardUrl: string | null): StatusIdentity {
   const cloudRaw = process.env.SWARM_CLOUD;
   const hideRaw = process.env.SWARM_HIDE_CLOUD_PROMO;
   return {
@@ -345,6 +352,7 @@ function buildIdentity(): StatusIdentity {
     marketing_url: process.env.SWARM_MARKETING_URL?.trim() || null,
     hide_cloud_promo: hideRaw === "true" || hideRaw === "1",
     org_id: process.env.SWARM_ORG_ID?.trim() || null,
+    dashboard_url: dashboardUrl,
   };
 }
 
@@ -759,7 +767,7 @@ export async function buildStatusPayload(): Promise<StatusResponse> {
   const instance = await getInstanceFeedbackSignals();
   return {
     runtime_pools: { enabled: isRuntimePoolsEnabled(), supervisor: runtimeSupervisorStatus() },
-    identity: buildIdentity(),
+    identity: buildIdentity(await resolveAppUrl()),
     setup,
     activity: { ...activity, leads_ready: readyLeads },
     agent_fs: {

package/src/http/tasks.ts

@@ -84,7 +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 { createListTotalCache, LIST_TOTAL_TTL_MS } from "./list-total-cache";
 import {
   agentFirstPrincipal,
   authUserId,
@@ -224,7 +224,9 @@ const SupersedeTaskResponseSchema = z.object({
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
 
-const taskTotals = createListTotalCache();
+// The task list total scans every visible task, and only the pager shows it,
+// so page 1 polls reuse a total younger than 15 s.
+const taskTotals = createListTotalCache(LIST_TOTAL_TTL_MS, 15_000);
 
 const listTasks = route({
   method: "get",

package/src/integrations/chat-sdk/inbound.ts

@@ -13,6 +13,7 @@ import {
 } from "@/be/db";
 import { rememberSessionLabel } from "@/be/db/session-labels";
 import { resolveIdentity } from "@/be/identity";
+import { SteeringBlockedError } from "@/be/steering";
 import { recordUnmappedIdentity } from "@/be/unmapped-identities";
 import { dispatchPre } from "@/extensions/dispatcher";
 import { resolveTemplate } from "@/prompts/resolver";
@@ -154,11 +155,20 @@ export async function handleChatInbound(
   // A thread with messages already waiting keeps its order: append, do not steer past them.
   // Another sender's message takes the buffer, so it gets its own header and requester.
   if (!immediate && attachments.length === 0 && text && !isChatThreadBuffered(thread.id)) {
-    const steering = await requestChatThreadSteering({
-      contextKey: chatSdkContextKey(thread.id),
-      message: text,
-      resolveSender: () => resolveChatSender(adapter, message.author.userId),
-    });
+    let steering: Awaited<ReturnType<typeof requestChatThreadSteering>>;
+    try {
+      steering = await requestChatThreadSteering({
+        contextKey: chatSdkContextKey(thread.id),
+        message: text,
+        resolveSender: () => resolveChatSender(adapter, message.author.userId),
+      });
+    } catch (error) {
+      if (!(error instanceof SteeringBlockedError)) throw error;
+      console.info(`[chat-sdk] ${thread.id}: steering blocked: ${error.reason}`);
+      stopTypingKeepalive(thread.id);
+      await setChatMessageReaction(adapter, thread.id, message.id, "failed");
+      return;
+    }
     if (steering) {
       console.log(
         `[chat-sdk] ${adapter} message steered task ${steering.task.id} (${steering.result.outcome})`,

package/src/integrations/chat-sdk/steering.ts

@@ -1,5 +1,5 @@
 import { getLatestLeadTaskByContextKey } from "@/be/db";
-import { requestSteering, SteeringRequestError } from "@/be/steering";
+import { requestSteering, SteeringBlockedError, SteeringRequestError } from "@/be/steering";
 import type { AgentTask, SteerResult } from "@/types";
 import { scrubSecrets } from "@/utils/secret-scrubber";
 import { isSteeringEnabled } from "@/utils/steering-enabled";
@@ -44,6 +44,8 @@ export async function requestChatThreadSteering(args: {
     });
     return { task, result };
   } catch (error) {
+    // A policy block must not fall back to task creation.
+    if (error instanceof SteeringBlockedError) throw error;
     const detail = error instanceof Error ? error.message : String(error);
     const what = error instanceof SteeringRequestError ? "was refused" : "failed";
     console.warn(

package/src/kv-reserved-namespaces.ts

@@ -12,6 +12,8 @@ const RESERVED_FAMILIES = new Map([
   ["worker", "namespace is reserved for worker nudges"],
   // Durable dedupe for SLACK_BLOCK_EXTERNAL_CHANNELS alerts (src/slack/external-channel.ts).
   ["slack-external-alert", "namespace is reserved for Slack external channel alerts"],
+  // Threads the swarm left via slack-leave-thread (src/slack/left-threads.ts).
+  ["slack-left-thread", "namespace is reserved for left Slack threads; use slack-leave-thread"],
   // Source group labels (src/be/db/session-labels.ts). Private, see PRIVATE_FAMILIES.
   [
     "session-labels",

package/src/prompts/base-prompt.ts

@@ -78,12 +78,15 @@ const REPO_CLAUDE_MD_INLINE_PROVIDERS: ReadonlySet<string> = new Set(["opencode"
 /**
  * Template event for the tool-discovery line. Amp, Codex and OpenCode run MCP
  * tools inside their own code sandbox (`code_exec`, `exec`, `execute`), each
- * with its own call shape, so the generic lines are wrong for them.
+ * with its own call shape, and fx defers them behind `capability_search` under
+ * `mcp_<server>_<tool>` names, so the generic lines are wrong for them.
  */
 function toolDiscoveryEvent(provider: string, hasToolSearch: boolean): string {
   switch (provider) {
     case "amp":
       return "system.agent.tool_discovery.amp";
+    case "fx":
+      return "system.agent.tool_discovery.fx";
     case "codex":
       return "system.agent.tool_discovery.codex";
     case "opencode":

package/src/prompts/session-templates.ts

@@ -314,6 +314,7 @@ The engine posts the thread tree and the outcome card. You post at most one mess
 The outcome card publishes your \`output\` verbatim. Keep free-text \`output\` under 120 words by default, with the exceptions in How you write.
 A Slack task from an unknown user: register them with \`manage-user\` first.
 You MUST use the \`slack-interaction\` skill before you post to Slack.
+Call \`slack-leave-thread\` with your taskId when a thread no longer needs you: people are talking among themselves, someone tells you to stop or back off, or the thread's work is done. The swarm then ignores the thread until someone @mentions it. Leave quietly, with no goodbye message.
 `,
   variables: [],
   category: "system",
@@ -397,6 +398,21 @@ registerTemplate({
   category: "system",
 });
 
+/**
+ * Last line of an fx system prompt that exceeds the 64 KiB `systemPrompt` cap.
+ * The adapter sends the first part and writes the whole prompt to a file.
+ */
+registerTemplate({
+  eventType: "system.agent.fx.system_prompt_file",
+  header: "",
+  defaultBody:
+    "These instructions are cut short. Read {{path}} before you start: it holds the complete swarm instructions, of which the text above is only the first part.",
+  variables: [
+    { name: "path", description: "Absolute path of the file with the full system prompt" },
+  ],
+  category: "system",
+});
+
 /**
  * First message of a cursor session on the first-message path. Cursor keeps
  * its own system prompt there, so the swarm's rides on top of the task prompt.
@@ -448,6 +464,15 @@ registerTemplate({
   category: "system",
 });
 
+registerTemplate({
+  eventType: "system.agent.tool_discovery.fx",
+  header: "",
+  defaultBody:
+    "Most swarm tools are deferred behind `capability_search`. Each one is named `mcp_swarm_<tool>`, so `store-progress` is `mcp_swarm_store-progress`. Call a tool you know by that name directly. To find one, use `capability_search`.",
+  variables: [],
+  category: "system",
+});
+
 registerTemplate({
   eventType: "system.agent.tool_discovery.codex",
   header: "",
@@ -574,6 +599,7 @@ registerTemplate({
 ## Slack (scripts-only)
 
 This task originated from Slack (channel: \`{{slackChannelId}}\`). The engine maintains the thread tree and publishes the top-level outcome card. Post at most one distinct agent-authored message per task, concrete, sized to what the user asked for. Progress, start, completion, failure, acknowledgment messages, and relayed raw task output stay out of Slack. Named Slack tools are not exposed in scripts-only mode, so use \`script-run\` with inline source calling \`ctx.swarm.slack_reply({ taskId, message })\` (your taskId carries the thread context).
+When the thread no longer needs you (people are talking among themselves, someone tells you to stop, or the work is done), call \`ctx.swarm.slack_leaveThread({ taskId })\` the same way. The swarm then ignores the thread until someone @mentions it. Leave quietly, with no goodbye message.
 The outcome card publishes your \`output\` verbatim. Keep free-text \`output\` under 120 words by default, with the exceptions in How you write.
 `,
   variables: [