@desplega.ai/agent-swarm 1.81.0 → 1.81.1

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.81.0",
+    "version": "1.81.1",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -7358,6 +7358,15 @@
             "required": false,
             "name": "q",
             "in": "query"
+          },
+          {
+            "schema": {
+              "type": "string",
+              "minLength": 1
+            },
+            "required": false,
+            "name": "requestedByUserId",
+            "in": "query"
           }
         ],
         "responses": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.81.0",
+  "version": "1.81.1",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/be/db.ts

@@ -9110,11 +9110,14 @@ export function listRecentSessions(opts?: {
   source?: string[];
   /** Case-insensitive substring match against `r.task`. */
   q?: string;
+  /** When set, restrict to root tasks where `requestedByUserId` equals this value. NULL rows are excluded. */
+  requestedByUserId?: string;
 }): SessionListItem[] {
   const limit = opts?.limit ?? 25;
   const offset = opts?.offset ?? 0;
   const sources = opts?.source?.filter((s) => s.length > 0) ?? [];
   const q = opts?.q?.trim();
+  const requestedByUserId = opts?.requestedByUserId?.trim() || undefined;
 
   const conditions: string[] = ["r.parentTaskId IS NULL"];
   const params: (string | number)[] = [];
@@ -9127,6 +9130,10 @@ export function listRecentSessions(opts?: {
     conditions.push("lower(r.task) LIKE ?");
     params.push(`%${q.toLowerCase()}%`);
   }
+  if (requestedByUserId) {
+    conditions.push("r.requestedByUserId = ?");
+    params.push(requestedByUserId);
+  }
   params.push(limit, offset);
 
   const rootRows = getDb()

package/src/github/handlers.ts

@@ -798,11 +798,10 @@ export async function handleComment(
 ): Promise<{ created: boolean; taskId?: string }> {
   const { action, comment, repository, sender, issue, pull_request, installation } = event;
 
-  // Resolve canonical user from GitHub sender (currently unused, but the
-  // unmapped-tracker side effect is still useful for operator triage).
-  const _requestedByUserId = resolveGitHubSender(
+  // Resolve canonical user from GitHub sender
+  const requestedByUserId = resolveGitHubSender(
     sender.login,
-    "issue_comment",
+    eventType,
     comment.body.slice(0, 100),
   );
 
@@ -873,6 +872,7 @@ export async function handleComment(
     vcsNumber: targetNumber,
     vcsCommentId: comment.id,
     vcsAuthor: sender.login,
+    requestedByUserId,
     vcsUrl: targetUrl,
     vcsInstallationId: installation?.id,
     vcsNodeId: comment.node_id,
@@ -911,9 +911,8 @@ export async function handlePullRequestReview(
 ): Promise<{ created: boolean; taskId?: string }> {
   const { action, review, pull_request: pr, repository, sender, installation } = event;
 
-  // Resolve canonical user from GitHub sender (currently unused, but the
-  // unmapped-tracker side effect is still useful for operator triage).
-  const _requestedByUserId = resolveGitHubSender(
+  // Resolve canonical user from GitHub sender
+  const requestedByUserId = resolveGitHubSender(
     sender.login,
     "pull_request_review",
     `Review on PR #${pr.number}: ${review.state}`,
@@ -995,6 +994,7 @@ export async function handlePullRequestReview(
     vcsEventType: "pull_request_review",
     vcsNumber: pr.number,
     vcsAuthor: sender.login,
+    requestedByUserId,
     vcsUrl: review.html_url,
     vcsInstallationId: installation?.id,
     vcsNodeId: review.node_id,

package/src/http/sessions.ts

@@ -19,6 +19,12 @@ const listSessions = route({
     source: z.string().optional(),
     /** Case-insensitive substring match against the root task's text. */
     q: z.string().optional(),
+    /**
+     * When present, restrict results to root tasks where
+     * `agent_tasks.requestedByUserId` equals this value. NULL rows are
+     * excluded. Omit to return every session (legacy / non-UI callers).
+     */
+    requestedByUserId: z.string().min(1).optional(),
   }),
   responses: {
     200: { description: "Recent sessions ordered by chain-wide last activity" },
@@ -64,6 +70,7 @@ export async function handleSessions(
       offset: parsed.query.offset,
       source: sources,
       q: parsed.query.q,
+      requestedByUserId: parsed.query.requestedByUserId,
     });
     json(res, { sessions });
     return true;

package/src/tests/github-handlers.test.ts

@@ -187,6 +187,35 @@ describe("known github sender", () => {
     expect(getKv(UNMAPPED_NAMESPACE, "assigner:meta")).toBeNull();
     expect(getKv(UNMAPPED_NAMESPACE, "assigner:count")).toBeNull();
   });
+
+  test("comment event with bot mention from mapped user puts user id on the task", async () => {
+    const user = createUser({ name: "Mapped Commenter", email: "commenter@example.com" });
+    linkIdentity(user.id, "github", "commenter", SYSTEM_ACTOR);
+
+    const result = await handleComment(
+      makeCommentEvent("commenter", `Hey @${GITHUB_BOT_NAME} please take a look`),
+      "issue_comment",
+    );
+    expect(result.created).toBe(true);
+    expect(getMappedUserTaskCount(user.id)).toBe(1);
+
+    // Mapped sender → no unmapped kv writes.
+    expect(getKv(UNMAPPED_NAMESPACE, "commenter:meta")).toBeNull();
+    expect(getKv(UNMAPPED_NAMESPACE, "commenter:count")).toBeNull();
+  });
+
+  test("review event from mapped user puts user id on the task", async () => {
+    const user = createUser({ name: "Mapped Reviewer", email: "reviewer@example.com" });
+    linkIdentity(user.id, "github", "reviewer", SYSTEM_ACTOR);
+
+    const result = await handlePullRequestReview(makeReviewEvent("reviewer"));
+    expect(result.created).toBe(true);
+    expect(getMappedUserTaskCount(user.id)).toBe(1);
+
+    // Mapped sender → no unmapped kv writes.
+    expect(getKv(UNMAPPED_NAMESPACE, "reviewer:meta")).toBeNull();
+    expect(getKv(UNMAPPED_NAMESPACE, "reviewer:count")).toBeNull();
+  });
 });
 
 // ── Unknown sender → unmapped kv tracker ──

package/src/tests/sessions.test.ts

@@ -4,6 +4,7 @@ import {
   closeDb,
   createAgent,
   createTaskExtended,
+  createUser,
   getRootTaskChain,
   initDb,
   listRecentSessions,
@@ -138,4 +139,56 @@ describe("sessions — getRootTaskChain + listRecentSessions", () => {
       expect(sessions[i - 1].lastActivityAt >= sessions[i].lastActivityAt).toBe(true);
     }
   });
+
+  test("listRecentSessions — requestedByUserId filter: positive / negative / NULL exclusion / compat", () => {
+    const userA = createUser({ name: "Test User A" });
+    const userB = createUser({ name: "Test User B" });
+
+    const agent = createAgent({
+      id: "sessions-test-agent-user-filter",
+      name: "Sessions Test Agent UserFilter",
+      isLead: false,
+      status: "idle",
+    });
+    createTaskExtended("user-a session 1", {
+      agentId: agent.id,
+      requestedByUserId: userA.id,
+    });
+    createTaskExtended("user-a session 2", {
+      agentId: agent.id,
+      requestedByUserId: userA.id,
+    });
+    createTaskExtended("user-b session 1", {
+      agentId: agent.id,
+      requestedByUserId: userB.id,
+    });
+
+    // Positive: user A sees only their own sessions
+    const aOnly = listRecentSessions({ limit: 50, requestedByUserId: userA.id });
+    const aTasks = aOnly.map((s) => s.root.task);
+    expect(aTasks).toContain("user-a session 1");
+    expect(aTasks).toContain("user-a session 2");
+    expect(aTasks).not.toContain("user-b session 1");
+    for (const s of aOnly) {
+      expect(s.root.requestedByUserId).toBe(userA.id);
+    }
+
+    // Negative: user A cannot see user B's sessions
+    const hasUserBInA = aOnly.some((s) => s.root.requestedByUserId === userB.id);
+    expect(hasUserBInA).toBe(false);
+
+    // NULL exclusion: NULL requestedByUserId rows excluded when filter is active
+    const hasNullInA = aOnly.some((s) => s.root.requestedByUserId == null);
+    expect(hasNullInA).toBe(false);
+
+    // Empty: unknown user ID returns empty list
+    const nobody = listRecentSessions({ limit: 50, requestedByUserId: "non-existent-user-id" });
+    expect(nobody).toHaveLength(0);
+
+    // Compat: no filter returns all sessions including NULL rows and both users
+    const all = listRecentSessions({ limit: 100 });
+    expect(all.some((s) => s.root.requestedByUserId == null)).toBe(true);
+    expect(all.some((s) => s.root.requestedByUserId === userA.id)).toBe(true);
+    expect(all.some((s) => s.root.requestedByUserId === userB.id)).toBe(true);
+  });
 });