@desplega.ai/agent-swarm 1.119.6 → 1.121.0

package/src/server.ts

@@ -5,6 +5,7 @@ import { startPricingRefreshLoop } from "./be/pricing-refresh";
 import { ensureRbacSeedsSynced } from "./be/rbac-roles";
 import { seedPricingFromModelsDev } from "./be/seed-pricing";
 import { registerGithubTaskReactions } from "./github/task-reactions";
+import { loadGlobalConfigsIntoEnv } from "./http/core";
 import { isRbacEnabled } from "./rbac";
 import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
@@ -160,20 +161,83 @@ import {
 } from "./tools/workflows";
 import { resolveScriptsOnlyMode } from "./utils/scripts-only-mode";
 
+// Every known capability, including the ones disabled by default. Exported for
+// surfaces that must see the full tool registry regardless of deployment
+// defaults (tests, drift checks).
+export const ALL_CAPABILITIES = [
+  "core",
+  "task-pool",
+  "scripts",
+  "config",
+  "prompt-templates",
+  "mcp",
+  "profiles",
+  "services",
+  "scheduling",
+  "memory",
+  "workflows",
+  "pages",
+  "metrics",
+  "kv",
+  "slack",
+  "tracker",
+  "skills",
+  "messaging",
+  "repo",
+  "agentmail",
+  "kapso",
+  "swarm-x",
+] as const;
+
+type CAPABILITIES_T = (typeof ALL_CAPABILITIES)[number];
+
 // Capability-based feature flags
