@desplega.ai/agent-swarm 1.57.4 → 1.58.0

package/src/linear/sync.ts

@@ -1,4 +1,4 @@
-import { cancelTask, createTaskExtended, getAllAgents, getTaskById } from "../be/db";
+import { cancelTask, createTaskExtended, getAllAgents, getTaskById, resolveUser } from "../be/db";
 import { getOAuthTokens } from "../be/db-queries/oauth";
 import {
   createTrackerSync,
@@ -269,6 +269,17 @@ export async function handleAgentSessionEvent(event: Record<string, unknown>): P
     return;
   }
 
+  // Extract actor identity from Linear webhook payload
+  const actor = event.actor as Record<string, unknown> | undefined;
+  const actorLinearId = actor ? String(actor.id ?? "") : "";
+  const actorName = actor ? String(actor.name ?? "") : "";
+  const actorEmail = actor ? String(actor.email ?? "") : "";
+  const requestedByUserId = resolveUser({
+    linearUserId: actorLinearId || undefined,
+    email: actorEmail || undefined,
+    name: actorName || undefined,
+  })?.id;
+
   // Check if we already track this issue
   const existing = getTrackerSyncByExternalId("linear", "task", issueId);
   const sessionId = agentSession ? String(agentSession.id ?? "") : "";
@@ -320,6 +331,7 @@ export async function handleAgentSessionEvent(event: Record<string, unknown>): P
     agentId: lead?.id ?? "",
     source: "linear",
     taskType: "linear-issue",
+    requestedByUserId,
   });
 
   // Delete old tracker_sync before creating new one (UNIQUE constraint)
@@ -536,6 +548,17 @@ export async function handleAgentSessionPrompted(event: Record<string, unknown>)
   // Task is completed/failed/cancelled or doesn't exist — create a new follow-up task
   const lead = findLeadAgent();
 
+  // Extract actor identity from Linear webhook payload
+  const promptedActor = event.actor as Record<string, unknown> | undefined;
+  const promptedActorLinearId = promptedActor ? String(promptedActor.id ?? "") : "";
+  const promptedActorEmail = promptedActor ? String(promptedActor.email ?? "") : "";
+  const promptedActorName = promptedActor ? String(promptedActor.name ?? "") : "";
+  const promptedRequestedByUserId = resolveUser({
+    linearUserId: promptedActorLinearId || undefined,
+    email: promptedActorEmail || undefined,
+    name: promptedActorName || undefined,
+  })?.id;
+
   const followupResult = resolveTemplate("linear.issue.followup", {
     issue_identifier: issueIdentifier,
     issue_title: issueTitle,
@@ -551,6 +574,7 @@ export async function handleAgentSessionPrompted(event: Record<string, unknown>)
     agentId: lead?.id ?? "",
     source: "linear",
     taskType: "linear-issue",
+    requestedByUserId: promptedRequestedByUserId,
   });
 
   // Repoint the existing tracker_sync to the new follow-up task (can't create a

package/src/server.ts

@@ -15,6 +15,7 @@ import { registerJoinSwarmTool } from "./tools/join-swarm";
 // Messaging capability
 import { registerListChannelsTool } from "./tools/list-channels";
 import { registerListServicesTool } from "./tools/list-services";
