@desplega.ai/agent-swarm 1.131.1 → 1.133.1

package/src/tests/user-identity.test.ts

@@ -3,15 +3,21 @@ import { unlinkSync } from "node:fs";
 import {
   closeDb,
   createAgent,
+  createScheduledTask,
   createTaskExtended,
   createUser,
+  createWorkflow,
+  createWorkflowRun,
   deleteUser,
   getAllUsers,
   getDb,
+  getScheduledTaskById,
   getTaskById,
   getUserById,
+  getWorkflowRun,
   initDb,
   updateUser,
+  updateWorkflowRun,
 } from "../be/db";
 import {
   findOrCreateUserByEmail,
@@ -276,13 +282,69 @@ describe("deleteUser", () => {
       source: "slack",
       requestedByUserId: user.id,
     });
+    getDb().prepare("UPDATE agent_tasks SET created_by = ? WHERE id = ?").run(user.id, task.id);
     expect(getTaskById(task.id)!.requestedByUserId).toBe(user.id);
+    expect(
+      getDb()
+        .prepare<{ created_by: string | null }, [string]>(
+          "SELECT created_by FROM agent_tasks WHERE id = ?",
+        )
+        .get(task.id)?.created_by,
+    ).toBe(user.id);
 
     deleteUser(user.id);
     expect(getTaskById(task.id)!.requestedByUserId).toBeUndefined();
+    expect(
+      getDb()
+        .prepare<{ created_by: string | null }, [string]>(
+          "SELECT created_by FROM agent_tasks WHERE id = ?",
+        )
+        .get(task.id)?.created_by,
+    ).toBeNull();
     // ON DELETE CASCADE on user_external_ids.userId should clear the mapping.
     expect(findUserByExternalId("slack", "U_TASKOWNER")).toBeNull();
   });
+
+  test("clears retained workflow run attribution before deleting the user", () => {
+    const user = createUser({ name: "Workflow Trigger" });
+    const workflow = createWorkflow({
+      name: `delete-user-workflow-${crypto.randomUUID()}`,
+      definition: { nodes: [] },
+    });
+    const run = createWorkflowRun({
+      id: crypto.randomUUID(),
+      workflowId: workflow.id,
+      createdBy: user.id,
+    });
+    updateWorkflowRun(run.id, {
+      context: {
+        swarm: { requestedByUserId: user.id, retained: "swarm-value" },
+        retained: "root-value",
+      },
+    });
+
+    expect(deleteUser(user.id)).toBe(true);
+    expect(getUserById(user.id)).toBeNull();
+    expect(getWorkflowRun(run.id)?.createdBy).toBeUndefined();
+    expect(getWorkflowRun(run.id)?.context).toEqual({
+      swarm: { retained: "swarm-value" },
+      retained: "root-value",
+    });
+  });
+
+  test("clears schedule attribution whose audit FKs were dropped by migration 103", () => {
+    const user = createUser({ name: "Schedule Trigger" });
+    const schedule = createScheduledTask({
+      name: `delete-user-schedule-${crypto.randomUUID()}`,
+      intervalMs: 60_000,
+      taskTemplate: "Run scheduled work",
+      createdBy: user.id,
+    });
+
+    expect(deleteUser(user.id)).toBe(true);
+    expect(getScheduledTaskById(schedule.id)?.createdBy).toBeUndefined();
+    expect(getScheduledTaskById(schedule.id)?.updatedBy).toBeUndefined();
+  });
 });
 
 // ─── findUserByExternalId ─────────────────────────────────────────────────────