-// Default: all capabilities enabled
-const DEFAULT_CAPABILITIES =
-  "core,task-pool,profiles,services,scheduling,memory,workflows,pages,metrics,kv";
-const CAPABILITIES = new Set(
-  (process.env.CAPABILITIES || DEFAULT_CAPABILITIES).split(",").map((s) => s.trim()),
-);
-
-export function hasCapability(cap: string): boolean {
-  return CAPABILITIES.has(cap);
+const DEFAULT_CAPABILITIES: string = [
+  "core",
+  "task-pool",
+  "scripts",
+  "config",
+  "mcp",
+  "profiles",
+  "scheduling",
+  "memory",
+  "workflows",
+  "pages",
+  "metrics",
+  "kv",
+  "slack",
+  "tracker",
+  "skills",
+  "repo",
+  //
+  // Disabled by default
+  //
+  // "services",
+  // "prompt-templates",
+  // "messaging",
+  // "swarm-x",
+  // "agentmail",
+  // "kapso",
+].join(",");
+
+// Note: unknown names are kept (they never match hasCapability); workers
+// reuse this env var for free-form skill tags, so dropping them here would
+// break agent capability declarations. Empty entries (trailing commas) are
+// filtered so they can't leak into enabledCapabilities payloads.
+const getCapabilities = (): Set<CAPABILITIES_T> =>
+  new Set(
+    (process.env.CAPABILITIES || DEFAULT_CAPABILITIES)
+      .split(",")
+      .map((s) => s.trim() as CAPABILITIES_T)
+      .filter((s) => s.length > 0),
+  );
+
+export function hasCapability(cap: CAPABILITIES_T): boolean {
+  return getCapabilities().has(cap);
 }
 
-export function getEnabledCapabilities(): string[] {
-  return Array.from(CAPABILITIES);
+export function getEnabledCapabilities(): CAPABILITIES_T[] {
+  return Array.from(getCapabilities());
 }
 
 /**
@@ -187,16 +251,28 @@ export function isScriptsOnlyMcp(): boolean {
   return resolveScriptsOnlyMode({ env: process.env.SCRIPTS_ONLY_MCP });
 }
 
-export function createServer(opts: { scriptsOnly?: boolean } = {}) {
+export function createServer(opts: { scriptsOnly?: boolean; fullSurface?: boolean } = {}) {
+  // Reload env
+  loadGlobalConfigsIntoEnv(true);
+
+  // Capability flags shape the externally exposed MCP tool list only. Internal
+  // full-surface consumers (the scripts SDK bridge, drift-check tests) pass
+  // fullSurface to register every tool group regardless of CAPABILITIES.
+  // This shadows the module-level hasCapability for the registrations below.
+  const hasCapability = (cap: CAPABILITIES_T): boolean =>
+    opts.fullSurface === true || getCapabilities().has(cap);
+
   // Initialize database with WAL mode
   // Uses DATABASE_PATH env var for Docker volume compatibility (WAL needs .sqlite, .sqlite-wal, .sqlite-shm on same filesystem)
   initDb(process.env.DATABASE_PATH);
+
   // Phase 2: project the vendored models.dev snapshot into the pricing table.
   // Idempotent (INSERT OR IGNORE keyed on PK with effective_from=0); safe to
   // call on every boot. See src/be/seed-pricing.ts for the projection logic
   // and the manual-override constants for runtime-fee / ACU pricing.
   seedPricingFromModelsDev();
   startPricingRefreshLoop();
+
   try {
     ensureRbacSeedsSynced();
   } catch (err) {
@@ -233,94 +309,69 @@ export function createServer(opts: { scriptsOnly?: boolean } = {}) {
     registerScriptDeleteTool(server);
     registerScriptQueryTypesTool(server);
     registerScriptRunsTools(server);
+
     return server;
   }
 
-  // Core tools - always registered
-  registerJoinSwarmTool(server);
-  registerPollTaskTool(server);
-  registerGetSwarmTool(server);
-  registerGetTasksTool(server);
-  registerGetMetricsTool(server);
-  registerSendTaskTool(server);
-  registerGetTaskDetailsTool(server);
-  registerStoreProgressTool(server);
-  registerMyAgentInfoTool(server);
-  registerCancelTaskTool(server);
-
-  // User identity tools - always registered
-  registerResolveUserTool(server);
-  registerManageUserTool(server); // self-guards with lead check
-
-  // Debug tools - always registered (self-guards with lead check)
-  registerDbQueryTool(server);
-  registerGetOauthAccessTokenTool(server);
-
-  // Swarm config tools - always registered (config management is fundamental)
-  registerSetConfigTool(server);
-  registerGetConfigTool(server);
-  registerListConfigTool(server);
-  registerDeleteConfigTool(server);
-  registerCredentialBindingsTool(server);
-
-  // Repo management tools - always registered (repo config is fundamental)
-  registerGetReposTool(server);
-  registerUpdateRepoTool(server);
-
-  // Prompt template tools - always registered (prompt management is fundamental)
-  registerListPromptTemplatesTool(server);
-  registerGetPromptTemplateTool(server);
-  registerSetPromptTemplateTool(server);
-  registerDeletePromptTemplateTool(server);
-  registerPreviewPromptTemplateTool(server);
-
-  // Reusable script catalog tools - always registered (HTTP MCP only in v1).
-  registerScriptSearchTool(server);
-  registerScriptConnectionsTool(server);
-  registerScriptApisTool(server);
-  registerScriptRunTool(server);
-  registerScriptUpsertTool(server);
-  registerScriptDeleteTool(server);
-  registerScriptQueryTypesTool(server);
-  registerScriptRunsTools(server);
-
-  // External command routes - mirrors the `agent-swarm x ...` CLI surface.
-  registerSwarmXTool(server);
-
-  // Slack integration tools (always registered, will no-op if Slack not configured)
-  registerSlackReplyTool(server);
-  registerSlackReadTool(server);
-  registerSlackPostTool(server);
-  registerSlackStartThreadTool(server);
-  registerSlackListChannelsTool(server);
-  registerSlackUploadFileTool(server);
-  registerSlackDownloadFileTool(server);
-  registerSlackDeleteTool(server);
-  registerSlackUpdateTool(server);
-
-  // AgentMail integration tool (always registered, self-service inbox mapping)
-  registerRegisterAgentmailInboxTool(server);
-
-  // Kapso/WhatsApp integration tools (native inbound provisioning + outbound)
-  registerRegisterKapsoNumberTool(server);
-  registerUnregisterKapsoNumberTool(server);
-  registerSendWhatsappMessageTool(server);
-  registerReplyWhatsappMessageTool(server);
+  // Start of default-enabled capabilities
+
+  // Core capability - swarm membership, task flow, progress, user identity, and lead debug tools
+  if (hasCapability("core")) {
+    registerJoinSwarmTool(server);
+    registerPollTaskTool(server);
+    registerGetSwarmTool(server);
+    registerGetTasksTool(server);
+    registerGetMetricsTool(server);
+    registerSendTaskTool(server);
+    registerGetTaskDetailsTool(server);
+    registerStoreProgressTool(server);
+    registerMyAgentInfoTool(server);
+    registerCancelTaskTool(server);
+
+    // User identity tools
+    registerResolveUserTool(server);
+    registerManageUserTool(server); // self-guards with lead check
+
+    // Debug tools (self-guard with lead check)
+    registerDbQueryTool(server);
+    registerGetOauthAccessTokenTool(server);
+  }
 
   // Task pool capability - task pool operations (create unassigned, claim, release, accept, reject)
   if (hasCapability("task-pool")) {
     registerTaskActionTool(server);
   }
 
-  // Core messaging tools - always registered (post/read are CORE_TOOLS)
-  registerPostMessageTool(server);
-  registerReadMessagesTool(server);
+  // Config capability - swarm config management and credential bindings
+  if (hasCapability("config")) {
+    registerSetConfigTool(server);
+    registerGetConfigTool(server);
+    registerListConfigTool(server);
+    registerDeleteConfigTool(server);
+    registerCredentialBindingsTool(server);
+  }
 
-  // Messaging capability - channel management (CRUD on channels)
-  if (hasCapability("messaging")) {
-    registerListChannelsTool(server);
-    registerCreateChannelTool(server);
-    registerDeleteChannelTool(server);
+  // Scripts capability - reusable script catalog (HTTP MCP only in v1)
+  if (hasCapability("scripts")) {
+    registerScriptSearchTool(server);
+    registerScriptConnectionsTool(server);
+    registerScriptApisTool(server);
+    registerScriptRunTool(server);
+    registerScriptUpsertTool(server);
+    registerScriptDeleteTool(server);
+    registerScriptQueryTypesTool(server);
+    registerScriptRunsTools(server);
+  }
+
+  // MCP capability - managed MCP server registry (CRUD + install/uninstall)
+  if (hasCapability("mcp")) {
+    registerMcpServerCreateTool(server);
+    registerMcpServerUpdateTool(server);
+    registerMcpServerDeleteTool(server);
+    registerMcpServerGetTool(server);
+    registerMcpServerListTool(server);
+    registerMcpServerInstallTool(server);
+    registerMcpServerUninstallTool(server);
   }
 
   // Profiles capability - agent profile management
@@ -330,12 +381,10 @@ export function createServer(opts: { scriptsOnly?: boolean } = {}) {
     registerContextDiffTool(server);
   }
 
-  // Services capability - PM2/background service registry
-  if (hasCapability("services")) {
-    registerRegisterServiceTool(server);
-    registerUnregisterServiceTool(server);
-    registerListServicesTool(server);
-    registerUpdateServiceStatusTool(server);
+  // Repo capability - repository configuration management
+  if (hasCapability("repo")) {
+    registerGetReposTool(server);
+    registerUpdateRepoTool(server);
   }
 
   // Scheduling capability - scheduled task management
@@ -359,11 +408,13 @@ export function createServer(opts: { scriptsOnly?: boolean } = {}) {
   }
 
   // Tracker capability - external issue tracker integration
-  registerTrackerStatusTool(server);
-  registerTrackerLinkTaskTool(server);
-  registerTrackerUnlinkTool(server);
-  registerTrackerSyncStatusTool(server);
-  registerTrackerMapAgentTool(server);
+  if (hasCapability("tracker")) {
+    registerTrackerStatusTool(server);
+    registerTrackerLinkTaskTool(server);
+    registerTrackerUnlinkTool(server);
+    registerTrackerSyncStatusTool(server);
+    registerTrackerMapAgentTool(server);
+  }
 
   // Workflows capability - DAG-based automation workflows
   if (hasCapability("workflows")) {
@@ -382,35 +433,34 @@ export function createServer(opts: { scriptsOnly?: boolean } = {}) {
     registerRequestHumanInputTool(server);
   }
 
-  // Skills - always registered (skill management is available to all agents)
-  registerSkillCreateTool(server);
-  registerSkillUpdateTool(server);
-  registerSkillDeleteTool(server);
-  registerSkillGetTool(server);
-  registerSkillGetFileTool(server);
-  registerSkillListTool(server);
-  registerSkillSearchTool(server);
-  registerSkillInstallTool(server);
-  registerSkillUninstallTool(server);
-  registerSkillInstallRemoteTool(server);
-  registerSkillSyncRemoteTool(server);
-  registerSkillPublishTool(server);
+  // Skills capability - installable skill packages (create, search, install, publish)
+  if (hasCapability("skills")) {
+    registerSkillCreateTool(server);
+    registerSkillUpdateTool(server);
+    registerSkillDeleteTool(server);
+    registerSkillGetTool(server);
+    registerSkillGetFileTool(server);
+    registerSkillListTool(server);
+    registerSkillSearchTool(server);
+    registerSkillInstallTool(server);
+    registerSkillUninstallTool(server);
+    registerSkillInstallRemoteTool(server);
+    registerSkillSyncRemoteTool(server);
+    registerSkillPublishTool(server);
+  }
 
   // Pages capability - DB-backed lightweight artifacts (HTML / JSON specs).
-  // Enabled by default (added to DEFAULT_CAPABILITIES in step-9 of the
-  // db-backed-pages plan). Operators can disable via explicit
-  // `CAPABILITIES=...` env without `pages`.
   if (hasCapability("pages")) {
     registerCreatePageTool(server);
     registerDeletePageTool(server);
   }
 
+  // Metrics capability - time-series metrics (DB-backed, for dashboards).
   if (hasCapability("metrics")) {
     registerCreateMetricTool(server);
   }
 
   // KV capability — namespaced Redis-like key/value (see src/be/migrations/061_kv_store.sql).
-  // Enabled by default; opt out via `CAPABILITIES=...` without `kv`.
   if (hasCapability("kv")) {
     registerKvGetTool(server);
     registerKvSetTool(server);
@@ -419,14 +469,68 @@ export function createServer(opts: { scriptsOnly?: boolean } = {}) {
     registerKvListTool(server);
   }
 
-  // MCP Servers - always registered
-  registerMcpServerCreateTool(server);
-  registerMcpServerUpdateTool(server);
-  registerMcpServerDeleteTool(server);
-  registerMcpServerGetTool(server);
-  registerMcpServerListTool(server);
-  registerMcpServerInstallTool(server);
-  registerMcpServerUninstallTool(server);
+  // Slack capability - Slack integration tools (no-op if Slack is not configured)
+  if (hasCapability("slack")) {
+    registerSlackReplyTool(server);
+    registerSlackReadTool(server);
+    registerSlackPostTool(server);
+    registerSlackStartThreadTool(server);
+    registerSlackListChannelsTool(server);
+    registerSlackUploadFileTool(server);
+    registerSlackDownloadFileTool(server);
+    registerSlackDeleteTool(server);
+    registerSlackUpdateTool(server);
+  }
+
+  // End of default-enabled capabilities
+  // ----------------------------
+  // Start of default-disabled capabilities
+
+  // Prompt-templates capability - prompt template management (list/get/set/delete/preview)
+  if (hasCapability("prompt-templates")) {
+    registerListPromptTemplatesTool(server);
+    registerGetPromptTemplateTool(server);
+    registerSetPromptTemplateTool(server);
+    registerDeletePromptTemplateTool(server);
+    registerPreviewPromptTemplateTool(server);
+  }
+
+  // Agentmail capability - AgentMail integration (self-service inbox mapping)
+  if (hasCapability("agentmail")) {
+    registerRegisterAgentmailInboxTool(server);
+  }
+
+  // Kapso capability - Kapso/WhatsApp integration (native inbound provisioning + outbound)
+  if (hasCapability("kapso")) {
+    registerRegisterKapsoNumberTool(server);
+    registerUnregisterKapsoNumberTool(server);
+    registerSendWhatsappMessageTool(server);
+    registerReplyWhatsappMessageTool(server);
+  }
+
+  // Swarm-x capability - external command routes mirroring the `agent-swarm x ...` CLI surface
+  if (hasCapability("swarm-x")) {
+    registerSwarmXTool(server);
+  }
+
+  // Messaging capability - internal swarm chat (post/read messages, channel CRUD)
+  if (hasCapability("messaging")) {
+    registerPostMessageTool(server);
+    registerReadMessagesTool(server);
+
+    // Channel management (CRUD on channels)
+    registerListChannelsTool(server);
+    registerCreateChannelTool(server);
+    registerDeleteChannelTool(server);
+  }
+
+  // Services capability - PM2/background service registry
+  if (hasCapability("services")) {
+    registerRegisterServiceTool(server);
+    registerUnregisterServiceTool(server);
+    registerListServicesTool(server);
+    registerUpdateServiceStatusTool(server);
+  }
 
   return server;
 }

package/src/tests/agent-avatar-resolution.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import { getAgentColorToken, resolveAgentColor } from "../../apps/ui/src/lib/agent-color";
+import {
+  AVATAR_ICON_CATALOG,
+  getAgentIcon,
+  resolveAgentIcon,
+} from "../../apps/ui/src/lib/agent-icon";
+
+/**
+ * Covers the pure avatar-resolution logic behind the customizable agent
+ * avatar feature (icon + color). These are the deterministic building
+ * blocks consumed by `agent-avatar.tsx` and the appearance picker — no React
+ * rendering involved, so they're testable with the existing `bun test`
+ * harness (apps/ui has no component-test infra; see PR discussion).
+ */
+describe("agent avatar resolution", () => {
+  describe("getAgentIcon (deterministic fallback)", () => {
+    test("lead always resolves to Crown, regardless of id", () => {
+      expect(getAgentIcon({ agentId: "any-id", isLead: true })).toBe(AVATAR_ICON_CATALOG.crown);
+      expect(getAgentIcon({ role: "lead", agentId: "any-id" })).toBe(AVATAR_ICON_CATALOG.crown);
+      expect(getAgentIcon({ agentName: "Lead", agentId: "any-id" })).toBe(
+        AVATAR_ICON_CATALOG.crown,
+      );
+    });
+
+    test("same agentId always resolves to the same icon (deterministic)", () => {
+      const first = getAgentIcon({ agentId: "agent-123" });
+      const second = getAgentIcon({ agentId: "agent-123" });
+      expect(first).toBe(second);
+    });
+
+    test("different agentIds can resolve to different icons", () => {
+      // Not a strict guarantee for every pair (hash collisions are possible),
+      // but across a spread of ids we should see more than one icon.
+      const icons = new Set(
+        Array.from({ length: 20 }, (_, i) => getAgentIcon({ agentId: `worker-${i}` })),
+      );
+      expect(icons.size).toBeGreaterThan(1);
+    });
+
+    test("empty/missing seed falls back to Bot", () => {
+      expect(getAgentIcon({})).toBe(AVATAR_ICON_CATALOG.bot);
+      expect(getAgentIcon({ agentId: "", agentName: "" })).toBe(AVATAR_ICON_CATALOG.bot);
+    });
+  });
+
+  describe("resolveAgentIcon (custom avatar overrides deterministic fallback)", () => {
+    test("a known catalog icon wins over the deterministic fallback", () => {
+      const avatar = { type: "lucide" as const, icon: "trophy" };
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentIcon(avatar, fallback)).toBe(AVATAR_ICON_CATALOG.trophy);
+      // Sanity check it's actually overriding, not coincidentally equal.
+      expect(resolveAgentIcon(avatar, fallback)).not.toBe(getAgentIcon(fallback));
+    });
+
+    test("an unknown icon name falls back to the deterministic default", () => {
+      const avatar = { type: "lucide" as const, icon: "not-a-real-icon" };
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentIcon(avatar, fallback)).toBe(getAgentIcon(fallback));
+    });
+
+    test("null/undefined avatar (reset to default) falls back to the deterministic default", () => {
+      const fallback = { agentId: "some-agent", isLead: false };
+      expect(resolveAgentIcon(null, fallback)).toBe(getAgentIcon(fallback));
+      expect(resolveAgentIcon(undefined, fallback)).toBe(getAgentIcon(fallback));
+    });
+  });
+
+  describe("getAgentColorToken (deterministic fallback)", () => {
+    test("lead always resolves to primary", () => {
+      expect(getAgentColorToken({ role: "lead", agentId: "x" })).toBe("primary");
+      expect(getAgentColorToken({ agentName: "Lead", agentId: "x" })).toBe("primary");
+    });
+
+    test("same agentId always resolves to the same token (deterministic)", () => {
+      expect(getAgentColorToken({ agentId: "agent-abc" })).toBe(
+        getAgentColorToken({ agentId: "agent-abc" }),
+      );
+    });
+
+    test("empty/missing seed falls back to action-default", () => {
+      expect(getAgentColorToken({})).toBe("action-default");
+    });
+  });
+
+  describe("resolveAgentColor (custom hex overrides deterministic fallback)", () => {
+    test("a custom hex wins over the deterministic token", () => {
+      const avatar = { type: "lucide" as const, icon: "star", color: "#ff00aa" };
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentColor(avatar, fallback)).toEqual({ kind: "custom", hex: "#ff00aa" });
+    });
+
+    test("a lucide avatar with no color falls back to the deterministic token", () => {
+      const avatar = { type: "lucide" as const, icon: "star" };
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentColor(avatar, fallback)).toEqual({
+        kind: "token",
+        token: getAgentColorToken(fallback),
+      });
+    });
+
+    test("an empty-string color is treated as unset (falls back)", () => {
+      const avatar = { type: "lucide" as const, icon: "star", color: "" };
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentColor(avatar, fallback)).toEqual({
+        kind: "token",
+        token: getAgentColorToken(fallback),
+      });
+    });
+
+    test("null/undefined avatar (reset to default) falls back to the deterministic token", () => {
+      const fallback = { agentId: "some-agent" };
+      expect(resolveAgentColor(null, fallback)).toEqual({
+        kind: "token",
+        token: getAgentColorToken(fallback),
+      });
+      expect(resolveAgentColor(undefined, fallback)).toEqual({
+        kind: "token",
+        token: getAgentColorToken(fallback),
+      });
+    });
+  });
+});

