@desplega.ai/agent-swarm 2.7.4 → 2.7.5

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/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/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

@@ -493,6 +493,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>;

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

@@ -475,6 +475,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>;

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

package/src/slack/assistant.ts

@@ -20,6 +20,7 @@ import {
   fetchSlackFiles,
   notifySlackFileFailures,
 } from "./inbound-files";
+import { shouldSkipLeftSlackThread } from "./left-threads";
 import {
   collectSlackMessageFiles,
   type SlackMessageLike,
@@ -194,11 +195,26 @@ export function createAssistant(
           }
         }
 
+        const botMentioned = !!cachedBotUserId && rawText.includes(`<@${cachedBotUserId}>`);
+        // A thread the swarm left (slack-leave-thread) stays silent until someone
+        // @mentions the bot.
+        if (
+          await shouldSkipLeftSlackThread(
+            channelId,
+            msg.thread_ts as string | undefined,
+            botMentioned,
+          )
+        ) {
+          console.log(
+            `[Slack] assistant: skipping message in left thread ${channelId}/${threadTs}`,
+          );
+          return ignoreSlackInbound("thread_left");
+        }
+
         // If the message @-mentions someone OTHER than our bot and does NOT mention
         // our bot, it is addressed to a different agent/user — do not spawn a task
         // (unless SLACK_THREAD_WAKE_ON_ANY_MESSAGE=true).
         if (cachedBotUserId) {
-          const botMentioned = rawText.includes(`<@${cachedBotUserId}>`);
           if (!botMentioned && isAddressedToOtherUser(rawText, cachedBotUserId)) {
             console.log(
               `[Slack] assistant: skipping message in ${channelId}/${threadTs} — mentions another user, not us`,

package/src/slack/handlers.ts

@@ -10,6 +10,7 @@ import {
   getTasksByAgentId,
   isExtensionAgent,
 } from "../be/db";
+import { SteeringBlockedError } from "../be/steering";
 import { dispatchPre } from "../extensions/dispatcher";
 import { resolveTemplate } from "../prompts/resolver";
 import { slackContextKey } from "../tasks/context-key";
@@ -51,6 +52,7 @@ import {
   leaveExternalChannel,
   shouldBlockChannel,
 } from "./external-channel";
+import { shouldSkipLeftSlackThread } from "./left-threads";
 import {
   collectSlackMessageFiles,
   extractSlackMessageText,
@@ -486,6 +488,17 @@ export function registerMessageHandler(app: App): void {
       return ignoreSlackInbound("unauthorized_user");
     }
 
+    // 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
+    // @mentions the bot. Checked before the workflow event, buffering, routing,
+    // or any AI call.
+    if (await shouldSkipLeftSlackThread(msg.channel, msg.thread_ts, botMentioned)) {
+      console.log(`[Slack] Skipping message in left thread ${msg.channel}/${msg.thread_ts}`);
+      return ignoreSlackInbound("thread_left");
+    }
+
     // Resolve canonical user identity via the three-step cascade:
     //   fast-path alias lookup → enrich+auto-link by email → unmapped tracker.
     // Returns undefined when no email is recoverable; task creation proceeds
@@ -519,9 +532,6 @@ export function registerMessageHandler(app: App): void {
     }
     const botUserId = cachedBotUserId;
 
-    // Check if bot was mentioned (in original text only)
-    const botMentioned = !!msg.text?.includes(`<@${botUserId}>`);
-
     // Detect assistant thread context. Bolt's Assistant middleware claims DM thread
     // messages with no subtype or `file_share` (`isAssistantMessage` in @slack/bolt), so
     // those — file uploads included — are handled in assistant.ts. An assistant-thread
@@ -862,6 +872,7 @@ export function registerMessageHandler(app: App): void {
                   message: taskDescription,
                   messageTimestamps: [msg.ts],
                   requestedByUserId,
+                  slackUserId: msg.user,
                 })
               : null;
           if (steering) {
@@ -937,12 +948,14 @@ export function registerMessageHandler(app: App): void {
       } catch (error) {
         // A policy block is an answered outcome; anything else is a failure the
         // user sees as "could not assign" and the dispatcher must not call success.
-        if (!(error instanceof TaskCreationBlockedError)) {
+        const blocked =
+          error instanceof TaskCreationBlockedError || error instanceof SteeringBlockedError;
+        if (!blocked) {
           reportSlackInboundFailure("task_creation_error");
         }
         results.failed.push({
           agentName: agent.name,
-          reason: error instanceof TaskCreationBlockedError ? error.reason : "error",
+          reason: blocked ? error.reason : "error",
         });
       }
     }

package/src/slack/left-threads.ts

@@ -0,0 +1,65 @@
+import { deleteKv, getKv, upsertKv } from "../be/db";
+import { isEnvFlagEnabled } from "../utils/env-flag";
+
+/**
+ * Slack threads the swarm left via `slack-leave-thread`.
+ *
+ * A left thread drops every inbound message that does not @mention the bot,
+ * in code, before buffering, routing, or any AI call. A mention clears the
+ * state and the message is handled as usual. Stored in kv_entries so a
+ * restart keeps it.
+ */
+export const SLACK_LEFT_THREAD_KV_NAMESPACE = "slack-left-thread";
+
+/** Operator flag that turns the `slack-leave-thread` tool off. */
+export const SLACK_LEAVE_THREAD_DISABLE = "SLACK_LEAVE_THREAD_DISABLE";
+
+/**
+ * Read at call time, not cached: a global swarm_config row is hydrated into
+ * process.env on every config reload, so a flip applies without a restart.
+ */
+export function isSlackLeaveThreadDisabled(): boolean {
+  return isEnvFlagEnabled(SLACK_LEAVE_THREAD_DISABLE, false);
+}
+
+function threadKey(channelId: string, threadTs: string): string {
+  return `${channelId}:${threadTs}`;
+}
+
+export async function leaveSlackThread(
+  channelId: string,
+  threadTs: string,
+  agentId: string,
+): Promise<void> {
+  await upsertKv({
+    namespace: SLACK_LEFT_THREAD_KV_NAMESPACE,
+    key: threadKey(channelId, threadTs),
+    value: { agentId, leftAt: new Date().toISOString() },
+    valueType: "json",
+  });
+}
+
+export async function isSlackThreadLeft(channelId: string, threadTs: string): Promise<boolean> {
+  return (await getKv(SLACK_LEFT_THREAD_KV_NAMESPACE, threadKey(channelId, threadTs))) !== null;
+}
+
+/**
+ * Inbound gate for left threads. Returns true when the message must be dropped:
+ * the thread is left and the message does not @mention the bot. A mention
+ * clears the left state and returns false.
+ */
+export async function shouldSkipLeftSlackThread(
+  channelId: string,
+  threadTs: string | undefined,
+  botMentioned: boolean,
+): Promise<boolean> {
+  if (!threadTs) return false;
+  const key = threadKey(channelId, threadTs);
+  if (botMentioned) {
+    if (await deleteKv(SLACK_LEFT_THREAD_KV_NAMESPACE, key)) {
+      console.log(`[Slack] Rejoined left thread ${key}: bot mentioned`);
+    }
+    return false;
+  }
+  return isSlackThreadLeft(channelId, threadTs);
+}

package/src/slack/steering.ts

@@ -9,6 +9,7 @@ export interface SlackThreadSteeringRequest {
   message: string;
   messageTimestamps?: string[];
   requestedByUserId?: string;
+  slackUserId?: string;
 }
 
 export interface SlackThreadSteeringResult {
@@ -52,6 +53,8 @@ export async function requestSlackThreadSteering(
     source: "slack",
     createdByKind: "user",
     createdByUserId: args.requestedByUserId,
+    messageTimestamps: args.messageTimestamps,
+    slack: { channelId: args.channelId, threadTs: args.threadTs, userId: args.slackUserId },
   });
   for (const messageTs of args.messageTimestamps ?? []) {
     await createLogEntry({

package/src/slack/thread-buffer.ts

@@ -4,6 +4,7 @@ import {
   getLeadAgent,
   getMostRecentTaskInThread,
 } from "../be/db";
+import { SteeringBlockedError } from "../be/steering";
 import { findUserByExternalId } from "../be/users";
 import { createAdditiveBuffer } from "../tasks/additive-buffer";
 import { slackContextKey } from "../tasks/context-key";
@@ -21,6 +22,7 @@ import {
   fetchSlackFiles,
   notifySlackFileFailures,
 } from "./inbound-files";
+import { isSlackThreadLeft } from "./left-threads";
 import { extractSlackMessageText } from "./message-text";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
 import { getAgentDisplayName, getAgentSlackIcon } from "./responses";
@@ -164,6 +166,12 @@ async function slackFlush(
     return;
   }
   const { channelId, threadTs } = split;
+  // The thread was left (slack-leave-thread) while these replies waited. Only
+  // non-mentions are buffered, so none of them rejoins it.
+  if (await isSlackThreadLeft(channelId, threadTs)) {
+    console.log(`[Slack] Buffer flush: dropping ${items.length} message(s) in left thread ${key}`);
+    return;
+  }
   // Buffer is guaranteed to have at least one item — the first carries the
   // original requester's userId (same semantics as the pre-refactor version).
   const originalRequesterId = items[0]!.userId;
@@ -226,22 +234,38 @@ async function slackFlush(
 
   // Steering carries text only. As on the mention path, files need a follow-up
   // task so its attachments exist before a worker can claim it.
-  const steering =
-    files.length === 0
-      ? await requestSlackThreadSteering({
-          channelId,
-          threadTs,
-          message:
-            nextSenderIndex === -1
-              ? combinedText
-              : await rewriteSlackMentions(
-                  steeringItems.map((item) => item.text).join("\n---\n"),
-                  botUserId,
-                ),
-          messageTimestamps: steeringItems.map((item) => item.ts),
-          requestedByUserId,
-        })
-      : null;
+  let steering: Awaited<ReturnType<typeof requestSlackThreadSteering>>;
+  try {
+    steering =
+      files.length === 0
+        ? await requestSlackThreadSteering({
+            channelId,
+            threadTs,
+            message:
+              nextSenderIndex === -1
+                ? combinedText
+                : await rewriteSlackMentions(
+                    steeringItems.map((item) => item.text).join("\n---\n"),
+                    botUserId,
+                  ),
+            messageTimestamps: steeringItems.map((item) => item.ts),
+            requestedByUserId,
+            slackUserId: originalRequesterId,
+          })
+        : null;
+  } catch (error) {
+    if (!(error instanceof SteeringBlockedError)) throw error;
+    console.info("[Slack] pre.task.steer blocked:", error.extension.name, error.reason);
+    if (app) {
+      for (const item of steeringItems) {
+        await ackSlackMessage(app.client, channelId, item.ts, "no_entry");
+      }
+    }
+    if (nextSenderIndex !== -1) {
+      await slackFlush(items.slice(nextSenderIndex), key, immediate);
+    }
+    return;
+  }
   if (steering) {
     console.log(
       `[Slack] Buffer flushed → steering ${steering.result.outcome} for task ${steering.task.id}`,

package/src/tests/acp-adapter.test.ts

@@ -1179,6 +1179,85 @@ ${serveFakeAcpAgent("FakeCopilot")}
     expect(toAcpMcpServers(null)).toEqual([]);
   });
 
+  test("a target without the opt-in hooks keeps its session/new payload, MCP URL and no steering", async () => {
+    const cwd = makeTempDir();
+    const agentPath = join(cwd, "fake-acp-hooks-off.ts");
+    const captureFile = join(cwd, "session-new.json");
+    await Bun.write(
+      agentPath,
+      `
+import { Readable, Writable } from "node:stream";
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from "${ACP_SDK_PATH}";
+class FakeAgent {
+  constructor(connection) { this.connection = connection; }
+  async initialize() {
+    // Advertises every capability the opt-in hooks key off; a target without
+    // the hooks must ignore them.
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: true,
+        mcpCapabilities: { http: true, sse: false },
+        sessionCapabilities: { resume: {}, systemPrompt: {} },
+        _meta: { fx: { steering: true } },
+      },
+      agentInfo: { name: "fake", version: "9.9.9" },
+    };
+  }
+  async newSession(params) {
+    await Bun.write(${JSON.stringify(captureFile)}, JSON.stringify(params));
+    return { sessionId: "hooks-off-1" };
+  }
+  async prompt() { return { stopReason: "end_turn" }; }
+  async cancel() {}
+}
+${serveFakeAcpAgent("FakeAgent")}
+`,
+    );
+    const { close: closeTokenStub, apiUrl } = await startTokenStubServer(
+      "hooks-off-token",
+      "aseph_hooksofftoken1234567890",
+    );
+    // A reachable, plain-HTTP, non-loopback URL: only requiresSecureMcpUrl rewrites it.
+    const publicStyleUrl = apiUrl.replace("127.0.0.1", "0.0.0.0");
+    try {
+      const adapter = new ACPAdapter();
+      const session = await adapter.createSession(
+        baseConfig({
+          cwd,
+          apiUrl: publicStyleUrl,
+          resumeSessionId: "ignored-without-a-resume-hook",
+          env: {
+            PATH: process.env.PATH ?? "",
+            HOME: process.env.HOME ?? "",
+            ACP_TARGET_COMMAND: "bun",
+            ACP_TARGET_ARGS: JSON.stringify([agentPath]),
+          },
+        }),
+      );
+      const events: ProviderEvent[] = [];
+      session.onEvent((event) => events.push(event));
+      await session.waitForCompletion();
+
+      expect(session.sessionId).toBe("hooks-off-1");
+      expect(session.deliverSteering).toBeUndefined();
+      expect(await adapter.canResume("hooks-off-1")).toBe(false);
+      const params = JSON.parse(await Bun.file(captureFile).text());
+      expect(Object.keys(params).sort()).toEqual(["cwd", "mcpServers"]);
+      expect(params.mcpServers.map((server: { url: string }) => server.url)).toEqual([
+        `${publicStyleUrl}/mcp`,
+      ]);
+      // Every ACP target records the agent's own version on session_init.
+      expect(events.find((event) => event.type === "session_init")).toMatchObject({
+        sessionId: "hooks-off-1",
+        provider: "acp",
+        harnessVariantMeta: { version: "9.9.9" },
+      });
+    } finally {
+      await closeTokenStub();
+    }
+  });
+
   test("completes before the revoke response and logs a failed revocation", async () => {
     const cwd = makeTempDir();
     const agentPath = join(cwd, "fake-acp-ephem-agent.ts");

package/src/tests/base-prompt.test.ts

@@ -1290,6 +1290,18 @@ describe("getBasePrompt: harness tool discovery", () => {
     expect(result).toContain('import { store_progress } from "agent-swarm"');
   });
 
+  test("fx gets capability_search guidance with mcp_swarm_ tool names", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      provider: "fx",
+      traits: { ...localTraits, hasToolSearch: false },
+    });
+    expect(result).not.toContain(deferred);
+    expect(result).not.toContain("already in your tool list");
+    expect(result).toContain("`capability_search`");
+    expect(result).toContain("`store-progress` is `mcp_swarm_store-progress`");
+  });
+
   test("codex gets exec guidance with the normalized tool name", async () => {
     const result = await getBasePrompt({
       ...minimalArgs,