@@ -518,6 +580,13 @@ describe("recordIdentityEvent", () => {
 // ─── requestedByUserId on tasks ───────────────────────────────────────────────
 
 describe("requestedByUserId in tasks", () => {
+  const requesterWasInherited = (taskId: string): number | undefined =>
+    getDb()
+      .prepare<{ requestedByUserIdInherited: number }, [string]>(
+        "SELECT requestedByUserIdInherited FROM agent_tasks WHERE id = ?",
+      )
+      .get(taskId)?.requestedByUserIdInherited;
+
   test("createTaskExtended stores requestedByUserId", () => {
     const user = createUser({ name: "Requester" });
     const task = createTaskExtended("task with requester", {
@@ -527,6 +596,7 @@ describe("requestedByUserId in tasks", () => {
     });
     const fetched = getTaskById(task.id);
     expect(fetched!.requestedByUserId).toBe(user.id);
+    expect(requesterWasInherited(task.id)).toBe(0);
     deleteUser(user.id);
   });
 
@@ -544,6 +614,7 @@ describe("requestedByUserId in tasks", () => {
     });
     const fetchedChild = getTaskById(child.id);
     expect(fetchedChild!.requestedByUserId).toBe(user.id);
+    expect(requesterWasInherited(child.id)).toBe(1);
     deleteUser(user.id);
   });
 
@@ -562,6 +633,7 @@ describe("requestedByUserId in tasks", () => {
       requestedByUserId: user2.id,
     });
     expect(getTaskById(child.id)!.requestedByUserId).toBe(user2.id);
+    expect(requesterWasInherited(child.id)).toBe(0);
     deleteUser(user1.id);
     deleteUser(user2.id);
   });

package/src/tests/workflow-async-v2.test.ts

@@ -152,7 +152,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
       expect(task!.task).toBe("Do the thing");
     });
 