package/src/tests/agents-list-model-display.test.ts

@@ -44,6 +44,11 @@ describe("agents list model display", () => {
   });
 
   test("presents latest Anthropic direct model ids as readable labels", () => {
+    expect(getAgentModelPresentation("claude-opus-5")).toMatchObject({
+      label: "Claude Opus 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
     expect(getAgentModelPresentation("claude-fable-5")).toMatchObject({
       label: "Claude Fable 5",
       provider: "Anthropic",
@@ -59,6 +64,11 @@ describe("agents list model display", () => {
       provider: "Anthropic",
       providerId: "anthropic",
     });
+    expect(getAgentModelPresentation("opus")).toMatchObject({
+      label: "Claude Opus 5",
+      provider: "Anthropic",
+      providerId: "anthropic",
+    });
   });
 
   // ── Phase 6 (reasoning-effort plan) ─────────────────────────────────────────

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

@@ -739,3 +739,75 @@ describe("getBasePrompt — conditional Slack templates", () => {
     expect(result).toContain("C123");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Server capability gating (serverCapabilities = the API server's enabled
+// tool groups, reported on registration; distinct from agent skill tags)
+// ---------------------------------------------------------------------------
+
+describe("getBasePrompt — serverCapabilities gating", () => {
+  test("messaging section kept when serverCapabilities is unknown (legacy servers registered the tools unconditionally)", async () => {
+    const result = await getBasePrompt(minimalArgs);
+    expect(result).toContain("post-message");
+    expect(result).toContain("read-messages");
+  });
+
+  test("messaging section omitted when server capabilities omit messaging", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core"],
+    });
+    expect(result).not.toContain("post-message");
+    expect(result).not.toContain("read-messages");
+  });
+
+  test("messaging section included when the server enables messaging", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "messaging"],
+    });
+    expect(result).toContain("#### Swarm Messaging");
+    expect(result).toContain("post-message");
+    expect(result).toContain("read-messages");
+  });
+
+  test("services section dropped when server capabilities omit services", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core"],
+    });
+    expect(result).not.toContain("register-service");
+  });
+
+  test("services section kept for legacy servers that report no capabilities", async () => {
+    const result = await getBasePrompt(minimalArgs);
+    expect(result).toContain("register-service");
+  });
+
+  test("server-enabled services shows section even without the agent skill tag", async () => {
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      capabilities: ["typescript"],
+      serverCapabilities: ["core", "services"],
+    });
+    expect(result).toContain("register-service");
+  });
+
+  test("slack section dropped when server capabilities omit slack", async () => {
+    enableSlackPromptTools();
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core"],
+    });
+    expect(result).not.toContain("slack-list-channels");
+  });
+
+  test("slack section kept when the server enables slack", async () => {
+    enableSlackPromptTools();
+    const result = await getBasePrompt({
+      ...minimalArgs,
+      serverCapabilities: ["core", "slack"],
+    });
+    expect(result).toContain("slack-list-channels");
+  });
+});

package/src/tests/claude-managed-adapter.test.ts

@@ -802,6 +802,12 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
   });
 
   test("CLAUDE_MANAGED_MODEL_PRICING covers sonnet, opus, haiku at minimum", () => {
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-opus-5"]).toEqual({
+      inputPerMillion: 5.0,
+      outputPerMillion: 25.0,
+      cacheReadPerMillion: 0.5,
+      cacheWritePerMillion: 6.25,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-fable-5"]).toEqual({
       inputPerMillion: 10.0,
       outputPerMillion: 50.0,