@desplega.ai/agent-swarm 2.5.0 → 2.5.2

package/src/be/scripts/run-saved.ts

@@ -1,4 +1,4 @@
-import { type RunScriptOutput, runScript } from "../../scripts-runtime/loader";
+import type { RunScriptOutput } from "../../scripts-runtime/loader";
 import type { ScriptRecord } from "../../types";
 import {
   getScriptApiConnectionDescriptors,
@@ -6,6 +6,7 @@ import {
 } from "../script-connections";
 import { buildScriptCredentialBindingsWithFailures } from "../script-credential-broker";
 import { restoreScratchScriptLastUsedIfUnchanged, touchScratchScriptLastUsed } from "./db";
+import { runScriptWithRunCredential } from "./run-credential";
 
 export function getSavedScriptOwnerAgentId(script: ScriptRecord): string | null {
   return script.scopeId ?? script.createdByAgentId;
@@ -45,7 +46,7 @@ export async function runSavedScriptAsAgent(
         exitCode: 1,
         error: "killed",
       }
-    : await runScript({
+    : await runScriptWithRunCredential({
         source: args.script.source,
         args: args.input,
         fsMode: args.script.fsMode,

package/src/be/users.ts

@@ -615,6 +615,23 @@ export async function mintRuntimeToken(
   return await insertSessionToken(agentId, null, runtimeId, ttlMs);
 }
 
+/**
+ * Mint the short-lived `aseph_` token a script run uses for its `ctx.swarm`
+ * SDK calls, so those calls present the executing agent instead of the swarm
+ * API key (the operator). It resolves as a plain agent principal (`kind:
+ * "agent"`, no task/runtime binding), so the API layer scopes it to that
+ * agent's permissions: a lead keeps lead powers, a worker reads only its own
+ * scope. Marked `scriptRun` so it stays apart from the agent's worker token
+ * (see `AGENT_TOKEN_BINDING`). The run revokes it when it ends; `ttlMs` is the
+ * backstop for a run that dies without revoking.
+ */
+export async function mintScriptRunToken(
+  agentId: string,
+  ttlMs: number,
+): Promise<{ tokenId: string; plaintext: string }> {
+  return await insertSessionToken(agentId, null, null, ttlMs, null, undefined, null, null, true);
+}
+
 export async function insertSessionToken(
   agentId: string,
   taskId: string | null,
@@ -624,6 +641,7 @@ export async function insertSessionToken(
   expiresAtCeiling?: string,
   controllerId: string | null = null,
   parentTokenId: string | null = null,
+  scriptRun = false,
 ): Promise<{ tokenId: string; plaintext: string }> {
   const plaintext = `${SESSION_TOKEN_PREFIX}${base62(randomBytes(24))}`;
   const tokenId = randomUUID().replace(/-/g, "");
@@ -636,8 +654,8 @@ export async function insertSessionToken(
 
   await getDbClient().run(
     `INSERT INTO session_tokens
-     (id, tokenHash, tokenPreview, agentId, taskId, runtimeId, parentRuntimeId, expiresAt, createdAt, controllerId, parentTokenId)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+     (id, tokenHash, tokenPreview, agentId, taskId, runtimeId, parentRuntimeId, expiresAt, createdAt, controllerId, parentTokenId, scriptRun)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     [
       tokenId,
       hash,
@@ -650,6 +668,7 @@ export async function insertSessionToken(
       now.toISOString(),
       controllerId,
       parentTokenId,
+      scriptRun ? 1 : 0,
     ],
   );
 
@@ -713,9 +732,14 @@ export async function revokeRuntimeTokensForRuntime(runtimeId: string): Promise<
 // Agent tokens (long-lived, one agent, no runtime)
 // ---------------------------------------------------------------------------
 
-/** SQL predicate for an agent token: bound to its agent and nothing else. */
+/**
+ * SQL predicate for an agent (worker) token: bound to its agent and nothing
+ * else. `scriptRun = 0` excludes a script run's ephemeral token, which shares
+ * the same all-null binding shape but has its own lifecycle (see migration 233
+ * and `mintScriptRunToken`).
+ */
 const AGENT_TOKEN_BINDING =
-  "taskId IS NULL AND runtimeId IS NULL AND controllerId IS NULL AND parentRuntimeId IS NULL";
+  "taskId IS NULL AND runtimeId IS NULL AND controllerId IS NULL AND parentRuntimeId IS NULL AND scriptRun = 0";
 
 /** Stored expiry of a token that does not expire. `expiresAt` is NOT NULL. */
 export const AGENT_TOKEN_NO_EXPIRY = "9999-12-31T23:59:59.999Z";

package/src/gitlab/auth.ts

@@ -53,8 +53,14 @@ export function getGitLabUrl(): string {
   return gitlabUrl;
 }
 
-/** Bot name for mention detection. */
-export const GITLAB_BOT_NAME = process.env.GITLAB_BOT_NAME ?? "agent-swarm-bot";
+/**
+ * Bot name for mention detection. Read on every call: a stored swarm_config
+ * value reaches process.env after this module loads, and again on each config
+ * reload.
+ */
+export function getGitLabBotName(): string {
+  return process.env.GITLAB_BOT_NAME || "agent-swarm-bot";
+}
 
 /** Reset state for testing. */
 export function resetGitLab(): void {

package/src/gitlab/handlers.ts

@@ -8,13 +8,21 @@
  * - Detects bot mentions
  */
 
-import { failTask, findTaskByVcs, getAllAgents, incrKv, upsertKv } from "../be/db";
+import {
+  failTask,
+  findActiveTasksByVcs,
+  findTaskByVcs,
+  getAllAgents,
+  incrKv,
+  upsertKv,
+} from "../be/db";
 import { renderIdentity, resolveIdentity } from "../be/identity";
 import { findOrCreateUserByEmail, findUserByExternalId, linkIdentity } from "../be/users";
 import { resolveTemplate } from "../prompts/resolver";
 import { gitlabContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
-import { GITLAB_BOT_NAME } from "./auth";
+import type { AgentTask } from "../types";
+import { getGitLabBotName } from "./auth";
 import { addGitLabNoteReaction, addGitLabReaction } from "./reactions";
 import type { GitLabUser } from "./types";
 // Side-effect import: registers all GitLab event templates in the in-memory registry
@@ -40,11 +48,37 @@ function isDuplicate(key: string): boolean {
 
 function detectMention(text: string | null | undefined): boolean {
   if (!text) return false;
-  return new RegExp(`@${GITLAB_BOT_NAME}\\b`, "i").test(text);
+  return new RegExp(`@${getGitLabBotName()}\\b`, "i").test(text);
 }
 
 function extractMentionContext(text: string): string {
-  return text.replace(new RegExp(`@${GITLAB_BOT_NAME}\\b`, "gi"), "").trim();
+  return text.replace(new RegExp(`@${getGitLabBotName()}\\b`, "gi"), "").trim();
+}
+
+// Legacy rows written before contextKey existed: scoped only on positive evidence.
+const LEGACY_SCOPE = {
+  mr: {
+    taskTypes: new Set(["gitlab-mr", "gitlab-ci"]),
+    eventTypes: new Set(["merge_request", "note_on_mr", "pipeline"]),
+  },
+  issue: {
+    taskTypes: new Set(["gitlab-issue"]),
+    eventTypes: new Set(["issue", "note_on_issue"]),
+  },
+};
+
+/**
+ * GitLab issue and MR iids are separate per-project sequences, so a vcsNumber
+ * match alone hits both issue #N and MR !N. Match on the contextKey instead; a
+ * row without one counts only when its taskType or vcsEventType names the kind.
+ */
+function isScopedTask(task: AgentTask, kind: "mr" | "issue", contextKey: string): boolean {
+  if (task.contextKey) return task.contextKey === contextKey;
+  const legacy = LEGACY_SCOPE[kind];
+  return (
+    (task.taskType !== undefined && legacy.taskTypes.has(task.taskType)) ||
+    (task.vcsEventType !== undefined && legacy.eventTypes.has(task.vcsEventType))
+  );
 }
 
 async function findLeadAgent() {
@@ -206,12 +240,18 @@ export async function handleMergeRequest(
 
     case "close":
     case "merge": {
-      // Cancel existing tasks for this MR
-      const existingTask = await findTaskByVcs(repo, mr.iid, "gitlab");
-      if (existingTask) {
-        const reason = action === "merge" ? "MR was merged" : "MR was closed";
-        console.log(`[GitLab] Cancelling task ${existingTask.id} — ${reason}`);
-        await failTask(existingTask.id, reason);
+      // Every active task, not only the newest: a note task is a child of the
+      // MR task, and failTask does not cascade up to the parent.
+      const reason = action === "merge" ? "MR was merged" : "MR was closed";
+      const mrContextKey = gitlabContextKey({
+        projectId: String(project.id),
+        kind: "mr",
+        iid: mr.iid,
+      });
+      const tasks = await findActiveTasksByVcs(repo, mr.iid, "gitlab");
+      for (const task of tasks.filter((t) => isScopedTask(t, "mr", mrContextKey))) {
+        console.log(`[GitLab] Cancelling task ${task.id} — ${reason}`);
+        await failTask(task.id, reason);
       }
       return { created: false };
     }
@@ -262,7 +302,7 @@ export async function handleIssue(
       if (!hasMention) {
         // Check if bot is in assignees
         const isBotAssigned = event.assignees?.some(
-          (a) => a.username.toLowerCase() === GITLAB_BOT_NAME.toLowerCase(),
+          (a) => a.username.toLowerCase() === getGitLabBotName().toLowerCase(),
         );
         if (!isBotAssigned) {
           console.log(`[GitLab] Issue opened without bot mention/assignment, skipping`);
@@ -318,7 +358,15 @@ export async function handleIssue(
     }
 
     case "close": {
-      const existingTask = await findTaskByVcs(repo, issue.iid, "gitlab");
+      const issueContextKey = gitlabContextKey({
+        projectId: String(project.id),
+        kind: "issue",
+        iid: issue.iid,
+      });
+      // Newest issue-scoped task only; MR !N shares the iid but not the issue.
+      const existingTask = (await findActiveTasksByVcs(repo, issue.iid, "gitlab")).find((t) =>
+        isScopedTask(t, "issue", issueContextKey),
+      );
       if (existingTask) {
         console.log(`[GitLab] Cancelling task ${existingTask.id} — issue closed`);
         await failTask(existingTask.id, "Issue was closed");

package/src/gitlab/index.ts

@@ -1,6 +1,6 @@
 // GitLab Integration
 export {
-  GITLAB_BOT_NAME,
+  getGitLabBotName,
   getGitLabToken,
   getGitLabUrl,
   initGitLab,

package/src/http/all-routes.ts

@@ -70,6 +70,7 @@ import "./trackers/linear";
 import "./ranking";
 import "./used-by";
 import "./fleet-benchmark";
+import "./user-roles";
 import "./users";
 import "./webhooks";
 import "./workflow-events";

package/src/http/approval-requests.ts

@@ -20,8 +20,12 @@ import { findUserById } from "../be/users";
 import { can, type RbacPrincipal } from "../rbac";
 import type { User } from "../types";
 import { getRequestAuth } from "../utils/request-auth-context";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { cancelApprovalRequest } from "../workflows/approval-cancel";
-import { createApprovalFollowUpTask } from "../workflows/approval-notifications";
+import {
+  createApprovalFollowUpTask,
+  dispatchApprovalNotifications,
+} from "../workflows/approval-notifications";
 import { workflowEventBus } from "../workflows/event-bus";
 import { bodyTask, route } from "./route-def";
 import { jsonError } from "./utils";
@@ -288,7 +292,10 @@ const createRoute = route({
           target: z.string(),
         }),
       )
-      .optional(),
+      .optional()
+      .describe(
+        "Where to announce the request. A Slack target (channel or user ID) gets a card with the title, the questions and a link to the dashboard page that answers it. Slack targets need a lead agent caller (403 otherwise). Email is not supported yet and is skipped.",
+      ),
   }),
   responses: {
     201: {
@@ -296,6 +303,7 @@ const createRoute = route({
       schema: z.object({ approvalRequest: ApprovalRequestSchema }),
     },
     400: { description: "Validation error" },
+    403: { description: "Slack notifications require a lead agent" },
   },
   auth: { apiKey: true },
 });
@@ -578,7 +586,7 @@ export async function handleApprovalRequests(
     const parsed = await cancelRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
 
-    const { principal, resolvedBy } = await approvalCancelPrincipal(req);
+    const { principal, resolvedBy } = await approvalCallerPrincipal(req);
     const result = await cancelApprovalRequest({
       id: parsed.params.id,
       reason: parsed.body.reason,
@@ -619,6 +627,17 @@ export async function handleApprovalRequests(
     const parsed = await createRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
 
+    // Posting to Slack is lead-only everywhere else (slack-post); a caller that
+    // may not post must not reach an arbitrary channel through this route.
+    if (parsed.body.notifications?.some((notification) => notification.channel === "slack")) {
+      const { principal } = await approvalCallerPrincipal(req);
+      const decision = can({ principal, verb: "integration.slack.post", source: "http" });
+      if (!decision.allow) {
+        jsonError(res, SLACK_NOTIFICATION_REFUSED, 403);
+        return true;
+      }
+    }
+
     const id = crypto.randomUUID();
     // Prefer a trusted authenticated user (never client-controlled); else fall
     // back to the ownership-validated sourceTaskId the request body carries.
@@ -642,6 +661,24 @@ export async function handleApprovalRequests(
       createdBy,
     });
 
+    // Fire-and-forget: Slack must not delay or fail the 201. Workflow HITL
+    // requests are created by the executor directly, so they never post here.
+    const notifications = parsed.body.notifications;
+    if (notifications?.length && request.status === "pending") {
+      dispatchApprovalNotifications({
+        requestId: request.id,
+        title: request.title,
+        questions: parsed.body.questions,
+        timeoutSeconds: parsed.body.timeoutSeconds,
+        notifications,
+      }).catch((err) => {
+        console.error(
+          "[approval-requests] Unexpected error dispatching notifications:",
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        );
+      });
+    }
+
     createRoute.respond(res, 201, {
       approvalRequest: await toApprovalRequestResponse(request),
     });
@@ -676,11 +713,14 @@ export async function handleApprovalRequests(
   return false;
 }
 
+const SLACK_NOTIFICATION_REFUSED =
+  "Slack notifications require lead privileges (integration.slack.post). Create the request without them, or ask the lead to post the link.";
+
 /**
- * The caller of the cancel route. The shared API key with an `X-Agent-ID`
- * header identifies that agent, as on the create route.
+ * The caller of the create and cancel routes. The shared API key with an
+ * `X-Agent-ID` header identifies that agent.
  */
-async function approvalCancelPrincipal(
+async function approvalCallerPrincipal(
   req: IncomingMessage,
 ): Promise<{ principal: RbacPrincipal; resolvedBy: string | null }> {
   const auth = getRequestAuth(req);

package/src/http/index.ts

@@ -139,6 +139,7 @@ import { handleTasks } from "./tasks";
 import { handleTelemetryUi } from "./telemetry-ui";
 import { handleTrackers } from "./trackers";
 import { handleUsedBy } from "./used-by";
+import { handleUserRoles } from "./user-roles";
 import { handleUsers } from "./users";
 import {
   getPathSegments,
@@ -404,6 +405,7 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleRuntimePools(req, res, pathSegments, queryParams, myAgentId),
         () => handleExtensions(req, res, pathSegments, queryParams, myAgentId),
         () => handleFavorites(req, res, pathSegments, queryParams, myAgentId),
+        () => handleUserRoles(req, res, pathSegments, queryParams),
         () => handleUsers(req, res, pathSegments, queryParams),
         () => handleSessions(req, res, pathSegments, queryParams, myAgentId),
         () => handleInboxState(req, res, pathSegments, queryParams),

package/src/http/schedules.ts

@@ -19,6 +19,7 @@ import {
 import { explicitModelErrorForAgent } from "../be/model-validation";
 import { mergeScheduleTiming, validateRecurringTiming } from "../be/schedules/validate";
 import { getScript } from "../be/scripts/db";
+import { can } from "../rbac";
 import { calculateNextRun, dispatchScheduleTarget } from "../scheduler/scheduler";
 import {
   AgentTaskSchema,
@@ -30,6 +31,7 @@ import {
   splitLegacyModelAlias,
 } from "../types";
 import { resolveHttpFavoriteOwner } from "./favorite-owner";
+import { agentFirstPrincipal } from "./request-principal";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -219,6 +221,7 @@ const updateSchedule = route({
   responses: {
     200: { description: "Schedule updated", schema: ScheduledTaskSchema.nullable() },
     400: { description: "Validation error" },
+    403: { description: "Deferral owned by another agent" },
     404: { description: "Schedule not found" },
     409: { description: "Duplicate name" },
   },
@@ -237,6 +240,7 @@ const patchSchedule = route({
   responses: {
     200: { description: "Schedule patched", schema: ScheduledTaskSchema.nullable() },
     400: { description: "Validation error" },
+    403: { description: "Deferral owned by another agent" },
     404: { description: "Schedule not found" },
     409: { description: "Duplicate name" },
   },
@@ -559,6 +563,28 @@ export async function handleSchedules(
       jsonError(res, "Schedule not found", 404);
       return true;
     }
+    // A deferral continues its owner's task, in that task's chat thread when
+    // it has one (src/scheduler/schedule-task.ts). An agent may change it only
+    // as its owner or a lead, as in the patch-schedule and update-schedule tools.
+    if (existing.taskType === "deferred") {
+      const principal = await agentFirstPrincipal(req, myAgentId);
+      if (
+        principal.kind === "agent" &&
+        !can({
+          principal,
+          verb: "schedule.deferral.update.any",
+          resource: { kind: "owned", ownerAgentId: existing.createdByAgentId },
+          source: "http",
+        }).allow
+      ) {
+        jsonError(
+          res,
+          `Schedule "${existing.name}" defers another agent's task. Only that agent or a lead can change it.`,
+          403,
+        );
+        return true;
+      }
+    }
     // A move to another agent re-judges the stored model against the new harness.
     const agentChanged =
       parsed.body.targetAgentId !== undefined &&

package/src/http/scripts.ts

@@ -32,6 +32,7 @@ import {
 } from "../be/scripts/db";
 import { searchScripts } from "../be/scripts/embeddings";
 import { extractArgsJsonSchema } from "../be/scripts/extract-schema";
+import { runScriptWithRunCredential } from "../be/scripts/run-credential";
 import { refuseSourceWithSecrets } from "../be/scripts/source-secrets";
 import {
   scriptSdkTypesWithGeneratedApis,
@@ -40,7 +41,6 @@ import {
 } from "../be/scripts/typecheck";
 import { can } from "../rbac";
 import { extractScriptSignature, type ScriptSignature } from "../scripts-runtime/extract-signature";
-import { runScript } from "../scripts-runtime/loader";
 import { checkQuickJSCompat, quickJSCompatWarnings } from "../scripts-runtime/quickjs-compat";
 import {
   ScriptApiAuthModeSchema,
@@ -782,7 +782,7 @@ export async function handleScripts(
       ? await touchScratchScriptLastUsed(namedScript.id)
       : null;
     const credentials = await buildScriptCredentialBindingsWithFailures({ agentId: agent.id });
-    const output = await runScript({
+    const output = await runScriptWithRunCredential({
       source: source as string,
       args: parsed.body.args,
       fsMode,

package/src/http/sessions.ts

@@ -26,7 +26,7 @@ import {
   moveSessionChains,
   type SessionKeyMove,
 } from "../be/db/session-moves";
-import { getSessionReadState, getSessionTree } from "../be/db/session-tree";
+import { getSessionReadState, getSessionTree, triageSessionList } from "../be/db/session-tree";
 import { getUserGrant } from "../be/rbac-roles";
 import {
   getSessionRoot,
@@ -157,6 +157,9 @@ const SessionTreeResponseSchema = z.object({
   later: SessionSectionCountsSchema,
   done: SessionSectionCountsSchema,
   noGroup: SessionSectionCountsSchema,
+  sources: z
+    .array(z.object({ source: z.string(), total: z.number().int() }))
+    .describe("Each root source in this view with its session count, hidden sources included."),
 });
 
 const SessionApprovalSchema = z.object({
@@ -480,6 +483,28 @@ async function handleAgentTokens(
   return true;
 }
 
+const SessionShowSchema = z
+  .enum(["mine", "all"])
+  .optional()
+  .describe(
+    "Sessions v2 view, for a user viewer with tree scope. mine (default): roots the user started from a human channel (not workflow, schedule, or system) plus sessions shared with the user. all: every tree session. Lists only: access is unchanged.",
+  );
+
+const SessionHideSourceSchema = z
+  .string()
+  // The same cap as the `hideSource` body field of `POST /api/session-triage`.
+  .refine((value) => value.split(",").length <= 32, "hideSource takes at most 32 sources.")
+  .optional()
+  .transform((value) =>
+    value
+      ?.split(",")
+      .map((source) => source.trim())
+      .filter(Boolean),
+  )
+  .describe(
+    "Comma-separated root sources to leave out (the sessions v2 source filter), e.g. `slack,chat`.",
+  );
+
 const listSessions = route({
   method: "get",
   path: "/api/sessions",
@@ -539,6 +564,10 @@ const listSessions = route({
       .describe(
         "mine: owned sessions. shared: sessions shared with me. tree: Sessions that GET /api/session-tree counts: mine plus shared with me, no ownerless roots. A bypass actor sees every root with tree scope.",
       ),
+    /** With `scope=tree`: `mine` (default) or `all`. Must match the tree's `show`. */
+    show: SessionShowSchema,
+    /** Root sources to leave out. Must match the tree's `hideSource`. */
+    hideSource: SessionHideSourceSchema,
   }),
   responses: {
     200: {
@@ -561,6 +590,7 @@ const sessionTree = route({
   pattern: ["api", "session-tree"],
   summary: "Get session groups and triage counts",
   tags: ["Sessions"],
+  query: z.object({ show: SessionShowSchema, hideSource: SessionHideSourceSchema }),
   responses: {
     200: { description: "Visible groups and section counts", schema: SessionTreeResponseSchema },
     401: { description: "Unauthorized" },
@@ -568,6 +598,39 @@ const sessionTree = route({
   auth: { apiKey: true },
 });
 
+const triageSessionListRoute = route({
+  method: "post",
+  path: "/api/session-triage",
+  pattern: ["api", "session-triage"],
+  summary: "Triage every session of one sidebar list",
+  description:
+    "The bulk bar's 'Select all N': Done, back to the Inbox, read, or unread for every session that one sessions v2 list shows the caller (the `GET /api/sessions?scope=tree` filters). Needs a picked user.",
+  tags: ["Sessions"],
+  body: z
+    .object({
+      action: z.enum(["done", "inbox", "read", "unread"]),
+      /** The list: one of Inbox, Later, Done, No group, or a group. */
+      triage: z.enum(["inbox", "later", "done"]).optional(),
+      noGroup: z.boolean().optional(),
+      groupKey: SessionKeyFilterSchema.optional(),
+      show: SessionShowSchema,
+      hideSource: z.array(z.string().min(1)).max(32).optional(),
+    })
+    .refine((body) => [body.triage, body.noGroup, body.groupKey].filter(Boolean).length === 1, {
+      message: "Name exactly one list: triage, noGroup, or groupKey",
+    }),
+  responses: {
+    200: {
+      description: "The number of sessions written",
+      schema: z.object({ updated: z.number().int() }),
+    },
+    400: { description: "Validation error, or no picked user" },
+    401: { description: "Unauthorized" },
+  },
+  auth: { apiKey: true },
+  rbac: { ungated: "per-user inbox UI state, same posture as PATCH /api/inbox-state" },
+});
+
 const SESSION_MOVE_LIMIT = 200;
 const SESSION_MOVE_OWNER_ONLY = "Only the session owner can move this group";
 const SESSION_MOVE_UNAVAILABLE = "Session not found or not accessible";
@@ -877,6 +940,7 @@ export async function handleSessions(
     }
     const filterOpts = {
       source: sources,
+      hideSource: parsed.query.hideSource,
       q: parsed.query.q,
       requestedByUserId: parsed.query.requestedByUserId,
       contextKeyPrefix: parsed.query.contextKeyPrefix,
@@ -888,6 +952,7 @@ export async function handleSessions(
       withUserId: parsed.query.withUserId,
       now: new Date().toISOString(),
       tree: parsed.query.scope === "tree",
+      mine: parsed.query.scope === "tree" && parsed.query.show !== "all",
       ...(actor.kind === "user"
         ? {
             viewer: {
@@ -922,7 +987,33 @@ export async function handleSessions(
   if (sessionTree.match(req.method, pathSegments)) {
     const parsed = await sessionTree.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    sessionTree.respond(res, 200, await getSessionTree(await resolveSessionActor(req, myAgentId)));
+    const actor = await resolveSessionActor(req, myAgentId);
+    sessionTree.respond(
+      res,
+      200,
+      await getSessionTree(actor, undefined, {
+        mine: parsed.query.show !== "all",
+        hideSource: parsed.query.hideSource,
+      }),
+    );
+    return true;
+  }
+
+  if (triageSessionListRoute.match(req.method, pathSegments)) {
+    const parsed = await triageSessionListRoute.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const actor = await resolveSessionActor(req, myAgentId);
+    if (actor.kind !== "user" || !actor.userId) {
+      jsonError(res, "Pick a user to triage sessions", 400);
+      return true;
+    }
+    const { action, show, ...list } = parsed.body;
+    const updated = await triageSessionList(
+      actor.userId,
+      { ...list, mine: show !== "all" },
+      action,
+    );
+    triageSessionListRoute.respond(res, 200, { updated });
     return true;
   }