@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/src/http/apps.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import * as z from "zod";
+import type { AppActionCaller } from "../apps/action-caller";
 import {
   type AppDefinition,
   AppNameSchema,
@@ -660,45 +661,64 @@ const syncAppRoute = route({
 });
 
 /**
- * RBAC-gate an app operation and resolve the acting principal's stable actor id
- * (`user:<id>`, `agent:<id>`, or `operator`) for row provenance. Returns null
- * (after writing the 403) when the write is denied.
+ * Check app permissions and resolve server-verified identity for action input
+ * and row provenance. Return null after a 403 response when access is denied.
  */
-async function authorizeApp(
+async function authorizeAppCaller(
   req: IncomingMessage,
   res: ServerResponse,
   myAgentId: string | undefined,
   verb: "app.manage" | "app.use",
   resource: RbacResource,
-): Promise<string | null> {
+): Promise<{ actor: string; caller: AppActionCaller } | null> {
   const auth = getRequestAuth(req);
   let principal: RbacPrincipal;
   let actor: string;
+  let caller: AppActionCaller;
   if (auth?.kind === "operator") {
     principal = { kind: "operator" };
-    actor = "operator";
+    // Page sessions never act as an agent, even if a header names one.
+    const agent = myAgentId && !auth.page ? await getAgentById(myAgentId) : null;
+    actor = agent ? `agent:${agent.id}` : "operator";
+    caller = agent
+      ? { kind: "agent", id: agent.id, name: agent.name }
+      : { kind: "operator", id: null };
   } else if (auth?.kind === "user") {
     principal = { kind: "user", userId: auth.userId };
     actor = `user:${auth.userId}`;
-  } else if (auth?.kind === "guest") {
+    caller = { kind: "user", id: auth.userId, name: auth.user.name };
+  } else if (auth?.kind === "guest" || auth?.kind === "controller") {
     principal = { kind: "guest" };
     actor = "guest";
+    caller = { kind: "guest", id: null };
   } else {
     const agent = myAgentId ? await getAgentById(myAgentId) : null;
     principal = { kind: "agent", agentId: myAgentId ?? "", isLead: agent?.isLead ?? false };
     actor = myAgentId ? `agent:${myAgentId}` : "agent";
+    caller = { kind: "agent", id: myAgentId ?? null, name: agent?.name };
   }
+  if (auth?.page) caller.pageId = auth.page.id;
   const decision = can({
     principal,
     verb,
     resource,
     source: "http",
   });
-  if (decision.allow) return actor;
+  if (decision.allow) return { actor, caller };
   jsonError(res, decision.reason, 403);
   return null;
 }
 
+async function authorizeApp(
+  req: IncomingMessage,
+  res: ServerResponse,
+  myAgentId: string | undefined,
+  verb: "app.manage" | "app.use",
+  resource: RbacResource,
+): Promise<string | null> {
+  return (await authorizeAppCaller(req, res, myAgentId, verb, resource))?.actor ?? null;
+}
+
 async function authorizeAppManage(
   req: IncomingMessage,
   res: ServerResponse,
@@ -1326,8 +1346,12 @@ export async function handleApps(
     if (enforceContentLengthCap(req, res, MAX_APP_ROW_BODY_BYTES) === BODY_TOO_LARGE) return true;
     const parsed = await runActionRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const actor = await authorizeAppUse(req, res, myAgentId, parsed.params.id);
-    if (!actor) return true;
+    const identity = await authorizeAppCaller(req, res, myAgentId, "app.use", {
+      kind: "app",
+      appId: parsed.params.id,
+    });
+    if (!identity) return true;
+    const { actor, caller } = identity;
 
     const app = await getApp(parsed.params.id);
     if (!app) {
@@ -1375,7 +1399,7 @@ export async function handleApps(
 
       const output = await runSavedScriptAsAgent({
         script,
-        input: { ...action.args, ...input, app: { id: app.id } },
+        input: { ...action.args, ...input, app: { id: app.id }, caller },
         agentId: runAsAgentId,
       });
       const ok = output.exitCode === 0 && !output.error && !output.runtimeError;
@@ -1434,6 +1458,7 @@ export async function handleApps(
       app_id: app.id,
       action_name: parsed.params.name,
       input_json: JSON.stringify(input),
+      caller_json: JSON.stringify(caller),
     });
     const task = await createTaskWithSiblingAwareness(
       taskPrompt.text,

package/src/http/assets.ts

@@ -7,6 +7,7 @@ import { resolveHttpAuditUserId } from "../be/audit-user";
 import {
   getDb,
   getDbClient,
+  getRootTaskChain,
   getTaskById,
   listAssetSummaries,
   moveAssetKey,
@@ -120,10 +121,17 @@ function ensureOperator(req: IncomingMessage, res: ServerResponse): boolean {
 }
 
 const moveAssetBodySchema = z.object({ key: AssetKeySchema });
+const moveGenericAssetBodySchema = moveAssetBodySchema.extend({
+  cascade: z
+    .boolean()
+    .optional()
+    .describe("For tasks only, also move every descendant task recursively through parentTaskId."),
+});
 const moveAssetSuccessSchema = z.object({
   entityType: AssetEntityTypeSchema,
   id: z.string(),
   key: AssetKeySchema,
+  movedTaskIds: z.array(z.string()).optional(),
 });
 const moveAssetResponses = {
   200: { description: "Asset namespace updated", schema: moveAssetSuccessSchema },
@@ -168,7 +176,7 @@ const moveAssetRoute = route({
     "Updates namespace metadata only. Provider-backed files keep the same provider key, org, and drive; no remote move occurs. Personal keys are labels, not a privacy guarantee.",
   tags: ["Assets"],
   params: z.object({ entityType: AssetEntityTypeSchema, id: z.string().min(1) }),
-  body: moveAssetBodySchema,
+  body: moveGenericAssetBodySchema,
   responses: moveAssetResponses,
   rbac: {
     ungated:
@@ -302,17 +310,29 @@ export async function handleAssets(
   ) {
     const parsed = await moveAssetRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
+    if (parsed.body.cascade && parsed.params.entityType !== "task") {
+      jsonError(res, "Cascade is only supported for task namespace moves", 400);
+      return true;
+    }
     if (parsed.params.entityType === "file" && !ensureOperator(req, res)) return true;
+    let descendantTaskIds: string[] | undefined;
     if (parsed.params.entityType === "task") {
       const task = await getTaskById(parsed.params.id);
       if (!task) {
         jsonError(res, "Asset not found", 404);
         return true;
       }
-      if (!(await canMutateTaskNamespace(task, myAgentId, req))) {
-        jsonError(res, "Not authorized to move this task namespace", 403);
-        return true;
+      // Only the tasks checked here move: a subtask created after this read stays put.
+      const tasks = parsed.body.cascade ? await getRootTaskChain(task.id) : [task];
+      for (const target of tasks) {
+        if (!(await canMutateTaskNamespace(target, myAgentId, req))) {
+          jsonError(res, "Not authorized to move this task namespace", 403);
+          return true;
+        }
       }
+      descendantTaskIds = tasks
+        .filter((target) => target.id !== task.id)
+        .map((target) => target.id);
     }
     if (parsed.params.entityType === "app") {
       if (!(await getApp(parsed.params.id))) {
@@ -344,6 +364,7 @@ export async function handleAssets(
         id: parsed.params.id,
         key,
         changedBy: actor ?? undefined,
+        descendantTaskIds,
       });
       if (!moved) {
         jsonError(res, "Asset not found", 404);
@@ -353,6 +374,7 @@ export async function handleAssets(
         entityType: parsed.params.entityType,
         id: parsed.params.id,
         key,
+        ...moved,
       });
     } catch (error) {
       if (error instanceof AssetKeyAuthorizationError) {

package/src/http/config.ts

@@ -31,6 +31,7 @@ import { SwarmConfigSchema } from "../types";
 import { getRequestAuth, type HttpRequestAuth } from "../utils/request-auth-context";
 import { registerVolatileSecret } from "../utils/secret-scrubber";
 import { reloadGlobalConfigsAndIntegrations, scheduleIntegrationsReload } from "./core";
+import { syncRankingAfterConfigChange } from "./ranking";
 import { route } from "./route-def";
 import { duplicateGuardedQueryKey, jsonError } from "./utils";
 
@@ -527,6 +528,7 @@ export async function handleConfig(
       if (scope === "global" && key === "SWARM_ORG_WEBSITE") {
         await fillOrgLogoFromWebsite(String(value));
       }
+      if (scope === "global") await syncRankingAfterConfigChange(key, String(value));
       if (scope === "global") {
         scheduleIntegrationsReload();
       }
@@ -561,6 +563,7 @@ export async function handleConfig(
       return true;
     }
     if (existing.scope === "global") {
+      await syncRankingAfterConfigChange(existing.key, null);
       scheduleIntegrationsReload();
     }
     if (

package/src/http/context.ts

@@ -43,6 +43,7 @@ const postContext = route({
   method: "post",
   path: "/api/tasks/{id}/context",
   pattern: ["api", "tasks", null, "context"],
+  session: { taskParam: "id" },
   summary: "Record a context usage snapshot for a task",
   tags: ["Tasks"],
   params: z.object({ id: z.string() }),
@@ -72,6 +73,7 @@ const getContext = route({
   method: "get",
   path: "/api/tasks/{id}/context",
   pattern: ["api", "tasks", null, "context"],
+  session: { taskParam: "id" },
   summary: "Get context usage history for a task",
   tags: ["Tasks"],
   params: z.object({ id: z.string() }),

package/src/http/core.ts

@@ -47,6 +47,14 @@ import { refreshSecretScrubberCache, registerSensitiveKeyName } from "../utils/s
 import { resolveHttpRequestAuth } from "./auth";
 import { generateOpenApiSpec, SCALAR_HTML } from "./openapi";
 import { findRoute, isPublicRoute, route, runtimeInstanceHeader } from "./route-def";
+import {
+  canReadSession,
+  pathSessionDenial,
+  readableByFor,
+  resolveSessionActor,
+  SESSION_READ_DENIED,
+  userAgentIdentityDenial,
+} from "./session-access";
 import {
   agentWithCapacity,
   duplicateGuardedQueryKey,
@@ -503,6 +511,15 @@ export async function handleCore(
     setRequestAuth(req, auth);
   }
 
+  // A user token never gains agent identity from X-Agent-ID, on /mcp, /api/poll
+  // or any worker-header route.
+  const routeDef = findRoute(req.method, pathSegments);
+  const agentIdentityDenial = await userAgentIdentityDenial(req, routeDef, pathSegments);
+  if (agentIdentityDenial) {
+    jsonError(res, agentIdentityDenial, 403);
+    return true;
+  }
+
   if (auth?.kind === "agent") {
     const query = parseQueryParams(req.url || "");
     const duplicate = duplicateGuardedQueryKey(query);
@@ -565,7 +582,7 @@ export async function handleCore(
   if (auth?.kind === "user" && isRbacEnabled()) {
     const grant = await getUserGrant(auth.userId);
     if (!grant.grantsAll) {
-      const def = findRoute(req.method, pathSegments);
+      const def = routeDef;
       const decision = decideAdmission({
         method: req.method ?? "",
         rbac: def?.rbac,
@@ -585,6 +602,16 @@ export async function handleCore(
     }
   }
 
+  // Session access for every route keyed by a task or steering message, before
+  // its handler reads or changes anything (the route's `session` posture).
+  if (routeDef?.session) {
+    const sessionDenial = await pathSessionDenial(req, myAgentId, routeDef, pathSegments);
+    if (sessionDenial) {
+      jsonError(res, sessionDenial, 403);
+      return true;
+    }
+  }
+
   // POST /internal/reload-config — re-read swarm_config into process.env and re-init integrations
   if (req.method === "POST" && req.url === "/internal/reload-config") {
     try {
@@ -662,7 +689,14 @@ export async function handleCore(
     const queryParams = parseQueryParams(req.url || "");
     const taskId = queryParams.get("taskId");
 
+    // A user token naming an agent in X-Agent-ID still reads only its sessions.
+    const sessionActor = await resolveSessionActor(req, myAgentId);
     if (taskId) {
+      if (!(await canReadSession(req, myAgentId, taskId))) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: SESSION_READ_DENIED }));
+        return true;
+      }
       // Check if specific task is cancelled
       const task = await getTaskById(taskId);
       if (task && task.status === "cancelled") {
@@ -687,7 +721,10 @@ export async function handleCore(
     }
 
     // No taskId - return all recently cancelled tasks for this agent
-    const cancelledTasks = await getRecentlyCancelledTasksForAgent(myAgentId);
+    const cancelledTasks = await getRecentlyCancelledTasksForAgent(
+      myAgentId,
+      readableByFor(sessionActor),
+    );
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ cancelled: cancelledTasks }));
     return true;

package/src/http/events.ts

@@ -13,7 +13,8 @@ import {
   EventStatusSchema,
   SwarmEventSchema,
 } from "../types";
-import { route } from "./route-def";
+import { bodyListTask, bodyTask, route } from "./route-def";
+import { readableByFor, resolveSessionActor } from "./session-access";
 import { jsonError } from "./utils";
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
@@ -36,6 +37,7 @@ const createEventRoute = route({
   method: "post",
   path: "/api/events",
   pattern: ["api", "events"],
+  session: bodyTask("taskId"),
   summary: "Store a single event",
   tags: ["Events"],
   body: eventBodySchema,
@@ -53,6 +55,7 @@ const createEventsBatchRoute = route({
   method: "post",
   path: "/api/events/batch",
   pattern: ["api", "events", "batch"],
+  session: bodyListTask("events", "taskId"),
   summary: "Store multiple events in a batch",
   tags: ["Events"],
   body: z.object({
@@ -153,7 +156,7 @@ export async function handleEvents(
   res: ServerResponse,
   pathSegments: string[],
   queryParams: URLSearchParams,
-  _myAgentId: string | undefined,
+  myAgentId: string | undefined,
 ): Promise<boolean> {
   // Match batch BEFORE generic /api/events (POST)
   if (createEventsBatchRoute.match(req.method, pathSegments)) {
@@ -252,6 +255,7 @@ export async function handleEvents(
       limit: parsed.query.limit ?? 100,
       events: eventFilter,
       latestPerDataField: latestPerDataField ? { events: latestEvents, dataFields } : undefined,
+      readableBy: readableByFor(await resolveSessionActor(req, myAgentId)),
     });
     getEventsRoute.respond(
       res,

package/src/http/favorite-owner.ts

@@ -16,7 +16,7 @@ export type FavoriteOwner = {
  */
 export const DASHBOARD_USER_HEADER = "x-swarm-user-id";
 
-function dashboardUserIdHeader(req: IncomingMessage): string | null {
+export function dashboardUserIdHeader(req: IncomingMessage): string | null {
   const raw = req.headers[DASHBOARD_USER_HEADER];
   const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
   return value ? value : null;

package/src/http/fs.ts

@@ -15,6 +15,7 @@ import { getCurrentRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { requestPrincipal } from "./request-principal";
 import { route } from "./route-def";
+import { canReadSession, SESSION_READ_DENIED } from "./session-access";
 import { BODY_TOO_LARGE, enforceContentLengthCap, jsonError } from "./utils";
 
 // Upload wall-clock past which the provider round-trip is worth a log line.
@@ -126,6 +127,7 @@ const listTaskFilesRoute = route({
   method: "get",
   path: "/api/fs/tasks/{taskId}/files",
   pattern: ["api", "fs", "tasks", null, "files"],
+  session: { taskParam: "taskId" },
   summary: "List task file attachments",
   tags: ["FS"],
   params: taskParams,
@@ -142,6 +144,7 @@ const uploadTaskFileRoute = route({
   method: "post",
   path: "/api/fs/tasks/{taskId}/files",
   pattern: ["api", "fs", "tasks", null, "files"],
+  session: { taskParam: "taskId" },
   summary: "Upload a binary task file attachment",
   description:
     "Accepts a raw binary request body. Pass the display/path name as the `name` query parameter.",
@@ -163,6 +166,7 @@ const getTaskFileRoute = route({
   method: "get",
   path: "/api/fs/tasks/{taskId}/files/{attachmentId}",
   pattern: ["api", "fs", "tasks", null, "files", null],
+  session: { taskParam: "taskId" },
   summary: "Get task file attachment metadata",
   tags: ["FS"],
   params: attachmentParams,
@@ -176,6 +180,7 @@ const downloadTaskFileRoute = route({
   method: "get",
   path: "/api/fs/tasks/{taskId}/files/{attachmentId}/raw",
   pattern: ["api", "fs", "tasks", null, "files", null, "raw"],
+  session: { taskParam: "taskId" },
   summary: "Download raw task file bytes",
   description: "Streams raw bytes. File content is not secret-scrubbed.",
   tags: ["FS"],
@@ -193,6 +198,7 @@ const signedUrlTaskFileRoute = route({
   method: "get",
   path: "/api/fs/tasks/{taskId}/files/{attachmentId}/signed-url",
   pattern: ["api", "fs", "tasks", null, "files", null, "signed-url"],
+  session: { taskParam: "taskId" },
   summary: "Create a provider signed GET URL for a task file",
   tags: ["FS"],
   params: attachmentParams,
@@ -208,6 +214,7 @@ const deleteTaskFileRoute = route({
   method: "delete",
   path: "/api/fs/tasks/{taskId}/files/{attachmentId}",
   pattern: ["api", "fs", "tasks", null, "files", null],
+  session: { taskParam: "taskId" },
   summary: "Delete a task file attachment",
   tags: ["FS"],
   params: attachmentParams,
@@ -263,7 +270,13 @@ export async function handleFs(
   if (downloadTaskFileRoute.match(req.method, pathSegments)) {
     const parsed = await downloadTaskFileRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const attachment = await findAttachment(parsed.params.taskId, parsed.params.attachmentId, res);
+    const attachment = await findAttachment(
+      req,
+      myAgentId,
+      parsed.params.taskId,
+      parsed.params.attachmentId,
+      res,
+    );
     if (!attachment) return true;
     return sendDownload(res, attachment);
   }
@@ -271,7 +284,13 @@ export async function handleFs(
   if (signedUrlTaskFileRoute.match(req.method, pathSegments)) {
     const parsed = await signedUrlTaskFileRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const attachment = await findAttachment(parsed.params.taskId, parsed.params.attachmentId, res);
+    const attachment = await findAttachment(
+      req,
+      myAgentId,
+      parsed.params.taskId,
+      parsed.params.attachmentId,
+      res,
+    );
     if (!attachment) return true;
     return sendSignedUrl(res, attachment, parsed.query.expiresIn);
   }
@@ -279,7 +298,13 @@ export async function handleFs(
   if (getTaskFileRoute.match(req.method, pathSegments)) {
     const parsed = await getTaskFileRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    const attachment = await findAttachment(parsed.params.taskId, parsed.params.attachmentId, res);
+    const attachment = await findAttachment(
+      req,
+      myAgentId,
+      parsed.params.taskId,
+      parsed.params.attachmentId,
+      res,
+    );
     if (!attachment) return true;
     getTaskFileRoute.respond(res, 200, attachment);
     return true;
@@ -313,6 +338,10 @@ export async function handleFs(
     const parsed = await listTaskFilesRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     if (!(await getTaskById(parsed.params.taskId))) return notFound(res, "Task not found");
+    if (!(await canReadSession(req, myAgentId, parsed.params.taskId))) {
+      jsonError(res, SESSION_READ_DENIED, 403);
+      return true;
+    }
     listTaskFilesRoute.respond(res, 200, {
       attachments: await getTaskAttachments(parsed.params.taskId),
     });
@@ -493,6 +522,8 @@ function backingProviderId(attachment: TaskAttachment): string | null {
 }
 
 async function findAttachment(
+  req: IncomingMessage,
+  myAgentId: string | undefined,
   taskId: string,
   attachmentId: string,
   res: ServerResponse,
@@ -501,6 +532,10 @@ async function findAttachment(
     notFound(res, "Task not found");
     return null;
   }
+  if (!(await canReadSession(req, myAgentId, taskId))) {
+    jsonError(res, SESSION_READ_DENIED, 403);
+    return null;
+  }
   const attachment = (await getTaskAttachments(taskId)).find((item) => item.id === attachmentId);
   if (!attachment) {
     notFound(res, "Attachment not found");

package/src/http/inbox-state.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { listInboxState, upsertInboxState } from "../be/db";
+import { getDbClient, listInboxState, upsertInboxState } from "../be/db";
 import { InboxItemStateSchema, InboxItemStatusSchema, InboxItemTypeSchema } from "../types";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
@@ -29,29 +29,60 @@ const listState = route({
   auth: { apiKey: true },
 });
 
+const inboxStateItemSchema = z.object({
+  itemType: InboxItemTypeSchema,
+  itemId: z.string().min(1),
+  status: InboxItemStatusSchema,
+  snoozeUntil: z.string().datetime().optional(),
+  readAt: z.string().datetime().optional(),
+  lastReadAt: z
+    .string()
+    .datetime()
+    .nullable()
+    .optional()
+    .describe(
+      "Omit to preserve the read cursor, send null to clear it, or send a timestamp to set it, including an earlier time.",
+    ),
+});
+
 const upsertState = route({
   method: "patch",
   path: "/api/inbox-state",
   pattern: ["api", "inbox-state"],
   summary: "Upsert per-user dismiss/snooze/done state for an inbox item",
   tags: ["Inbox State"],
+  body: inboxStateItemSchema.extend({ userId: z.string() }),
+  responses: {
+    200: {
+      description: "Upserted inbox state row",
+      schema: z.object({ item: InboxItemStateSchema }),
+    },
+    400: { description: "Validation error" },
+    401: { description: "Unauthorized" },
+  },
+  auth: { apiKey: true },
+});
+
+const bulkUpsertState = route({
+  method: "patch",
+  path: "/api/inbox-state/bulk",
+  pattern: ["api", "inbox-state", "bulk"],
+  summary: "Upsert inbox-item state in one transaction",
+  tags: ["Inbox State"],
   body: z.object({
     userId: z.string(),
-    itemType: InboxItemTypeSchema,
-    itemId: z.string().min(1),
-    status: InboxItemStatusSchema,
-    snoozeUntil: z.string().datetime().optional(),
-    readAt: z.string().datetime().optional(),
+    items: z.array(inboxStateItemSchema).min(1).max(200),
   }),
   responses: {
     200: {
-      description: "Upserted inbox state row",
-      schema: z.object({ item: InboxItemStateSchema }),
+      description: "Upserted inbox state rows in request order",
+      schema: z.object({ items: z.array(InboxItemStateSchema) }),
     },
     400: { description: "Validation error" },
     401: { description: "Unauthorized" },
   },
   auth: { apiKey: true },
+  rbac: { ungated: "per-user inbox UI state, same posture as PATCH /api/inbox-state" },
 });
 
 // ─── Handler ─────────────────────────────────────────────────────────────────
@@ -74,6 +105,24 @@ export async function handleInboxState(
     return true;
   }
 
+  if (bulkUpsertState.match(req.method, pathSegments)) {
+    const parsed = await bulkUpsertState.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    try {
+      const items = await getDbClient().transaction(async () => {
+        const rows = [];
+        for (const item of parsed.body.items) {
+          rows.push(await upsertInboxState({ ...item, userId: parsed.body.userId }));
+        }
+        return rows;
+      });
+      bulkUpsertState.respond(res, 200, { items });
+    } catch (err) {
+      jsonError(res, err instanceof Error ? err.message : "Failed to upsert inbox state", 500);
+    }
+    return true;
+  }
+
   if (upsertState.match(req.method, pathSegments)) {
     const parsed = await upsertState.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
@@ -85,6 +134,7 @@ export async function handleInboxState(
         status: parsed.body.status,
         snoozeUntil: parsed.body.snoozeUntil,
         readAt: parsed.body.readAt,
+        lastReadAt: parsed.body.lastReadAt,
       });
       upsertState.respond(res, 200, { item });
     } catch (err) {

package/src/http/index.ts

@@ -116,6 +116,7 @@ import { handlePagesPublic } from "./pages-public";
 import { handlePoll } from "./poll";
 import { handlePricing } from "./pricing";
 import { handlePromptTemplates } from "./prompt-templates";
+import { handleRanking } from "./ranking";
 import { handleRealtimeAsset, handleRealtimeTicket } from "./realtime";
 import { handleRepos } from "./repos";
 import { handleRooms } from "./rooms";
@@ -403,10 +404,11 @@ const httpServer = createHttpServer(async (req, res) => {
         () => handleExtensions(req, res, pathSegments, queryParams, myAgentId),
         () => handleFavorites(req, res, pathSegments, queryParams, myAgentId),
         () => handleUsers(req, res, pathSegments, queryParams),
-        () => handleSessions(req, res, pathSegments, queryParams),
+        () => handleSessions(req, res, pathSegments, queryParams, myAgentId),
         () => handleInboxState(req, res, pathSegments, queryParams),
         () => handleTelemetryUi(req, res, pathSegments, queryParams, myAgentId),
         () => handleUsedBy(req, res, pathSegments, queryParams, myAgentId),
+        () => handleRanking(req, res, pathSegments, queryParams),
         () => handleFleetBenchmark(req, res, pathSegments, queryParams),
         () => handleTaskTemplates(req, res, pathSegments, queryParams),
         () => handleMcp(req, res, transports, transportActivity, mcpSessionAgents),

package/src/http/memory.ts

@@ -44,7 +44,7 @@ import { AgentMemorySchema, AgentMemoryScopeSchema, AgentMemorySourceSchema } fr
 import { getRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { rejectGuest } from "./request-principal";
-import { route } from "./route-def";
+import { bodyTask, route } from "./route-def";
 import { jsonError, parseQueryParams } from "./utils";
 
 // ─── Response Schemas ────────────────────────────────────────────────────────
@@ -68,6 +68,7 @@ const indexMemory = route({
   method: "post",
   path: "/api/memory/index",
   pattern: ["api", "memory", "index"],
+  session: bodyTask("sourceTaskId"),
   summary: "Ingest content into memory system (async embedding)",
   tags: ["Memory"],
   // The gate only bites when the key that lands on the rows (here, `sourcePath`) sits under a
@@ -687,6 +688,7 @@ const rateMemory = route({
   method: "post",
   path: "/api/memory/rate",
   pattern: ["api", "memory", "rate"],
+  session: { none: "worker-only: it needs X-Agent-ID, which a user token cannot send" },
   summary: "Submit RatingEvents to update memory usefulness posteriors",
   tags: ["Memory"],
   auth: { apiKey: true, agentId: true },