@desplega.ai/agent-swarm 1.113.0 → 1.115.0

package/src/server-user.ts

@@ -1,6 +1,15 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import * as z from "zod";
 import pkg from "../package.json";
+import { enqueueAdmissionRow } from "./be/rbac-audit";
+import { getUserGrant } from "./be/rbac-roles";
+import {
+  type AdmissionRbac,
+  decideToolAdmission,
+  isRbacEnabled,
+  type PermissionVerb,
+} from "./rbac";
 import {
   cancelTaskHandler,
   cancelTaskInputSchema,
@@ -22,6 +31,11 @@ import { userCtx } from "./tools/task-tool-ctx";
 import { createToolRegistrar } from "./tools/utils";
 import { ModelTierSchema, type User } from "./types";
 
+type UserToolAdmissionConfig = {
+  annotations?: ToolAnnotations;
+  rbac?: AdmissionRbac;
+};
+
 const userSendTaskInputSchema = z.object({
   task: z.string().min(1).describe("The task description to send."),
   taskType: z.string().max(50).optional().describe("Task type (e.g., 'bug', 'feature', 'review')."),
@@ -38,6 +52,40 @@ const userSendTaskInputSchema = z.object({
   ),
 });
 
+function permission(verb: PermissionVerb): AdmissionRbac {
+  return { permission: verb };
+}
+
+async function maybeDenyUserToolAdmission(
+  user: User,
+  toolName: string,
+  config: UserToolAdmissionConfig,
+): Promise<CallToolResult | undefined> {
+  if (!isRbacEnabled()) return undefined;
+
+  const grant = getUserGrant(user.id);
+  if (grant.grantsAll) return undefined;
+
+  const decision = decideToolAdmission({
+    rbac: config.rbac,
+    readOnly: config.annotations?.readOnlyHint ?? false,
+    grant,
+  });
+  enqueueAdmissionRow({
+    userId: user.id,
+    decision,
+    source: "mcp",
+    toolName,
+  });
+
+  if (decision.allow) return undefined;
+
+  return {
+    isError: true,
+    content: [{ type: "text", text: `Forbidden: ${decision.reason}` }],
+  };
+}
+
 export function createUserServer(user: User): McpServer {
   const server = new McpServer(
     {
@@ -54,69 +102,76 @@ export function createUserServer(user: User): McpServer {
 
   const registerTool = createToolRegistrar(server);
 
-  registerTool(
-    "send-task",
-    {
-      title: "Send a task",
-      annotations: { destructiveHint: false },
-      description: "Creates an unassigned task requested by the authenticated user.",
-      inputSchema: userSendTaskInputSchema,
-      outputSchema: sendTaskOutputSchema,
-    },
-    async (args, info, _meta) =>
-      sendTaskHandler(userCtx(user, info.sessionId), {
-        offerMode: false,
-        allowDuplicate: false,
-        ...args,
-      }),
-  );
+  const sendTaskConfig = {
+    title: "Send a task",
+    annotations: { destructiveHint: false },
+    rbac: permission("task.create.own"),
+    description: "Creates an unassigned task requested by the authenticated user.",
+    inputSchema: userSendTaskInputSchema,
+    outputSchema: sendTaskOutputSchema,
+  };
+  registerTool("send-task", sendTaskConfig, async (args, info, _meta) => {
+    const denied = await maybeDenyUserToolAdmission(user, "send-task", sendTaskConfig);
+    if (denied) return denied;
+    return sendTaskHandler(userCtx(user, info.sessionId), {
+      offerMode: false,
+      allowDuplicate: false,
+      ...args,
+    });
+  });
 
-  registerTool(
-    "get-tasks",
-    {
-      title: "Get tasks",
-      description: "Returns tasks requested by the authenticated user.",
-      annotations: { readOnlyHint: true },
-      inputSchema: getTasksInputSchema,
-      outputSchema: getTasksOutputSchema,
-    },
-    async (args, info, _meta) => getTasksHandler(userCtx(user, info.sessionId), args),
-  );
+  const getTasksConfig = {
+    title: "Get tasks",
+    description: "Returns tasks requested by the authenticated user.",
+    annotations: { readOnlyHint: true },
+    inputSchema: getTasksInputSchema,
+    outputSchema: getTasksOutputSchema,
+  };
+  registerTool("get-tasks", getTasksConfig, async (args, info, _meta) => {
+    const denied = await maybeDenyUserToolAdmission(user, "get-tasks", getTasksConfig);
+    if (denied) return denied;
+    return getTasksHandler(userCtx(user, info.sessionId), args);
+  });
 
-  registerTool(
-    "get-task-details",
-    {
-      title: "Get task details",
-      description: "Returns detailed information about one of your tasks.",
-      annotations: { readOnlyHint: true },
-      inputSchema: getTaskDetailsInputSchema,
-      outputSchema: getTaskDetailsOutputSchema,
-    },
-    async (args, info, _meta) => getTaskDetailsHandler(userCtx(user, info.sessionId), args),
-  );
+  const getTaskDetailsConfig = {
+    title: "Get task details",
+    description: "Returns detailed information about one of your tasks.",
+    annotations: { readOnlyHint: true },
+    inputSchema: getTaskDetailsInputSchema,
+    outputSchema: getTaskDetailsOutputSchema,
+  };
+  registerTool("get-task-details", getTaskDetailsConfig, async (args, info, _meta) => {
+    const denied = await maybeDenyUserToolAdmission(user, "get-task-details", getTaskDetailsConfig);
+    if (denied) return denied;
+    return getTaskDetailsHandler(userCtx(user, info.sessionId), args);
+  });
 
-  registerTool(
-    "cancel-task",
-    {
-      title: "Cancel Task",
-      description: "Cancel one of your pending or in-progress tasks.",
-      annotations: { destructiveHint: true },
-      inputSchema: cancelTaskInputSchema,
-      outputSchema: cancelTaskOutputSchema,
-    },
-    async (args, info, _meta) => cancelTaskHandler(userCtx(user, info.sessionId), args),
-  );
+  const cancelTaskConfig = {
+    title: "Cancel Task",
+    description: "Cancel one of your pending or in-progress tasks.",
+    annotations: { destructiveHint: true },
+    rbac: permission("task.cancel.own"),
+    inputSchema: cancelTaskInputSchema,
+    outputSchema: cancelTaskOutputSchema,
+  };
+  registerTool("cancel-task", cancelTaskConfig, async (args, info, _meta) => {
+    const denied = await maybeDenyUserToolAdmission(user, "cancel-task", cancelTaskConfig);
+    if (denied) return denied;
+    return cancelTaskHandler(userCtx(user, info.sessionId), args);
+  });
 
-  registerTool(
-    "task-action",
-    {
-      title: "Task Pool Action",
-      description: "Move one of your tasks to or from backlog.",
-      inputSchema: taskActionInputSchema,
-      outputSchema: taskActionOutputSchema,
-    },
-    async (args, info, _meta) => taskActionHandler(userCtx(user, info.sessionId), args),
-  );
+  const taskActionConfig = {
+    title: "Task Pool Action",
+    description: "Move one of your tasks to or from backlog.",
+    rbac: permission("task.action.own"),
+    inputSchema: taskActionInputSchema,
+    outputSchema: taskActionOutputSchema,
+  };
+  registerTool("task-action", taskActionConfig, async (args, info, _meta) => {
+    const denied = await maybeDenyUserToolAdmission(user, "task-action", taskActionConfig);
+    if (denied) return denied;
+    return taskActionHandler(userCtx(user, info.sessionId), args);
+  });
 
   return server;
 }

package/src/server.ts

@@ -2,8 +2,10 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import pkg from "../package.json";
 import { initDb } from "./be/db";
 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 { isRbacEnabled } from "./rbac";
 import { registerCancelTaskTool } from "./tools/cancel-task";
 import { registerContextDiffTool } from "./tools/context-diff";
 import { registerContextHistoryTool } from "./tools/context-history";
@@ -13,6 +15,7 @@ import { registerCreatePageTool } from "./tools/create-page";
 import { registerCredentialBindingsTool } from "./tools/credential-bindings";
 import { registerDbQueryTool } from "./tools/db-query";
 import { registerDeleteChannelTool } from "./tools/delete-channel";
+import { registerDeletePageTool } from "./tools/delete-page";
 import { registerGetMetricsTool } from "./tools/get-metrics";
 import { registerGetSwarmTool } from "./tools/get-swarm";
 import { registerGetTaskDetailsTool } from "./tools/get-task-details";
@@ -182,6 +185,14 @@ export function createServer() {
   // and the manual-override constants for runtime-fee / ACU pricing.
   seedPricingFromModelsDev();
   startPricingRefreshLoop();
+  try {
+    ensureRbacSeedsSynced();
+  } catch (err) {
+    console.error("[startup] Failed to sync RBAC seed rows:", err);
+    // RBAC flag-on must fail closed; flag-off deployments should not be bricked
+    // by role-catalog drift for a disabled security feature.
+    if (isRbacEnabled()) throw err;
+  }
 
   // Subscribe API-side integrations to task-lifecycle events. Idempotent.
   // (Inverts the old be/db → github/task-reactions import; see cycle-break #4.)
@@ -366,6 +377,7 @@ export function createServer() {
   // `CAPABILITIES=...` env without `pages`.
   if (hasCapability("pages")) {
     registerCreatePageTool(server);
+    registerDeletePageTool(server);
   }
 
   if (hasCapability("metrics")) {

package/src/slack/assistant.ts

@@ -3,7 +3,7 @@ import { getAgentWorkingOnThread, getLeadAgent, getMostRecentTaskInThread } from
 import { resolveTemplate } from "../prompts/resolver";
 import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
-import { resolveSlackUserId } from "./enrich";
+import { resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import { wasEventSeen } from "./event-dedup";
 import { hasOtherUserMention } from "./router";
 import { bufferThreadMessage } from "./thread-buffer";
@@ -76,6 +76,11 @@ export function createAssistant(): Assistant {
         const channelId = message.channel;
         const messageText = (msg.text as string) || "";
         const userId = (msg.user as string) || "";
+        // Any in-body `<@U…>` mention the requester typed is rewritten via
+        // the identity primitive before it reaches agent-visible task text —
+        // never a raw Slack ID. Bot-mention routing checks below use the
+        // raw `messageText`, not this rendered copy.
+        const renderedMessageText = rewriteSlackMentions(messageText);
 
         // Resolve the bot's own Slack user ID (cached after first call) so we can
         // check whether this message is actually addressed to us.
@@ -123,7 +128,7 @@ export function createAssistant(): Assistant {
 
           // Otherwise, create a follow-up task for the working agent
           const latestTask = getMostRecentTaskInThread(channelId, threadTs);
-          createTaskWithSiblingAwareness(messageText, {
+          createTaskWithSiblingAwareness(renderedMessageText, {
             agentId: workingAgent.id,
             source: "slack",
             slackChannelId: channelId,
@@ -141,8 +146,11 @@ export function createAssistant(): Assistant {
         // 2. First message in thread — create new task for lead
         await safeSetStatus("Processing your request...");
 
-        if (messageText) {
-          const title = messageText.length > 50 ? `${messageText.slice(0, 47)}...` : messageText;
+        if (renderedMessageText) {
+          const title =
+            renderedMessageText.length > 50
+              ? `${renderedMessageText.slice(0, 47)}...`
+              : renderedMessageText;
           await safeSetTitle(title);
         }
 
@@ -156,7 +164,7 @@ export function createAssistant(): Assistant {
         const lead = getLeadAgent();
         if (!lead) {
           // No lead — still queue the task
-          createTaskWithSiblingAwareness(messageText + channelContext, {
+          createTaskWithSiblingAwareness(renderedMessageText + channelContext, {
             source: "slack",
             slackChannelId: channelId,
             slackThreadTs: threadTs,
@@ -169,7 +177,7 @@ export function createAssistant(): Assistant {
           return;
         }
 
-        createTaskWithSiblingAwareness(messageText + channelContext, {
+        createTaskWithSiblingAwareness(renderedMessageText + channelContext, {
           agentId: lead.id,
           source: "slack",
           slackChannelId: channelId,

package/src/slack/enrich.ts

@@ -23,6 +23,7 @@
 
 import type { WebClient } from "@slack/web-api";
 import { getKv, upsertKv } from "../be/db";
+import { resolveIdentity } from "../be/identity";
 import { recordUnmappedIdentity } from "../be/unmapped-identities";
 import {
   findOrCreateUserByEmail,
@@ -160,3 +161,19 @@ export async function resolveSlackUserId(
   recordUnmappedIdentity("slack", slackUserId, eventContext);
   return undefined;
 }
+
+/**
+ * Rewrite every Slack `<@USERID>` mention token in `text` via the identity
+ * primitive: `<@USERID|Name>` when resolved, `<@USERID> (unknown user)` when
+ * not. Covers both author labels (`<@U…>: message`) and mentions embedded in
+ * message bodies — both are just this same token. Pure DB reads via
+ * `resolveIdentity`; zero Slack API calls, no cache.
+ */
+export function rewriteSlackMentions(text: string): string {
+  return text.replace(/<@([A-Z0-9]+)>/g, (_match, userId: string) => {
+    const resolution = resolveIdentity("slack", userId);
+    return resolution.status === "resolved"
+      ? `<@${userId}|${resolution.name}>`
+      : `<@${userId}> (unknown user)`;
+  });
+}

package/src/slack/handlers.ts

@@ -12,7 +12,7 @@ import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { workflowEventBus } from "../workflows/event-bus";
 import { buildTreeBlocks, type TreeNode } from "./blocks";
-import { enrichSlackUserEmail, resolveSlackUserId } from "./enrich";
+import { enrichSlackUserEmail, resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import { wasEventSeen } from "./event-dedup";
 import type { SlackFile } from "./files";
 import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
@@ -250,23 +250,6 @@ async function wasThreadStartedBySwarm(
   return startedBySwarm;
 }
 
-// Cache for user display names
-const userNameCache = new Map<string, string>();
-
-async function getUserDisplayName(client: WebClient, userId: string): Promise<string> {
-  if (userNameCache.has(userId)) {
-    return userNameCache.get(userId)!;
-  }
-  try {
-    const result = await client.users.info({ user: userId });
-    const name = result.user?.profile?.display_name || result.user?.real_name || userId;
-    userNameCache.set(userId, name);
-    return name;
-  } catch {
-    return userId;
-  }
-}
-
 /**
  * Fetch thread history and format as context for the task.
  * Returns empty string if not in a thread or no previous messages.
@@ -297,7 +280,10 @@ async function getThreadContext(
 
     if (previousMessages.length === 0) return "";
 
-    // Format messages with user names or [Agent] for bot messages
+    // Format messages with user names or [Agent] for bot messages. Author
+    // identity is rendered via the identity primitive (resolved name or the
+    // UNKNOWN sentinel) — never a raw Slack API display name, and no
+    // `users.info` call.
     const formattedMessages: string[] = [];
     for (const m of previousMessages) {
       // Check if this is a bot/agent message (multiple ways to identify)
@@ -310,12 +296,12 @@ async function getThreadContext(
         const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
         formattedMessages.push(`[Agent]: ${truncatedText}`);
       } else {
-        const userName = m.user ? await getUserDisplayName(client, m.user) : "Unknown";
-        formattedMessages.push(`${userName}: ${text}`);
+        const authorTag = m.user ? `<@${m.user}>` : "Unknown";
+        formattedMessages.push(`${authorTag}: ${text}`);
       }
     }
 
-    return formattedMessages.join("\n");
+    return rewriteSlackMentions(formattedMessages.join("\n"));
   } catch (error) {
     console.error("[Slack] Failed to fetch thread context:", error);
     return "";

package/src/slack/responses.ts

@@ -1,6 +1,6 @@
 import type { WebClient } from "@slack/web-api";
 import { getAgentById, getTaskAttachments } from "../be/db";
-import type { Agent, AgentTask } from "../types";
+import type { Agent, AgentTask, TaskAttachment } from "../types";
 import { getSlackApp } from "./app";
 import {
   buildCancelledBlocks,
@@ -10,7 +10,9 @@ import {
   buildProgressBlocks,
   formatAttachmentsBlockForSlack,
   formatDuration,
+  getTaskLink,
   markdownToSlack,
+  splitSlackSectionText,
 } from "./blocks";
 
 // Re-export for backward compatibility
@@ -31,6 +33,16 @@ function classifySlackUpdateError(error: unknown): SlackUpdateResult {
 }
 
 const isDev = process.env.ENV === "development";
+const MIN_INLINE_OUTPUT_LENGTH = 20;
+export const MAX_INLINE_OUTPUT_MESSAGE_LENGTH = 4000;
+const INLINE_OUTPUT_FALLBACKS = new Set([
+  "done",
+  "completed",
+  "complete",
+  "task completed",
+  "process completed successfully",
+  "process completed successfully (no output captured)",
+]);
 
 /**
  * Get the display name for an agent, with (dev) prefix if in development mode.
@@ -39,6 +51,84 @@ function getAgentDisplayName(agent: Agent): string {
   return isDev ? `(dev) ${agent.name}` : agent.name;
 }
 
+export function shouldPostInlineCompletionOutput(
+  task: AgentTask,
+  attachments: readonly TaskAttachment[],
+): boolean {
+  if (task.status !== "completed") return false;
+  if (!task.slackChannelId || !task.slackThreadTs) return false;
+  if (task.slackReplySent) return false;
+
+  const output = task.output?.trim();
+  if (!output || output.length < MIN_INLINE_OUTPUT_LENGTH) return false;
+  if (INLINE_OUTPUT_FALLBACKS.has(output.toLowerCase())) return false;
+
+  return !attachments.some((attachment) => attachment.isPrimary);
+}
+
+export function formatInlineCompletionOutputText(opts: {
+  agentName: string;
+  taskId: string;
+  output: string;
+}): string {
+  const header = `✅ *${opts.agentName}* completed with output (${getTaskLink(opts.taskId)}):\n\n`;
+  const tail = `\n\n…(full output in task ${getTaskLink(opts.taskId)})`;
+  const slackOutput = markdownToSlack(opts.output.trim());
+  const maxBodyLength = MAX_INLINE_OUTPUT_MESSAGE_LENGTH - header.length;
+
+  if (slackOutput.length <= maxBodyLength) {
+    return header + slackOutput;
+  }
+
+  const maxTruncatedBodyLength = Math.max(0, maxBodyLength - tail.length);
+  let cut = slackOutput.lastIndexOf("\n", maxTruncatedBodyLength);
+  if (cut < maxTruncatedBodyLength / 2) {
+    cut = slackOutput.lastIndexOf(" ", maxTruncatedBodyLength);
+  }
+  if (cut < maxTruncatedBodyLength / 2) {
+    cut = maxTruncatedBodyLength;
+  }
+
+  return header + slackOutput.slice(0, cut).trimEnd() + tail;
+}
+
+export async function sendInlineTaskOutput(task: AgentTask): Promise<boolean> {
+  const app = getSlackApp();
+  if (!app || !task.slackChannelId || !task.slackThreadTs || !task.agentId || !task.output) {
+    return false;
+  }
+
+  const agent = getAgentById(task.agentId);
+  if (!agent) {
+    console.error(`[Slack] Agent not found for task ${task.id}`);
+    return false;
+  }
+
+  const text = formatInlineCompletionOutputText({
+    agentName: agent.name,
+    taskId: task.id,
+    output: task.output,
+  });
+
+  try {
+    await sendWithPersona(app.client, {
+      channel: task.slackChannelId,
+      thread_ts: task.slackThreadTs,
+      text,
+      username: getAgentDisplayName(agent),
+      icon_emoji: getAgentEmoji(agent),
+      blocks: splitSlackSectionText(text).map((chunk) => ({
+        type: "section",
+        text: { type: "mrkdwn", text: chunk },
+      })),
+    });
+    return true;
+  } catch (error) {
+    console.error(`[Slack] Failed to send inline output for task ${task.id}:`, error);
+    return false;
+  }
+}
+
 /**
  * Send a task completion message to Slack with the agent's persona.
  */

package/src/slack/thread-buffer.ts

@@ -4,6 +4,7 @@ import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
+import { rewriteSlackMentions } from "./enrich";
 import { extractSlackMessageText } from "./message-text";
 import { registerTreeMessage } from "./watcher";
 
@@ -107,7 +108,7 @@ async function getThreadContextForBuffer(channelId: string, threadTs: string): P
       })
       .join("\n");
 
-    return formatted;
+    return rewriteSlackMentions(formatted);
   } catch (error) {
     console.error("[Slack] Failed to fetch thread context for buffer:", error);
     return "";
@@ -137,8 +138,10 @@ async function slackFlush(
 
   console.log(`[Slack] Flushing buffer: ${key} (${items.length} messages, immediate=${immediate})`);
 
-  // Build combined task description
-  const combinedText = items.map((m) => m.text).join("\n---\n");
+  // Build combined task description. Any in-body `<@U…>` mentions the
+  // requester typed are rewritten via the identity primitive so the agent
+  // sees a name or the explicit UNKNOWN sentinel — never a raw Slack ID.
+  const combinedText = rewriteSlackMentions(items.map((m) => m.text).join("\n---\n"));
   const description = `[Thread follow-up — ${items.length} message(s) buffered]\n\n${combinedText}`;
 
   // Find the latest active task in this thread for dependency chaining

package/src/slack/watcher.ts

@@ -12,8 +12,10 @@ import { getSlackApp } from "./app";
 import type { TreeNode } from "./blocks";
 import { buildTreeBlocks, formatDuration } from "./blocks";
 import {
+  sendInlineTaskOutput,
   sendProgressUpdate,
   sendTaskResponse,
+  shouldPostInlineCompletionOutput,
   updateProgressInPlace,
   updateToFinal,
   updateTreeMessage,
@@ -704,11 +706,11 @@ export function startTaskWatcher(intervalMs = 3000): void {
         if (lastSent && now - lastSent < MIN_SEND_INTERVAL) continue;
 
         // Tasks tracked in a tree are still rendered by processTreeMessages().
-        // Successful tasks without their own slack-reply also get a full
-        // threaded completion message so the tree's compact preview is not the
-        // only place their output appears.
+        // For prose-only completions, add one inline output reply so the user
+        // sees the actual answer instead of only the compact tree preview.
         if (taskToTree.has(task.id)) {
-          if (task.status !== "completed" || task.slackReplySent) {
+          const attachments = task.status === "completed" ? getTaskAttachments(task.id) : [];
+          if (!shouldPostInlineCompletionOutput(task, attachments)) {
             notifiedCompletions.set(task.id, now);
             continue;
           }
@@ -717,9 +719,10 @@ export function startTaskWatcher(intervalMs = 3000): void {
           notifiedCompletions.set(task.id, now);
           lastSendTime.set(completionKey, now);
           try {
-            await sendTaskResponse(task);
+            const sent = await sendInlineTaskOutput(task);
+            if (!sent) throw new Error("sendInlineTaskOutput returned false");
             console.log(
-              `[Slack] Sent full tree-tracked completion for task ${task.id.slice(0, 8)}`,
+              `[Slack] Sent inline output for tree-tracked completion ${task.id.slice(0, 8)}`,
             );
           } catch (error) {
             notifiedCompletions.delete(task.id);