-    test("inherits requestedByUserId from workflow execution options", async () => {
+    test("persists the requester on the run and attributes the root task", async () => {
       const user = createUser({ name: "Workflow Requester" });
       const workflow = makeWorkflow({
         nodes: [
@@ -170,6 +170,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
       const steps = getWorkflowRunStepsByRunId(runId);
       const task = getTaskByWorkflowRunStepId(steps[0]!.id);
 
+      expect(getWorkflowRun(runId)?.createdBy).toBe(user.id);
       expect(task).toBeTruthy();
       expect(task!.requestedByUserId).toBe(user.id);
     });
@@ -251,6 +252,43 @@ describe("Workflow Async v2 (Phase 4)", () => {
       expect(completedSteps).toHaveLength(2);
     });
 
+    test("resume rehydrates requester attribution from the workflow run", async () => {
+      const user = createUser({ name: "Resumed Workflow Requester" });
+      const workflow = makeWorkflow({
+        nodes: [
+          {
+            id: "task1",
+            type: "agent-task",
+            config: { template: "First attributed task" },
+            next: "task2",
+          },
+          {
+            id: "task2",
+            type: "agent-task",
+            config: { template: "Second attributed task" },
+          },
+        ],
+      });
+
+      const runId = await startWorkflowExecution(workflow, {}, registry, {
+        requestedByUserId: user.id,
+      });
+      const firstStep = getWorkflowRunStepsByRunId(runId).find((step) => step.nodeId === "task1")!;
+      const firstTask = getTaskByWorkflowRunStepId(firstStep.id)!;
+
+      workflowEventBus.emit("task.completed", {
+        taskId: firstTask.id,
+        output: "done",
+        workflowRunId: runId,
+        workflowRunStepId: firstStep.id,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const secondStep = getWorkflowRunStepsByRunId(runId).find((step) => step.nodeId === "task2");
+      expect(secondStep).toBeDefined();
+      expect(getTaskByWorkflowRunStepId(secondStep!.id)?.requestedByUserId).toBe(user.id);
+    });
+
     test("resume from task failure marks run as failed", async () => {
       const workflow = makeWorkflow({
         nodes: [

package/src/tests/workflow-http-v2.test.ts

@@ -607,7 +607,7 @@ describe("Workflow HTTP API v2", () => {
       expect(res.status).toBe(201);
     });
 
-    test("falls back to the workflow author when the trigger has no user auth", async () => {
+    test("does not attribute a trigger with no user auth to the workflow author", async () => {
       const author = createUser({
         name: "Workflow Author",
         email: `workflow-author-${crypto.randomUUID()}@example.com`,
@@ -622,7 +622,8 @@ describe("Workflow HTTP API v2", () => {
       });
       expect(res.status).toBe(201);
       const { runId } = (await res.json()) as { runId: string };
-      expect(getWorkflowRun(runId)?.context?.swarm).toEqual({ requestedByUserId: author.id });
+      expect(getWorkflowRun(runId)?.createdBy).toBeUndefined();
+      expect(getWorkflowRun(runId)?.context?.swarm).toBeUndefined();
     });
 
     test("returns 400 for disabled workflow", async () => {

package/src/tests/workflow-mcp-trigger-schema.test.ts

@@ -8,7 +8,19 @@ import {
   type ServerResponse,
 } from "node:http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { closeDb, deleteWorkflow, getWorkflow, initDb } from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  createWorkflow,
+  deleteWorkflow,
+  getTaskByWorkflowRunStepId,
+  getWorkflow,
+  getWorkflowRun,
+  getWorkflowRunStepsByRunId,
+  initDb,
+} from "../be/db";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { handleWorkflows } from "../http/workflows";
 import { SCRIPT_LONG_TIMEOUT_HINT_MS } from "../scripts-runtime/executors/types";
@@ -66,12 +78,17 @@ function buildServerWithTools() {
 
   const callTool =
     (name: string) =>
-    async (args: Record<string, unknown>, agentId = "agent-test") => {
+    async (args: Record<string, unknown>, agentId = "agent-test", sourceTaskId?: string) => {
       const tool = registeredTools[name];
       expect(tool).toBeDefined();
       const extra = {
         sessionId: "session-test",
-        requestInfo: { headers: { "x-agent-id": agentId } },
+        requestInfo: {
+          headers: {
+            "x-agent-id": agentId,
+            ...(sourceTaskId ? { "x-source-task-id": sourceTaskId } : {}),
+          },
+        },
       };
       return (await tool.handler(args, extra)) as ToolResult;
     };
@@ -579,6 +596,38 @@ describe("MCP create-workflow / update-workflow / patch-workflow accept triggerS
 
   // ─── Phase 3: trigger-workflow surfaces TriggerSchemaError ──
 
+  test("trigger-workflow attributes the run and its root task to the calling task's requester", async () => {
+    const requester = createUser({ name: "MCP Workflow Requester" });
+    const agent = createAgent({
+      name: uniqueName("mcp-trigger-agent"),
+      isLead: false,
+      status: "idle",
+    });
+    const sourceTask = createTaskExtended("Trigger a workflow", {
+      agentId: agent.id,
+      requestedByUserId: requester.id,
+    });
+    const workflow = createWorkflow({
+      name: uniqueName("mcp-trigger-attribution"),
+      definition: minimalDefinition,
+    });
+    createdWorkflowIds.push(workflow.id);
+
+    const triggered = await tools.callTrigger(
+      { id: workflow.id, triggerData: { source: "test" } },
+      agent.id,
+      sourceTask.id,
+    );
+
+    expect(triggered.structuredContent?.success).toBe(true);
+    const runId = triggered.structuredContent?.runId as string;
+    expect(getWorkflowRun(runId)?.createdBy).toBe(requester.id);
+
+    const [step] = getWorkflowRunStepsByRunId(runId);
+    expect(step).toBeDefined();
+    expect(getTaskByWorkflowRunStepId(step!.id)?.requestedByUserId).toBe(requester.id);
+  });
+
   test("trigger-workflow with missing required field → structured TriggerSchemaError", async () => {
     const triggerSchema: Record<string, unknown> = {
       type: "object",

package/src/tests/workflow-retry-v2.test.ts

@@ -3,6 +3,7 @@ import { unlink } from "node:fs/promises";
 import { z } from "zod";
 import {
   closeDb,
+  createUser,
   createWorkflow,
   createWorkflowRun,
   createWorkflowRunStep,
@@ -15,7 +16,7 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
 } from "../be/db";
-import type { RetryPolicy, Workflow, WorkflowDefinition } from "../types";
+import type { ExecutorMeta, RetryPolicy, Workflow, WorkflowDefinition } from "../types";
 import { startWorkflowExecution } from "../workflows/engine";
 import { workflowEventBus } from "../workflows/event-bus";
 import {
@@ -33,6 +34,7 @@ const TEST_DB_PATH = "./test-workflow-retry-v2.sqlite";
 // ─── Test Executors ──────────────────────────────────────────
 
 let failCounter = 0;
+const failExecutorMeta: ExecutorMeta[] = [];
 
 class FailOnceExecutor extends BaseExecutor<
   typeof FailOnceExecutor.schema,
@@ -48,7 +50,10 @@ class FailOnceExecutor extends BaseExecutor<
 
   protected async execute(
     config: z.infer<typeof FailOnceExecutor.schema>,
+    _context: Readonly<Record<string, unknown>>,
+    meta: ExecutorMeta,
   ): Promise<ExecutorResult<z.infer<typeof FailOnceExecutor.outSchema>>> {
+    failExecutorMeta.push(meta);
     failCounter++;
     if (failCounter <= config.failUntilAttempt) {
       return { status: "failed", error: `Intentional failure #${failCounter}` };
@@ -219,6 +224,45 @@ describe("Workflow Retry v2 (Phase 4)", () => {
   });
 
   describe("Retry Poller", () => {
+    test("rehydrates requester attribution before retrying an executor", async () => {
+      const user = createUser({ name: "Retry Requester" });
+      const workflow = makeWorkflow({
+        nodes: [
+          {
+            id: "attributed-retry",
+            type: "fail-once",
+            config: { failUntilAttempt: 1 },
+            retry: {
+              strategy: "static",
+              maxRetries: 2,
+              baseDelayMs: 10,
+              maxDelayMs: 10,
+            },
+          },
+        ],
+      });
+
+      failCounter = 0;
+      failExecutorMeta.length = 0;
+      const runId = await startWorkflowExecution(workflow, {}, registry, {
+        requestedByUserId: user.id,
+      });
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      try {
+        startRetryPoller(registry, 10);
+        for (let i = 0; i < 20 && getWorkflowRun(runId)?.status !== "completed"; i++) {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+      } finally {
+        stopRetryPoller();
+      }
+
+      expect(getWorkflowRun(runId)?.status).toBe("completed");
+      expect(failExecutorMeta).toHaveLength(2);
+      expect(failExecutorMeta[1]?.requestedByUserId).toBe(user.id);
+    });
+
     test("poller picks up failed steps past nextRetryAt", async () => {
       // Reset fail counter so the executor succeeds on the "retry" attempt
       failCounter = 0;

package/src/tools/db-query.ts

@@ -1,14 +1,18 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { DbQueryInputShape, executeReadOnlyQuery, resolveDbQuerySql } from "@/http/db-query";
+import { DbQueryInputShape, executeReadOnlyQueryGated, resolveDbQuerySql } from "@/http/db-query";
+import { getDbQueryMcpBudgetMs, getDbQueryMcpMaxRows } from "@/http/db-query-shared";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
-const MCP_MAX_ROWS = 100;
-
 const DbQueryToolInputSchema = z
   .object({
     ...DbQueryInputShape,
-    sql: z.string().optional().describe("SQL query (read-only only — writes are rejected)"),
+    sql: z
+      .string()
+      .optional()
+      .describe(
+        "Read-only SQL query (writes are rejected). Runs with a wall-clock budget in a bounded child process by default, and results are capped at a default row count (operator-configurable via `DB_QUERY_MCP_MAX_ROWS`) — a query is safe to try even against a huge table. session_logs, agent_log, events, and task_context_snapshots are too large to read whole: filter on an indexed column (session_logs: taskId/sessionId; agent_log: agentId/taskId/eventType/createdAt) and add a LIMIT, don't COUNT(*)/SUM(...)/typeof() across the table, and don't split a large read into rowid chunks — each chunk still reads every row in its range. See the db-query-guidance skill for the operator config knobs (timeout, row cap, concurrency cap) if a query keeps timing out or getting rejected.",
+      ),
     query: z.string().optional().describe("Deprecated runtime alias for sql."),
     params: z.array(z.any()).optional().default([]).describe("Query parameters"),
   })
@@ -22,7 +26,7 @@ export const registerDbQueryTool = (server: McpServer) => {
     {
       title: "Execute database query",
       description:
-        "Execute a read-only SQL query against the swarm database. Available to all authenticated agents — be aware results may include secrets (oauth_tokens, configs). Results capped at 100 rows.",
+        "Execute a read-only SQL query against the swarm database (SQLite). Available to all authenticated agents — be aware results may include secrets (oauth_tokens, configs). Runs in a short-lived child process with a wall-clock budget by default (fails gracefully with a timeout or a 429-style concurrency error rather than freezing); results capped at a default row count (operator-configurable via `DB_QUERY_MCP_MAX_ROWS`) regardless of how many the query matched. See the sql parameter's description for which tables are unsafe to read whole, and the db-query-guidance skill for config knobs.",
       annotations: { readOnlyHint: true },
       inputSchema: DbQueryToolInputSchema,
       outputSchema: swarmToolOutputSchema({
@@ -37,15 +41,21 @@ export const registerDbQueryTool = (server: McpServer) => {
       try {
         const sql = resolveDbQuerySql(input);
         const params = input.params ?? [];
-        const result = executeReadOnlyQuery(sql, params, MCP_MAX_ROWS);
-        const truncated = result.total > MCP_MAX_ROWS;
+        const maxRows = getDbQueryMcpMaxRows();
+        const result = await executeReadOnlyQueryGated(
+          sql,
+          params,
+          getDbQueryMcpBudgetMs(),
+          maxRows,
+        );
+        const truncated = result.total > maxRows;
 
         // Build a simple text table for Claude
         const header = result.columns.join(" | ");
         const separator = result.columns.map(() => "---").join(" | ");
         const dataRows = result.rows.map((row) => row.map((v) => String(v ?? "NULL")).join(" | "));
         const table = [header, separator, ...dataRows].join("\n");
-        const suffix = truncated ? `\n(Showing ${MCP_MAX_ROWS} of ${result.total} rows)` : "";
+        const suffix = truncated ? `\n(Showing ${maxRows} of ${result.total} rows)` : "";
         const details = `${table}${suffix}\n\n${result.total} rows in ${result.elapsed}ms`;
 
         return toolOk(`${result.total} row(s) in ${result.elapsed}ms`, {

package/src/tools/get-task-details.ts

@@ -15,6 +15,7 @@ import {
   toolOk,
 } from "@/tools/utils";
 import { AgentTaskStatusSchema } from "@/types";
+import { getUserCommsPrefs } from "@/utils/requester-comms";
 
 export const getTaskDetailsInputSchema = z.object({
   taskId: z.uuid().describe("The ID of the task to get details for."),
@@ -157,9 +158,23 @@ export const getTaskDetailsOutputSchema = swarmToolOutputSchema({
   yourAgentId: z.string().optional(),
   task: looseAgentTaskOutputSchema.optional(),
   requestedBy: z
-    .looseObject({ name: z.string().optional(), email: z.string().optional() })
+    .looseObject({
+      name: z.string().optional(),
+      email: z.string().optional(),
+      role: z.string().optional(),
+      notes: z.string().optional(),
+      comms: z
+        .looseObject({
+          tone: z.string().optional(),
+          language: z.string().optional(),
+          verbosity: z.string().optional(),
+        })
+        .optional(),
+    })
     .optional()
-    .describe("Resolved user who requested this task"),
+    .describe(
+      "Resolved user who requested this task, with role/notes and structured communication preferences (users.metadata.comms) when set",
+    ),
   logs: z.array(looseAgentLogSchema).optional(),
   attachments: z
     .array(looseTaskAttachmentSchema)
@@ -191,7 +206,13 @@ export async function getTaskDetailsHandler(
   // Resolve requesting user details if available
   const requestedByUser = task.requestedByUserId ? getUserById(task.requestedByUserId) : undefined;
   const requestedBy = requestedByUser
-    ? { name: requestedByUser.name, email: requestedByUser.email }
+    ? {
+        name: requestedByUser.name,
+        email: requestedByUser.email,
+        role: requestedByUser.role,
+        notes: requestedByUser.notes,
+        comms: getUserCommsPrefs(requestedByUser),
+      }
     : undefined;
 
   const data = {

package/src/tools/manage-user.ts

@@ -82,6 +82,17 @@ const InputSchema = z.object({
     .nullable()
     .optional()
     .describe("Free-form JSON metadata (null clears the field)"),
+  comms: z
+    .object({
+      tone: z.string().optional(),
+      language: z.string().optional(),
+      verbosity: z.string().optional(),
+    })
+    .nullable()
+    .optional()
+    .describe(
+      "Merge-safe write to metadata.comms without touching sibling metadata keys; null removes only the comms key. When metadata is also provided, it is applied first and replaces the whole blob.",
+    ),
 });
 
 function diffAliases(prev: string[], next: string[]): { added: string[]; removed: string[] } {
@@ -99,7 +110,7 @@ export const registerManageUserTool = (server: McpServer) => {
     {
       title: "Manage user profiles",
       description:
-        "Create, update, delete, or list user profiles in the user registry. Identities are managed via an `identities: [{kind, externalId}]` array (declarative — update computes diff). Lead-only.",
+        "Create, update, delete, or list user profiles in the user registry. Identities are managed via an `identities: [{kind, externalId}]` array (declarative — update computes diff). comms is the merge-safe way to set communication preferences; metadata replaces the whole blob. Lead-only.",
       annotations: { readOnlyHint: false },
       inputSchema: InputSchema,
       outputSchema: swarmToolOutputSchema({
@@ -157,6 +168,10 @@ export const registerManageUserTool = (server: McpServer) => {
             return toolErr("name is required for create action.");
           }
           try {
+            const metadata =
+              input.comms != null
+                ? { ...(input.metadata ?? {}), comms: input.comms }
+                : (input.metadata ?? undefined);
             const user = createUser({
               name: input.name,
               email: input.email,
@@ -167,7 +182,7 @@ export const registerManageUserTool = (server: McpServer) => {
               timezone: input.timezone,
               dailyBudgetUsd: input.dailyBudgetUsd ?? undefined,
               status: input.status,
-              metadata: input.metadata ?? undefined,
+              metadata,
             });
             for (const ident of input.identities ?? []) {
               linkIdentity(user.id, ident.kind, ident.externalId, operatorActor);
@@ -192,6 +207,24 @@ export const registerManageUserTool = (server: McpServer) => {
               return toolErr(`User ${input.userId} not found.`);
             }
 
+            // Merge-safe write: metadata (if provided) is applied first and
+            // replaces the whole blob, then comms is merged into it so
+            // sibling metadata keys survive.
+            let metadata = input.metadata;
+            if (input.comms !== undefined) {
+              const base: Record<string, unknown> = {
+                ...(input.metadata !== undefined
+                  ? (input.metadata ?? {})
+                  : (before.metadata ?? {})),
+              };
+              if (input.comms === null) {
+                delete base.comms;
+              } else {
+                base.comms = input.comms;
+              }
+              metadata = Object.keys(base).length > 0 ? base : null;
+            }
+
             const user = updateUser(input.userId, {
               name: input.name,
               email: input.email,
@@ -202,7 +235,7 @@ export const registerManageUserTool = (server: McpServer) => {
               timezone: input.timezone,
               dailyBudgetUsd: input.dailyBudgetUsd,
               status: input.status,
-              metadata: input.metadata,
+              metadata,
             });
             if (!user) {
               return toolErr(`User ${input.userId} not found.`);