+import { registerManageUserTool } from "./tools/manage-user";
 // MCP Servers capability
 import {
   registerMcpServerCreateTool,
@@ -44,6 +45,7 @@ import { registerRegisterAgentMailInboxTool } from "./tools/register-agentmail-i
 // Services capability
 import { registerRegisterServiceTool } from "./tools/register-service";
 import { registerRequestHumanInputTool } from "./tools/request-human-input";
+import { registerResolveUserTool } from "./tools/resolve-user";
 // Scheduling capability
 import {
   registerCreateScheduleTool,
@@ -156,6 +158,10 @@ export function createServer() {
   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);
 

package/src/slack/actions.ts

@@ -1,5 +1,12 @@
 import type { App } from "@slack/bolt";
-import { cancelTask, createTaskExtended, getAgentById, getLeadAgent, getTaskById } from "../be/db";
+import {
+  cancelTask,
+  createTaskExtended,
+  getAgentById,
+  getLeadAgent,
+  getTaskById,
+  resolveUser,
+} from "../be/db";
 import { buildCancelledBlocks, getTaskLink } from "./blocks";
 
 export function registerActionHandlers(app: App): void {
@@ -65,6 +72,7 @@ export function registerActionHandlers(app: App): void {
     if (!originalTask || !originalTask.slackChannelId) return;
 
     const lead = getLeadAgent();
+    const requestedByUserId = resolveUser({ slackUserId: body.user.id })?.id;
     const followUpTask = createTaskExtended(followUpText, {
       agentId: lead?.id,
       source: "slack",
@@ -72,6 +80,7 @@ export function registerActionHandlers(app: App): void {
       slackChannelId: originalTask.slackChannelId,
       slackThreadTs: originalTask.slackThreadTs,
       slackUserId: body.user.id,
+      requestedByUserId,
     });
 
     const taskLink = getTaskLink(followUpTask.id);

package/src/slack/assistant.ts

@@ -4,6 +4,7 @@ import {
   getAgentWorkingOnThread,
   getLeadAgent,
   getMostRecentTaskInThread,
+  resolveUser,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { bufferThreadMessage } from "./thread-buffer";
@@ -47,6 +48,9 @@ export function createAssistant(): Assistant {
         const messageText = (msg.text as string) || "";
         const userId = (msg.user as string) || "";
 
+        // Resolve canonical user identity (graceful — null if not found)
+        const requestedByUserId = userId ? resolveUser({ slackUserId: userId })?.id : undefined;
+
         // 1. Check if an agent is already working in this thread
         const workingAgent = getAgentWorkingOnThread(channelId, threadTs);
 
@@ -67,6 +71,7 @@ export function createAssistant(): Assistant {
             slackThreadTs: threadTs,
             slackUserId: userId,
             parentTaskId: latestTask?.id,
+            requestedByUserId,
           });
 
           await setStatus("Processing follow-up...");
@@ -96,6 +101,7 @@ export function createAssistant(): Assistant {
             slackChannelId: channelId,
             slackThreadTs: threadTs,
             slackUserId: userId,
+            requestedByUserId,
           });
           const offlineResult = resolveTemplate("slack.assistant.offline", {});
           await say(offlineResult.text);
@@ -108,6 +114,7 @@ export function createAssistant(): Assistant {
           slackChannelId: channelId,
           slackThreadTs: threadTs,
           slackUserId: userId,
+          requestedByUserId,
         });
         // setStatus shows typing indicator — watcher will post final result when done
       } catch (error) {

package/src/slack/handlers.ts

@@ -1,13 +1,13 @@
 import type { App } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
 import {
-  createTask,
   createTaskExtended,
   getAgentById,
   getAgentWorkingOnThread,
   getLeadAgent,
   getMostRecentTaskInThread,
   getTasksByAgentId,
+  resolveUser,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { workflowEventBus } from "../workflows/event-bus";
@@ -336,6 +336,9 @@ export function registerMessageHandler(app: App): void {
       return;
     }
 
+    // Resolve canonical user identity (graceful — null if not found)
+    const requestedByUserId = resolveUser({ slackUserId: msg.user })?.id;
+
     // Emit workflow trigger event for Slack messages
     workflowEventBus.emit("slack.message", {
       channel: msg.channel,
@@ -465,6 +468,7 @@ export function registerMessageHandler(app: App): void {
         slackChannelId: msg.channel,
         slackThreadTs: threadTs,
         slackUserId: msg.user,
+        requestedByUserId,
       });
 
       await say({
@@ -537,17 +541,20 @@ export function registerMessageHandler(app: App): void {
             slackThreadTs: threadTs,
             slackUserId: msg.user,
             parentTaskId: latestTask?.id,
+            requestedByUserId,
           });
           results.assigned.push({ agentName: agent.name, taskId: task.id });
           continue;
         }
 
         // Workers receive tasks as before
-        const task = createTask(agent.id, fullTaskDescription, {
+        const task = createTaskExtended(fullTaskDescription, {
+          agentId: agent.id,
           source: "slack",
           slackChannelId: msg.channel,
           slackThreadTs: threadTs,
           slackUserId: msg.user,
+          requestedByUserId,
         });
 
         // Check if agent has an in-progress task in this thread (queued follow-up)

package/src/tests/events-http.test.ts

@@ -38,7 +38,7 @@ async function waitForServer(url: string, timeoutMs = 15000) {
       const r = await fetch(url);
       if (r.ok) return;
     } catch {}
-    await Bun.sleep(200);
+    await Bun.sleep(50);
   }
   throw new Error(`Server did not start within ${timeoutMs}ms`);
 }
@@ -74,7 +74,7 @@ afterAll(async () => {
       await serverProc.exited;
     } catch {}
   }
-  await Bun.sleep(300);
+  await Bun.sleep(50);
   try {
     await unlink(TEST_DB_PATH);
     await unlink(`${TEST_DB_PATH}-wal`);

package/src/tests/http-api-integration.test.ts

@@ -64,7 +64,7 @@ async function waitForServer(url: string, timeoutMs = 15000) {
     } catch {
       // not ready yet
     }
-    await Bun.sleep(200);
+    await Bun.sleep(50);
   }
   throw new Error(`Server did not start within ${timeoutMs}ms`);
 }
@@ -128,7 +128,7 @@ afterAll(async () => {
       await serverProc.exited;
     } catch {}
   }
-  await Bun.sleep(300);
+  await Bun.sleep(50);
   try {
     await unlink(TEST_DB_PATH);
   } catch {}
@@ -1557,7 +1557,7 @@ describe("AgentMail Webhooks (with filters)", () => {
         await agentmailProc.exited;
       } catch {}
     }
-    await Bun.sleep(300);
+    await Bun.sleep(50);
     try {
       await unlink(AGENTMAIL_DB);
     } catch {}

package/src/tests/linear-outbound-sync.test.ts

@@ -54,7 +54,7 @@ describe("Linear Outbound Sync", () => {
     });
 
     // Allow async handler to run
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).toHaveBeenCalledTimes(1);
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
@@ -82,7 +82,7 @@ describe("Linear Outbound Sync", () => {
       failureReason: "Build error in module X",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).toHaveBeenCalledTimes(1);
     const callArgs = mockCreateComment.mock.calls[0] as unknown[];
@@ -98,7 +98,7 @@ describe("Linear Outbound Sync", () => {
       output: "done",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).not.toHaveBeenCalled();
   });
@@ -123,7 +123,7 @@ describe("Linear Outbound Sync", () => {
       output: "done",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).not.toHaveBeenCalled();
   });
@@ -148,7 +148,7 @@ describe("Linear Outbound Sync", () => {
       output: "done",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).toHaveBeenCalledTimes(1);
   });
@@ -172,7 +172,7 @@ describe("Linear Outbound Sync", () => {
       output: "done",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).toHaveBeenCalledTimes(1);
   });
@@ -193,7 +193,7 @@ describe("Linear Outbound Sync", () => {
       output: "done",
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockCreateComment).not.toHaveBeenCalled();
   });

package/src/tests/preload.ts

@@ -0,0 +1,14 @@
+import { closeDb, getDb, initDb } from "../be/db";
+
+// Prevent tests from making real network calls to LLM providers.
+// The RawLlmExecutor tests already handle both success and failure paths,
+// so removing the key just forces the fast failure path (~0ms vs ~2s of API calls).
+delete process.env.OPENROUTER_API_KEY;
+
+// Build one fully-migrated AND fully-seeded SQLite template per worker.
+// initDb runs all migrations, ensureAgentProfileColumns, seedContextVersions,
+// seedDefaultTemplates, etc. We serialize the result so each test suite can
+// restore from it instantly — no per-suite migration or seeding work at all.
+initDb(":memory:");
+(globalThis as any).__testMigrationTemplate = getDb().serialize();
+closeDb();

package/src/tests/rest-api.test.ts

@@ -599,7 +599,7 @@ describe("REST API Endpoints", () => {
     test("should return empty stats for empty database", async () => {
       // Clean up the database for this test
       closeDb();
-      await unlink(TEST_DB_PATH);
+      await unlink(TEST_DB_PATH).catch(() => {});
       await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
       await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
       initDb(TEST_DB_PATH);

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

@@ -0,0 +1,306 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  deleteUser,
+  getAllUsers,
+  getTaskById,
+  getUserById,
+  initDb,
+  resolveUser,
+  updateUser,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-user-identity.sqlite";
+
+let leadAgent: ReturnType<typeof createAgent>;
+let workerAgent: ReturnType<typeof createAgent>;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  leadAgent = createAgent({ name: "TestLead", isLead: true, status: "idle" });
+  workerAgent = createAgent({ name: "TestWorker", isLead: false, status: "idle" });
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+// ─── User CRUD ────────────────────────────────────────────────────────────────
+
+describe("createUser", () => {
+  test("creates a user with required fields only", () => {
+    const user = createUser({ name: "Alice" });
+    expect(user.id).toBeDefined();
+    expect(user.name).toBe("Alice");
+    expect(user.email).toBeUndefined();
+    expect(user.role).toBeUndefined();
+    expect(user.emailAliases).toEqual([]);
+    expect(user.preferredChannel).toBe("slack");
+    expect(user.createdAt).toBeDefined();
+    expect(user.lastUpdatedAt).toBeDefined();
+  });
+
+  test("creates a user with all fields", () => {
+    const user = createUser({
+      name: "Bob",
+      email: "bob@example.com",
+      role: "engineer",
+      notes: "Test user",
+      slackUserId: "U_BOB",
+      linearUserId: "lin-bob-uuid",
+      githubUsername: "bob-gh",
+      gitlabUsername: "bob-gl",
+      emailAliases: ["bob2@example.com", "robert@example.com"],
+      preferredChannel: "email",
+      timezone: "America/New_York",
+    });
+    expect(user.name).toBe("Bob");
+    expect(user.email).toBe("bob@example.com");
+    expect(user.role).toBe("engineer");
+    expect(user.notes).toBe("Test user");
+    expect(user.slackUserId).toBe("U_BOB");
+    expect(user.linearUserId).toBe("lin-bob-uuid");
+    expect(user.githubUsername).toBe("bob-gh");
+    expect(user.gitlabUsername).toBe("bob-gl");
+    expect(user.emailAliases).toEqual(["bob2@example.com", "robert@example.com"]);
+    expect(user.preferredChannel).toBe("email");
+    expect(user.timezone).toBe("America/New_York");
+  });
+
+  test("rejects duplicate slackUserId", () => {
+    createUser({ name: "First", slackUserId: "U_UNIQUE" });
+    expect(() => createUser({ name: "Second", slackUserId: "U_UNIQUE" })).toThrow();
+  });
+
+  test("rejects duplicate githubUsername", () => {
+    createUser({ name: "GH1", githubUsername: "unique-gh" });
+    expect(() => createUser({ name: "GH2", githubUsername: "unique-gh" })).toThrow();
+  });
+});
+
+describe("getUserById", () => {
+  test("returns user by ID", () => {
+    const created = createUser({ name: "GetById" });
+    const fetched = getUserById(created.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.name).toBe("GetById");
+    expect(fetched!.id).toBe(created.id);
+  });
+
+  test("returns null for non-existent ID", () => {
+    expect(getUserById("nonexistent")).toBeNull();
+  });
+});
+
+describe("getAllUsers", () => {
+  test("returns all users", () => {
+    const users = getAllUsers();
+    expect(users.length).toBeGreaterThan(0);
+  });
+});
+
+describe("updateUser", () => {
+  test("updates specific fields", () => {
+    const user = createUser({ name: "UpdateMe", role: "intern" });
+    const updated = updateUser(user.id, { role: "senior", email: "updated@test.com" });
+    expect(updated).toBeDefined();
+    expect(updated!.role).toBe("senior");
+    expect(updated!.email).toBe("updated@test.com");
+    expect(updated!.name).toBe("UpdateMe"); // unchanged
+  });
+
+  test("updates emailAliases", () => {
+    const user = createUser({ name: "AliasUser" });
+    const updated = updateUser(user.id, { emailAliases: ["alias1@test.com", "alias2@test.com"] });
+    expect(updated!.emailAliases).toEqual(["alias1@test.com", "alias2@test.com"]);
+  });
+
+  test("returns null for non-existent user", () => {
+    expect(updateUser("nonexistent", { name: "Nope" })).toBeNull();
+  });
+
+  test("returns unchanged user when no updates provided", () => {
+    const user = createUser({ name: "NoChange" });
+    const result = updateUser(user.id, {});
+    expect(result).toBeDefined();
+    expect(result!.name).toBe("NoChange");
+  });
+});
+
+describe("deleteUser", () => {
+  test("deletes existing user", () => {
+    const user = createUser({ name: "DeleteMe" });
+    expect(deleteUser(user.id)).toBe(true);
+    expect(getUserById(user.id)).toBeNull();
+  });
+
+  test("returns false for non-existent user", () => {
+    expect(deleteUser("nonexistent")).toBe(false);
+  });
+
+  test("clears requestedByUserId on tasks when user is deleted", () => {
+    const user = createUser({ name: "TaskOwner", slackUserId: "U_TASKOWNER" });
+    const task = createTaskExtended("test task with user", {
+      agentId: workerAgent.id,
+      source: "slack",
+      requestedByUserId: user.id,
+    });
+    expect(getTaskById(task.id)!.requestedByUserId).toBe(user.id);
+
+    deleteUser(user.id);
+    expect(getTaskById(task.id)!.requestedByUserId).toBeUndefined();
+  });
+});
+
+// ─── resolveUser ──────────────────────────────────────────────────────────────
+
+describe("resolveUser", () => {
+  let testUser: ReturnType<typeof createUser>;
+
+  beforeAll(() => {
+    testUser = createUser({
+      name: "Resolve TestUser",
+      email: "resolve-test@example.com",
+      slackUserId: "U_RESOLVE_SLACK",
+      linearUserId: "lin-resolve-uuid",
+      githubUsername: "resolve-gh",
+      gitlabUsername: "resolve-gl",
+      emailAliases: ["resolve-alias@example.com"],
+    });
+  });
+
+  test("resolves by slackUserId", () => {
+    const user = resolveUser({ slackUserId: "U_RESOLVE_SLACK" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by linearUserId", () => {
+    const user = resolveUser({ linearUserId: "lin-resolve-uuid" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by githubUsername", () => {
+    const user = resolveUser({ githubUsername: "resolve-gh" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by gitlabUsername", () => {
+    const user = resolveUser({ gitlabUsername: "resolve-gl" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by primary email", () => {
+    const user = resolveUser({ email: "resolve-test@example.com" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by email alias (case-insensitive)", () => {
+    const user = resolveUser({ email: "RESOLVE-ALIAS@EXAMPLE.COM" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("resolves by name substring (case-insensitive)", () => {
+    const user = resolveUser({ name: "resolve testuser" });
+    expect(user).toBeDefined();
+    expect(user!.id).toBe(testUser.id);
+  });
+
+  test("returns null for no match", () => {
+    expect(resolveUser({ slackUserId: "U_NONEXISTENT" })).toBeNull();
+    expect(resolveUser({ email: "nobody@nowhere.com" })).toBeNull();
+    expect(resolveUser({ name: "ZZZNoSuchPerson" })).toBeNull();
+  });
+
+  test("prioritizes platform ID over email", () => {
+    // Create a second user with different slack ID
+    const user2 = createUser({
+      name: "PriorityUser",
+      slackUserId: "U_OTHER_PRIORITY",
+    });
+    // When resolving with both slackUserId and email, slackUserId wins
+    const resolved = resolveUser({
+      slackUserId: "U_OTHER_PRIORITY",
+      email: "resolve-test@example.com", // belongs to testUser
+    });
+    expect(resolved!.id).toBe(user2.id);
+    // Cleanup
+    deleteUser(user2.id);
+  });
+});
+
+// ─── requestedByUserId on tasks ─────────────────────────────────────────────
+
+describe("requestedByUserId in tasks", () => {
+  test("createTaskExtended stores requestedByUserId", () => {
+    const user = createUser({ name: "Requester" });
+    const task = createTaskExtended("task with requester", {
+      agentId: workerAgent.id,
+      source: "slack",
+      requestedByUserId: user.id,
+    });
+    const fetched = getTaskById(task.id);
+    expect(fetched!.requestedByUserId).toBe(user.id);
+    deleteUser(user.id);
+  });
+
+  test("requestedByUserId inherits from parent task", () => {
+    const user = createUser({ name: "ParentRequester" });
+    const parent = createTaskExtended("parent task", {
+      agentId: leadAgent.id,
+      source: "slack",
+      requestedByUserId: user.id,
+    });
+    const child = createTaskExtended("child task", {
+      agentId: workerAgent.id,
+      source: "mcp",
+      parentTaskId: parent.id,
+    });
+    const fetchedChild = getTaskById(child.id);
+    expect(fetchedChild!.requestedByUserId).toBe(user.id);
+    deleteUser(user.id);
+  });
+
+  test("explicit requestedByUserId overrides parent inheritance", () => {
+    const user1 = createUser({ name: "User1" });
+    const user2 = createUser({ name: "User2" });
+    const parent = createTaskExtended("parent", {
+      agentId: leadAgent.id,
+      source: "slack",
+      requestedByUserId: user1.id,
+    });
+    const child = createTaskExtended("child", {
+      agentId: workerAgent.id,
+      source: "mcp",
+      parentTaskId: parent.id,
+      requestedByUserId: user2.id,
+    });
+    expect(getTaskById(child.id)!.requestedByUserId).toBe(user2.id);
+    deleteUser(user1.id);
+    deleteUser(user2.id);
+  });
+
+  test("task without requestedByUserId has undefined", () => {
+    const task = createTaskExtended("no user task", {
+      agentId: workerAgent.id,
+      source: "mcp",
+    });
+    expect(getTaskById(task.id)!.requestedByUserId).toBeUndefined();
+  });
+});