@desplega.ai/agent-swarm 2.2.0 → 2.4.0

package/dist/{http-fn978m0g.js → http-xpmmq028.js}

@@ -69,28 +69,6 @@ import {
   resolveKvView,
   toolErr,
   createToolRegistrar,
-  duplicateGuardedQueryKey,
-  warnIfCorsAllowsAnyOrigin,
-  isOriginAllowedForCredentials,
-  allowedCredentialRedirect,
-  setCorsHeaders,
-  parseQueryParams,
-  getPathSegments,
-  wireHttpSpanLifecycle,
-  safeRequestUrlForLog,
-  agentWithCapacity,
-  parseBody,
-  BODY_TOO_LARGE,
-  enforceContentLengthCap,
-  json,
-  jsonError,
-  writeUnhandledError,
-  triggerSchemaErrorResponse,
-  deriveApiBaseUrl,
-  httpServerSemconvAttributes,
-  runtimeInstanceHeader,
-  describeRequestRoute,
-  route,
   handleMcpBridge,
   Redacted,
   SCRIPT_SDK_RESPONSE_LIMIT_BYTES,
@@ -199,9 +177,6 @@ import {
   scheduleIntegrationsReload,
   handleCore,
   userCtx,
-  resolveTaskAuditUserId,
-  resolveHttpAuditUserId,
-  resolveHttpFavoriteOwner,
   handleApps,
   cancelApprovalRequest,
   getUserCommsPrefs,
@@ -262,6 +237,8 @@ import {
   resolveRoomNamespace,
   roomRequestInfo,
   authorizeRoomNamespace,
+  sessionAccessTopic,
+  sessionPresenceRoot,
   RoomOperationSchema,
   removeAwarenessStates,
   roomTopic,
@@ -303,7 +280,7 @@ import {
   hasCapability,
   getEnabledCapabilities,
   createServer
-} from "./cli-bddxamg7.js";
+} from "./cli-x719j3vs.js";
 import {
   chatThreadOfContextKey,
   agentContextKey,
@@ -440,6 +417,17 @@ import {
   CHAT_SDK_ADAPTER_NAMES,
   isAdapterEntryEnabled,
   init_schema,
+  TELEMETRY_RANKING_KEY,
+  PUBLIC_RANKING_ENABLED_KEY,
+  RANKING_CATEGORIES,
+  readTelemetryRanking,
+  rankingFormSchema,
+  mintRankingClaim,
+  buildListing,
+  rankingEntryFile,
+  rankingPrUrl,
+  rankingLeaveUrl,
+  init_telemetry_ranking,
   API_DRAINING_HEADER,
   init_api_drain,
   parseTaskToolManifest,
@@ -724,26 +712,26 @@ import {
   countScriptRunJournalSteps2,
   countScriptRunJournalAgentTaskSteps2,
   init_db3
-} from "./cli-4c7k75rq.js";
+} from "./cli-rg7ntypm.js";
 import {
   getUserGrant2,
   init_rbac_roles
-} from "./cli-6q7pyd3k.js";
-import"./cli-mnry16kh.js";
+} from "./cli-5s5hx57y.js";
+import"./cli-kk2r80n5.js";
 import {
   normalizeModelKey
-} from "./cli-8w65vwee.js";
+} from "./cli-tg9ksbn8.js";
 import {
   upsertModelCatalogOverlay,
   deleteModelCatalogOverlay,
   loadModelsCatalog,
   requestModelCatalogRefresh2
-} from "./cli-jhhb2v9n.js";
+} from "./cli-ttaz6c7m.js";
 import {
   AMP_ESTIMATE_MODELS,
   ampBillsCacheWrites,
   resolveAmpModel
-} from "./cli-vmbakbq0.js";
+} from "./cli-2rwet3r7.js";
 import {
   automationIntegrationFixUrl,
   preflightAutomation,
@@ -755,7 +743,7 @@ import {
   cancelWorkflowRun2,
   TriggerSchemaError,
   startWorkflowExecution2
-} from "./cli-dw0njd9q.js";
+} from "./cli-nme7wery.js";
 import {
   require_dist2,
   isInvalidClientError,
@@ -835,14 +823,14 @@ import {
   typecheckWithAmbient,
   typecheckScript,
   parseSkillContent
-} from "./cli-mvsfbbgq.js";
+} from "./cli-nrrg0fvy.js";
 import {
   buildAuthorizationUrl,
   exchangeAuthorizationCode,
   oauthAppRowToProviderConfig,
   forceRefreshAuthorizationOrThrow,
   forceRefreshTokenOrThrow
-} from "./cli-xx13gqf3.js";
+} from "./cli-b80a1100.js";
 import {
   signalProcessGroup,
   detachedProcessGroup,
@@ -870,15 +858,15 @@ import {
   getSlackApp2,
   startSlackApp2,
   stopSlackApp2
-} from "./cli-tba8fxf9.js";
-import"./cli-ztcxv5nv.js";
+} from "./cli-4fhyq711.js";
+import"./cli-xfe63zx3.js";
 import {
   createApprovalFollowUpTask,
   generateEdges,
   definitionNodeIds,
   validateDefinition
-} from "./cli-hwc4a9xm.js";
-import"./cli-8cvvytad.js";
+} from "./cli-tj4j2ts4.js";
+import"./cli-bn26xbcs.js";
 import {
   _fetchHolder,
   CLIENT_ID,
@@ -894,6 +882,48 @@ import {
   workflowEventBus2,
   init_event_bus
 } from "./cli-ptkpaqfy.js";
+import {
+  duplicateGuardedQueryKey,
+  warnIfCorsAllowsAnyOrigin,
+  isOriginAllowedForCredentials,
+  allowedCredentialRedirect,
+  setCorsHeaders,
+  parseQueryParams,
+  getPathSegments,
+  wireHttpSpanLifecycle,
+  safeRequestUrlForLog,
+  agentWithCapacity,
+  parseBody,
+  BODY_TOO_LARGE,
+  enforceContentLengthCap,
+  json,
+  jsonError,
+  writeUnhandledError,
+  triggerSchemaErrorResponse,
+  deriveApiBaseUrl,
+  httpServerSemconvAttributes,
+  hasSessionAccess,
+  getSessionRoot,
+  sessionAccessForRoot,
+  listActiveSessionShares,
+  toSessionSharesState,
+  setSessionShares,
+  resolveTaskAuditUserId,
+  resolveHttpAuditUserId,
+  dashboardUserIdHeader,
+  resolveHttpFavoriteOwner,
+  resolveSessionActor2,
+  sessionAccessFor2,
+  SESSION_READ_DENIED2,
+  canReadSession2,
+  readableByFor2,
+  SESSION_WRITE_DENIED2,
+  runtimeInstanceHeader,
+  bodyTask,
+  bodyListTask,
+  describeRequestRoute,
+  route
+} from "./cli-02vhhssk.js";
 import {
   isMultiRuntimeEnabled
 } from "./cli-7a91w22y.js";
@@ -906,24 +936,6 @@ import {
 } from "./cli-qje9k2nh.js";
 import {
   RuntimePoolError2,
-  registerSessionTokenConnection,
-  init_session_token_connections,
-  findUserById,
-  getUserIdentities,
-  listUserEvents,
-  listUserTokens,
-  recordIdentityEvent,
-  linkIdentity,
-  unlinkIdentity,
-  mintToken,
-  revokeToken,
-  resolveUserByToken,
-  InvalidRuntimeTokenError,
-  mintSessionToken,
-  mintRuntimeToken,
-  revokeSessionToken,
-  fingerprintApiKey,
-  init_users,
   mintControllerToken,
   init_tokens,
   listRuntimeControllers2,
@@ -942,7 +954,7 @@ import {
   resolvePoolDelivery2,
   createPoolAgent2,
   init_db
-} from "./cli-h23mr2s6.js";
+} from "./cli-6ftrrwm1.js";
 import {
   RATING_MODEL_MAX_LENGTH,
   REFERENCES_SOURCE_MAX_LENGTH,
@@ -958,8 +970,8 @@ import {
   checkHeartbeatChecklist2,
   runHeartbeatSweep2,
   stopHeartbeat2
-} from "./cli-0k9rcwfy.js";
-import"./cli-raejy0mp.js";
+} from "./cli-bhwa8rzc.js";
+import"./cli-eqgfs202.js";
 import {
   import_websocket,
   import_websocket_server
@@ -968,7 +980,7 @@ import {
   runtimeSupervisorStatus,
   startRuntimeSupervisor,
   stopRuntimeSupervisor
-} from "./cli-z3dk189k.js";
+} from "./cli-rsd7ga7v.js";
 import"./cli-ns59dc6r.js";
 import {
   ACP_TARGET_IDS
@@ -980,20 +992,22 @@ import {
 import {
   MAX_RATE_LIMIT_RESET_MS
 } from "./cli-gx4rm0qx.js";
-import {
-  inviteEmailToSharedOrg,
-  ensureAgentFsCredentialsForAgent
-} from "./cli-ak4c12mh.js";
-import {
-  Anthropic
-} from "./cli-er83cjbn.js";
 import {
   isLeadChannelMonitoringEnabled,
+  ORG_IDENTITY_KEYS,
+  orgIdentityStatus,
   SIMILARITY_THRESHOLD,
   memoryRelevance,
   isUnknownModelError,
   writeSkillsToFilesystem
-} from "./cli-4g629sgr.js";
+} from "./cli-wrv09v7q.js";
+import {
+  inviteEmailToSharedOrg,
+  ensureAgentFsCredentialsForAgent
+} from "./cli-5ff2sjyt.js";
+import {
+  Anthropic
+} from "./cli-er83cjbn.js";
 import {
   isCodexOAuthConfigKey
 } from "./cli-j4bwnpkm.js";
@@ -1005,7 +1019,27 @@ import"./cli-13p25grh.js";
 import"./cli-0adyhvq2.js";
 import {
   require_content_type
-} from "./cli-gzvb3d4a.js";
+} from "./cli-1jx0srjt.js";
+import {
+  registerSessionTokenConnection,
+  init_session_token_connections,
+  findUserById,
+  getUserIdentities,
+  listUserEvents,
+  listUserTokens,
+  recordIdentityEvent,
+  linkIdentity,
+  unlinkIdentity,
+  mintToken,
+  revokeToken,
+  resolveUserByToken,
+  InvalidRuntimeTokenError,
+  mintSessionToken,
+  mintRuntimeToken,
+  revokeSessionToken,
+  fingerprintApiKey,
+  init_users
+} from "./cli-8cxkw1f5.js";
 import"./cli-v41kn3cd.js";
 import"./cli-wgtk7xxr.js";
 import {
@@ -1019,7 +1053,7 @@ import {
   clearAuditSink,
   can,
   init_rbac
-} from "./cli-zj4d6afs.js";
+} from "./cli-1pa3rz69.js";
 import {
   isSafeBundlePath,
   init_bundle_path,
@@ -1039,6 +1073,10 @@ import {
   ProviderNameSchema,
   ModelProfileNameSchema,
   ModelProfileSchema,
+  SessionAccessSchema,
+  SessionOwnerSchema,
+  SessionSharesSchema,
+  SessionSharesUpdateSchema,
   SteerModeSchema,
   SteeringSourceSchema,
   SteeringMessageSchema,
@@ -1156,12 +1194,12 @@ import {
   KvKeySchema,
   KvEntrySchema,
   init_types
-} from "./cli-ksrphveb.js";
+} from "./cli-a1esmmee.js";
 import {
   IDENTITY_FIELD_BUDGETS,
   IdentityFieldBudgetError,
   init_identity_field_budget
-} from "./cli-cby329ny.js";
+} from "./cli-wyrr38xm.js";
 import {
   getSlackConfiguration,
   init_config
@@ -1179,7 +1217,7 @@ import {
   resolveTemplate,
   init_resolver,
   init_session_templates
-} from "./cli-w7z94e6c.js";
+} from "./cli-tx00c0h6.js";
 import {
   MODEL_SCOPED_WINDOWS,
   activeModelBlocks,
@@ -1201,6 +1239,7 @@ import {
 import {
   NEVER,
   toJSONSchema,
+  ZodError,
   string2,
   email,
   uuid,
@@ -1228,7 +1267,7 @@ import {
 import {
   init_package,
   package_default
-} from "./cli-2jm992rm.js";
+} from "./cli-mz1ezzzh.js";
 import {
   realtimeBus,
   init_bus
@@ -2367,7 +2406,8 @@ function identityFromHttpAuth(req, auth) {
       agentId,
       sourceTaskId: auth.kind === "agent" ? auth.taskId ?? undefined : header(req, "x-source-task-id"),
       userId: auth.kind === "user" ? auth.userId : undefined,
-      isOperator: auth.kind === "operator"
+      isOperator: auth.kind === "operator",
+      dashboardUserId: auth.kind === "operator" ? auth.dashboardUserId : undefined
     },
     me: {
       userId: auth.kind === "user" ? auth.userId : agentId ?? guestId,
@@ -2560,6 +2600,9 @@ function connect(ws, auth, runtimeId) {
       if (namespace.startsWith("presence:comb:") && msg.name !== "default") {
         throw new Error("Comb presence uses the default room");
       }
+      if (namespace.startsWith("presence:session:") && msg.name !== "default") {
+        throw new Error("Session presence uses the default room");
+      }
       const denied = await authorizeRoomNamespace(namespace, auth.identity, msg.op, msg.name);
       if (denied)
         throw new Error(typeof denied === "string" ? denied : "Forbidden");
@@ -2600,7 +2643,7 @@ function connect(ws, auth, runtimeId) {
           } catch (error) {
             if (!(error instanceof Error) || error.message !== "room does not exist")
               throw error;
-            const creationDenied = await authorizeRoomNamespace(namespace, auth.identity, namespace.startsWith("presence:comb:") ? "join" : true);
+            const creationDenied = await authorizeRoomNamespace(namespace, auth.identity, namespace.startsWith("presence:comb:") || namespace.startsWith("presence:session:") ? "join" : true);
             if (creationDenied)
               throw new Error(creationDenied);
             if (closed)
@@ -2610,6 +2653,8 @@ function connect(ws, auth, runtimeId) {
           if (closed)
             return;
           const stopRoom = realtimeBus.subscribe(key, (event) => {
+            if (rooms.get(key)?.suspended)
+              return;
             const view = event;
             const type = view.type;
             if (type === "deleted") {
@@ -2631,15 +2676,62 @@ function connect(ws, auth, runtimeId) {
               }).catch(() => ws.close(1011, "Room reset failed"));
             }
           });
-          const stopPresence = realtimeBus.subscribe(`presence:${key}`, (peers) => send({ type: "presence", name: msg.name, namespace, peers }));
+          const stopPresence = realtimeBus.subscribe(`presence:${key}`, (peers) => {
+            if (rooms.get(key)?.suspended)
+              return;
+            send({ type: "presence", name: msg.name, namespace, peers });
+          });
+          const sessionRoot = sessionPresenceRoot(namespace);
+          let accessCheck = 0;
+          const stopAccess = sessionRoot ? realtimeBus.subscribe(sessionAccessTopic(sessionRoot), () => {
+            const joined = rooms.get(key);
+            if (!joined)
+              return;
+            joined.suspended = true;
+            const check = ++accessCheck;
+            authorizeRoomNamespace(namespace, auth.identity, "join").catch(() => "Session access check failed").then((denied) => {
+              const current = rooms.get(key);
+              if (closed || !current || check !== accessCheck)
+                return;
+              if (denied) {
+                leave(key);
+                send({ type: "error", name: msg.name, namespace, error: denied });
+                return;
+              }
+              current.suspended = false;
+              send({
+                type: "presence",
+                name: msg.name,
+                namespace,
+                peers: [...current.room.awareness.getStates().values()]
+              });
+            });
+          }) : undefined;
           rooms.set(key, {
             room,
             version: msg.schemaVersion,
             stop: () => {
               stopRoom();
               stopPresence();
-            }
+              stopAccess?.();
+            },
+            suspended: sessionRoot !== undefined
           });
+          if (sessionRoot) {
+            const check = ++accessCheck;
+            const denied = await authorizeRoomNamespace(namespace, auth.identity, "join").catch(() => "Session access check failed");
+            if (closed)
+              return;
+            if (denied) {
+              leave(key);
+              throw new Error(denied);
+            }
+            const current = rooms.get(key);
+            if (!current)
+              throw new Error("You don't have access to this session");
+            if (check === accessCheck)
+              current.suspended = false;
+          }
           room.awareness.states.set(clientId, { ...auth.me, data: {} });
           room.awareness.meta.set(clientId, { clock: 1, lastUpdated: Date.now() });
           publishPresence(room);
@@ -3863,6 +3955,7 @@ var createActiveSession = route({
   method: "post",
   path: "/api/active-sessions",
   pattern: ["api", "active-sessions"],
+  session: bodyTask("taskId"),
   summary: "Create a new active session",
   tags: ["Active Sessions"],
   body: object2({
@@ -3883,6 +3976,7 @@ var deleteSessionByTask = route({
   method: "delete",
   path: "/api/active-sessions/by-task/{taskId}",
   pattern: ["api", "active-sessions", "by-task", null],
+  session: { taskParam: "taskId" },
   summary: "Delete active session by task ID",
   tags: ["Active Sessions"],
   params: object2({ taskId: string2() }),
@@ -3894,6 +3988,7 @@ var deleteSessionById = route({
   method: "delete",
   path: "/api/active-sessions/{id}",
   pattern: ["api", "active-sessions", null],
+  session: { activeSessionParam: "id" },
   summary: "Delete active session by ID",
   tags: ["Active Sessions"],
   params: object2({ id: string2() }),
@@ -3905,6 +4000,7 @@ var heartbeatSession = route({
   method: "put",
   path: "/api/active-sessions/heartbeat/{taskId}",
   pattern: ["api", "active-sessions", "heartbeat", null],
+  session: { taskParam: "taskId" },
   summary: "Update heartbeat for an active session",
   tags: ["Active Sessions"],
   params: object2({ taskId: string2() }),
@@ -3916,6 +4012,7 @@ var updateProviderSession = route({
   method: "put",
   path: "/api/active-sessions/provider-session/{taskId}",
   pattern: ["api", "active-sessions", "provider-session", null],
+  session: { taskParam: "taskId" },
   summary: "Update provider session ID on an active session",
   tags: ["Active Sessions"],
   params: object2({ taskId: string2() }),
@@ -3928,6 +4025,7 @@ var cleanupSessions = route({
   method: "post",
   path: "/api/active-sessions/cleanup",
   pattern: ["api", "active-sessions", "cleanup"],
+  session: { agentWide: "Deletes every session of an agent, or every stale session." },
   summary: "Clean up stale sessions",
   tags: ["Active Sessions"],
   body: object2({
@@ -3942,6 +4040,7 @@ var recoverOrphanedTasks = route({
   method: "post",
   path: "/api/active-sessions/recover-orphaned-tasks",
   pattern: ["api", "active-sessions", "recover-orphaned-tasks"],
+  session: { none: "Its handler admits only the calling agent, never a user." },
   summary: "Recover orphaned in-progress tasks for an agent",
   tags: ["Active Sessions"],
   body: object2({
@@ -3961,7 +4060,7 @@ async function handleActiveSessions(req, res, pathSegments, queryParams, myAgent
     const parsed = await listActiveSessions.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
-    const sessions = await getActiveSessions2(parsed.query.agentId || undefined);
+    const sessions = await getActiveSessions2(parsed.query.agentId || undefined, readableByFor2(await resolveSessionActor2(req, myAgentId)));
     listActiveSessions.respond(res, 200, { sessions });
     return true;
   }
@@ -4610,14 +4709,17 @@ async function handleAgentRegister(req, res, pathSegments, myAgentId) {
   }
   return false;
 }
-async function handleAgentsRest(req, res, pathSegments, queryParams, _myAgentId) {
+async function handleAgentsRest(req, res, pathSegments, queryParams, myAgentId) {
   if (listAgents.match(req.method, pathSegments)) {
     const parsed = await listAgents.parse(req, res, pathSegments, queryParams);
     if (!parsed)
       return true;
     const includeTasks = parsed.query.include === "tasks";
     const slim = parsed.query.fields !== "full";
-    const agents = includeTasks ? await getAllAgentsWithTasks2({ slim }) : await getAllAgents2({ slim });
+    const agents = includeTasks ? await getAllAgentsWithTasks2({
+      slim,
+      readableBy: readableByFor2(await resolveSessionActor2(req, myAgentId))
+    }) : await getAllAgents2({ slim });
     const [agentsWithCapacity, transports] = await Promise.all([
       Promise.all(agents.map(agentWithCapacity)),
       resolveListClaudeTransports(agents)
@@ -5155,7 +5257,7 @@ async function handleAgentsRest(req, res, pathSegments, queryParams, _myAgentId)
     if (!parsed)
       return true;
     const includeTasks = parsed.query.include === "tasks";
-    const agent = includeTasks ? await getAgentWithTasks2(parsed.params.id) : await getAgentById2(parsed.params.id);
+    const agent = includeTasks ? await getAgentWithTasks2(parsed.params.id, readableByFor2(await resolveSessionActor2(req, myAgentId))) : await getAgentById2(parsed.params.id);
     if (!agent) {
       jsonError(res, "Agent not found", 404);
       return true;
@@ -5234,6 +5336,7 @@ var reportUsage = route({
   method: "post",
   path: "/api/keys/report-usage",
   pattern: ["api", "keys", "report-usage"],
+  session: bodyTask("taskId"),
   summary: "Record which API key was used for a task",
   tags: ["API Keys"],
   body: object2({
@@ -5277,6 +5380,7 @@ var reportAuthFailure = route({
   method: "post",
   path: "/api/keys/report-auth-failure",
   pattern: ["api", "keys", "report-auth-failure"],
+  session: bodyTask("taskId"),
   summary: "Record an auth failure for a pooled key; bench it after 2 in a row",
   tags: ["API Keys"],
   body: object2({
@@ -5974,6 +6078,7 @@ var createRoute = route({
   method: "post",
   path: "/api/approval-requests",
   pattern: ["api", "approval-requests"],
+  session: bodyTask("sourceTaskId"),
   summary: "Create a new approval request",
   tags: ["ApprovalRequests"],
   body: object2({
@@ -6522,10 +6627,14 @@ function ensureOperator(req, res) {
   return false;
 }
 var moveAssetBodySchema = object2({ key: AssetKeySchema });
+var moveGenericAssetBodySchema = moveAssetBodySchema.extend({
+  cascade: boolean().optional().describe("For tasks only, also move every descendant task recursively through parentTaskId.")
+});
 var moveAssetSuccessSchema = object2({
   entityType: AssetEntityTypeSchema,
   id: string2(),
-  key: AssetKeySchema
+  key: AssetKeySchema,
+  movedTaskIds: array2(string2()).optional()
 });
 var moveAssetResponses = {
   200: { description: "Asset namespace updated", schema: moveAssetSuccessSchema },
@@ -6564,7 +6673,7 @@ var moveAssetRoute = route({
   description: "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: object2({ entityType: AssetEntityTypeSchema, id: string2().min(1) }),
-  body: moveAssetBodySchema,
+  body: moveGenericAssetBodySchema,
   responses: moveAssetResponses,
   rbac: {
     ungated: "preserves each entity's current mutation posture; task moves use task.fs.mutate, app moves use app.manage, scripts preserve agent ownership/global-lead rules, file moves require operator authentication, and personal destinations require a matching trusted user"
@@ -6671,18 +6780,27 @@ async function handleAssets(req, res, pathSegments, queryParams, myAgentId) {
     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;
     if (parsed.params.entityType === "task") {
       const task = await getTaskById2(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;
+      const tasks = parsed.body.cascade ? await getRootTaskChain2(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)) {
@@ -6712,7 +6830,8 @@ async function handleAssets(req, res, pathSegments, queryParams, myAgentId) {
         entityType: parsed.params.entityType,
         id: parsed.params.id,
         key,
-        changedBy: actor ?? undefined
+        changedBy: actor ?? undefined,
+        descendantTaskIds
       });
       if (!moved) {
         jsonError(res, "Asset not found", 404);
@@ -6721,7 +6840,8 @@ async function handleAssets(req, res, pathSegments, queryParams, myAgentId) {
       moveAssetRoute.respond(res, 200, {
         entityType: parsed.params.entityType,
         id: parsed.params.id,
-        key
+        key,
+        ...moved
       });
     } catch (error) {
       if (error instanceof AssetKeyAuthorizationError) {
@@ -7575,6 +7695,396 @@ init_rbac();
 init_types();
 init_request_auth_context();
 init_secret_scrubber();
+
+// src/http/ranking.ts
+init_zod();
+init_db3();
+init_telemetry_ranking();
+init_telemetry();
+init_env_flag();
+
+// src/http/used-by.ts
+init_zod();
+init_db3();
+init_telemetry();
+init_org_website();
+var CONSENT_KEY = "SWARM_USED_BY_CONSENT";
+var CONSENT_AT_KEY = "SWARM_USED_BY_CONSENT_AT";
+var GRANTED_NAME_KEY = "SWARM_USED_BY_ORG_NAME";
+var GRANTED_WEBSITE_KEY = "SWARM_USED_BY_ORG_WEBSITE";
+var TIMEOUT_MS = 1e4;
+var usedBy = route({
+  method: "post",
+  path: "/api/used-by",
+  pattern: ["api", "used-by"],
+  summary: "Grant or revoke the 'used by' logo consent",
+  description: "Records whether agent-swarm.dev may show this organization's logo as a company that uses Agent Swarm. Sends the organization name and website to the telemetry proxy, where a person approves each logo by hand. An explicit admin action, so it is not gated by the telemetry opt-out.",
+  tags: ["Telemetry"],
+  body: object2({ granted: boolean() }),
+  responses: {
+    200: {
+      description: "Consent recorded",
+      schema: object2({ granted: boolean(), changedAt: string2() })
+    },
+    400: {
+      description: "Organization name or website is not set (a revoke falls back to the identity of the last grant)"
+    },
+    401: { description: "Unauthorized" },
+    403: { description: "Only a config admin can change the consent" },
+    502: { description: "The telemetry proxy did not accept the consent" }
+  },
+  rbac: { permission: "config.write.any" }
+});
+async function globalConfig(key) {
+  const stored = (await getSwarmConfigs2({ scope: "global", key }))?.[0]?.value?.trim();
+  return stored || process.env[key]?.trim() || undefined;
+}
+async function telemetryProxyEndpoint(path) {
+  const feedback = await globalConfig("feedback_endpoint");
+  if (feedback && /^https?:\/\/[^/]+\/v1\/feedback\/?$/.test(feedback)) {
+    return feedback.replace(/\/v1\/feedback\/?$/, path);
+  }
+  return `${TELEMETRY_PROXY_ORIGIN}${path}`;
+}
+function usedByEndpoint() {
+  return telemetryProxyEndpoint("/v1/used-by");
+}
+async function handleUsedBy(req, res, pathSegments, queryParams, myAgentId) {
+  if (!usedBy.match(req.method, pathSegments))
+    return false;
+  const parsed = await usedBy.parse(req, res, pathSegments, queryParams);
+  if (!parsed)
+    return true;
+  if (!await ensureConfigAdmin(req, res, "config.write.any"))
+    return true;
+  const { granted } = parsed.body;
+  const current = orgIdentityStatus({
+    SWARM_ORG_NAME: await globalConfig("SWARM_ORG_NAME"),
+    SWARM_ORG_WEBSITE: await globalConfig("SWARM_ORG_WEBSITE")
+  });
+  const currentName = current.name ?? undefined;
+  const currentWebsite = current.website;
+  const grantedName = granted ? undefined : await globalConfig(GRANTED_NAME_KEY);
+  const grantedWebsite = granted ? null : normalizeOrgWebsite(await globalConfig(GRANTED_WEBSITE_KEY));
+  const [orgName, orgWebsite] = grantedName && grantedWebsite ? [grantedName, grantedWebsite] : [currentName, currentWebsite];
+  if (!orgName || !orgWebsite) {
+    jsonError(res, "Set the organization name and website first", 400);
+    return true;
+  }
+  const installId = isTelemetryEnabled() ? await globalConfig("telemetry_installation_id") : undefined;
+  const orgDomain = await globalConfig("telemetry_org_domain");
+  const changedAt = new Date().toISOString();
+  try {
+    const response = await fetch(await usedByEndpoint(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...installId ? { install_id: installId } : {},
+        org_name: orgName,
+        org_website: orgWebsite,
+        ...orgDomain ? { org_domain: orgDomain } : {},
+        granted,
+        changed_at: changedAt
+      }),
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      jsonError(res, `The telemetry proxy answered ${response.status}`, 502);
+      return true;
+    }
+  } catch {
+    jsonError(res, "Could not reach the telemetry proxy", 502);
+    return true;
+  }
+  await upsertSwarmConfig2({ scope: "global", key: CONSENT_KEY, value: String(granted) });
+  await upsertSwarmConfig2({ scope: "global", key: CONSENT_AT_KEY, value: changedAt });
+  if (granted) {
+    await upsertSwarmConfig2({ scope: "global", key: GRANTED_NAME_KEY, value: orgName });
+    await upsertSwarmConfig2({ scope: "global", key: GRANTED_WEBSITE_KEY, value: orgWebsite });
+  }
+  scheduleIntegrationsReload();
+  const owner = await resolveHttpFavoriteOwner(req, myAgentId);
+  trackRelayed("used_by.consent_changed", { granted }, { actor: owner?.userId ? { userId: owner.userId } : undefined, emitter: "ui" });
+  usedBy.respond(res, 200, { granted, changedAt });
+  return true;
+}
+
+// src/http/ranking.ts
+var ListingSchema = object2({
+  v: literal2(1),
+  claim: string2(),
+  name: string2(),
+  domain: string2(),
+  category: _enum2(RANKING_CATEGORIES),
+  subcategory: string2().nullable(),
+  description: string2().nullable(),
+  sourceCodeUrl: string2().nullable(),
+  updatedAt: string2()
+});
+var RankingStateSchema = object2({
+  eligible: boolean(),
+  missing: array2(_enum2(ORG_IDENTITY_KEYS)),
+  telemetryOn: boolean(),
+  enabled: boolean(),
+  name: string2().nullable(),
+  domain: string2().nullable(),
+  listing: ListingSchema.nullable(),
+  listingMatchesDomain: boolean(),
+  fileJson: string2().nullable(),
+  prUrl: string2().nullable(),
+  verifyUrl: string2().nullable()
+});
+var OptInResponseSchema = object2({
+  domain: string2(),
+  claim: string2(),
+  listing: ListingSchema,
+  fileJson: string2(),
+  prUrl: string2(),
+  verifyUrl: string2()
+});
+var OptOutResponseSchema = object2({
+  enabled: literal2(false),
+  leaveUrl: string2().nullable()
+});
+var getRanking = route({
+  method: "get",
+  path: "/api/ranking",
+  pattern: ["api", "ranking"],
+  summary: "Public ranking state",
+  description: "Whether this install can join the public agent-swarm.dev ranking (telemetry on, organization name and website set), whether it is opted in, and its stored listing. The listing carries the private ranking claim, so only a config admin can read it.",
+  tags: ["Telemetry"],
+  responses: {
+    200: { description: "Ranking state", schema: RankingStateSchema },
+    401: { description: "Unauthorized" },
+    403: { description: "Only a config admin can read the ranking state" }
+  },
+  rbac: { permission: "config.write.any" }
+});
+var optIn = route({
+  method: "post",
+  path: "/api/ranking/opt-in",
+  pattern: ["api", "ranking", "opt-in"],
+  summary: "Opt this install into the public ranking",
+  description: "Builds the telemetry_ranking listing from the organization name and website plus the chosen category, stores it, turns PUBLIC_RANKING_ENABLED on and sends ranking.opted_in. The install is ranked only after a ranking PR with the returned file is merged into desplega-ai/agent-swarm.",
+  tags: ["Telemetry"],
+  body: rankingFormSchema,
+  responses: {
+    200: { description: "Opted in", schema: OptInResponseSchema },
+    400: { description: "A listing field is invalid" },
+    401: { description: "Unauthorized" },
+    403: { description: "Only a config admin can opt in" },
+    409: {
+      description: "telemetry_off: telemetry is off or the install has no ID. org_identity_missing: the organization name or website is not set (`missing` lists which)."
+    }
+  },
+  rbac: { permission: "config.write.any" }
+});
+var optOut = route({
+  method: "post",
+  path: "/api/ranking/opt-out",
+  pattern: ["api", "ranking", "opt-out"],
+  summary: "Leave the public ranking",
+  description: "Turns PUBLIC_RANKING_ENABLED off and sends ranking.opted_out, so workers stop sending ranking.usage. Returns the GitHub page that deletes the ranking entry.",
+  tags: ["Telemetry"],
+  responses: {
+    200: { description: "Opted out", schema: OptOutResponseSchema },
+    401: { description: "Unauthorized" },
+    403: { description: "Only a config admin can opt out" }
+  },
+  rbac: { permission: "config.write.any" }
+});
+var RANKING_CONFIG_KEYS = new Set([...ORG_IDENTITY_KEYS, PUBLIC_RANKING_ENABLED_KEY]);
+async function currentIdentity(changed) {
+  const read = async (key) => changed?.key === key ? changed.value : await globalConfig(key);
+  return orgIdentityStatus({
+    SWARM_ORG_NAME: await read("SWARM_ORG_NAME"),
+    SWARM_ORG_WEBSITE: await read("SWARM_ORG_WEBSITE")
+  });
+}
+async function storedListing() {
+  return readTelemetryRanking(await globalConfig(TELEMETRY_RANKING_KEY));
+}
+async function rankingEnabled() {
+  const raw = await globalConfig(PUBLIC_RANKING_ENABLED_KEY);
+  return isEnvFlagEnabled(PUBLIC_RANKING_ENABLED_KEY, false, {
+    [PUBLIC_RANKING_ENABLED_KEY]: raw
+  });
+}
+async function telemetryReady() {
+  return isTelemetryEnabled() && Boolean(await globalConfig("telemetry_installation_id"));
+}
+async function verifyUrl(listing) {
+  const params = new URLSearchParams({ domain: listing.domain, claim: listing.claim });
+  return `${await telemetryProxyEndpoint("/v1/ranking/verify")}?${params.toString()}`;
+}
+async function setEnabled(enabled) {
+  await upsertSwarmConfig2({
+    scope: "global",
+    key: PUBLIC_RANKING_ENABLED_KEY,
+    value: String(enabled)
+  });
+}
+function emitOptedIn(listing) {
+  telemetry.ranking("opted_in", { listing: JSON.stringify(listing) }, { orgName: listing.name, orgWebsite: listing.domain });
+}
+function emitOptedOut(domain) {
+  telemetry.ranking("opted_out", { domain });
+}
+async function buildRankingState() {
+  const [identity, listing, enabled, telemetryOn] = await Promise.all([
+    currentIdentity(),
+    storedListing(),
+    rankingEnabled(),
+    telemetryReady()
+  ]);
+  const listingMatchesDomain = Boolean(listing && listing.domain === identity.website);
+  const current = listingMatchesDomain ? listing : null;
+  return {
+    eligible: telemetryOn && identity.ok,
+    missing: identity.missing,
+    telemetryOn,
+    enabled: enabled && listingMatchesDomain,
+    name: identity.name,
+    domain: identity.website,
+    listing,
+    listingMatchesDomain,
+    fileJson: current ? rankingEntryFile(current) : null,
+    prUrl: current ? rankingPrUrl(current) : null,
+    verifyUrl: current ? await verifyUrl(current) : null
+  };
+}
+async function syncRankingAfterConfigChange(key, value) {
+  if (!RANKING_CONFIG_KEYS.has(key))
+    return;
+  const listing = await storedListing();
+  if (!listing)
+    return;
+  if (key === PUBLIC_RANKING_ENABLED_KEY) {
+    if (!isEnvFlagEnabled(key, false, { [key]: value ?? undefined })) {
+      emitOptedOut(listing.domain);
+    }
+    return;
+  }
+  if (!await rankingEnabled())
+    return;
+  const identity = await currentIdentity({ key, value });
+  let rebuilt = null;
+  if (identity.ok && identity.website === listing.domain) {
+    if (identity.name === listing.name)
+      return;
+    try {
+      rebuilt = buildListing(identity, listing, listing.claim);
+    } catch {}
+  }
+  if (!rebuilt) {
+    await setEnabled(false);
+    emitOptedOut(listing.domain);
+    return;
+  }
+  await upsertSwarmConfig2({
+    scope: "global",
+    key: TELEMETRY_RANKING_KEY,
+    value: JSON.stringify(rebuilt)
+  });
+  emitOptedIn(rebuilt);
+}
+function conflict(res, body) {
+  res.writeHead(409, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+async function handleRanking(req, res, pathSegments, queryParams) {
+  if (getRanking.match(req.method, pathSegments)) {
+    const parsed = await getRanking.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await ensureConfigAdmin(req, res, "config.write.any"))
+      return true;
+    getRanking.respond(res, 200, await buildRankingState());
+    return true;
+  }
+  if (optIn.match(req.method, pathSegments)) {
+    const parsed = await optIn.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await ensureConfigAdmin(req, res, "config.write.any"))
+      return true;
+    if (!await telemetryReady()) {
+      conflict(res, {
+        error: "telemetry_off",
+        message: "Turn telemetry on first: the ranking counts tokens from telemetry."
+      });
+      return true;
+    }
+    const identity = await currentIdentity();
+    if (!identity.ok || !identity.website) {
+      conflict(res, {
+        error: "org_identity_missing",
+        message: "Set the organization name and website first",
+        missing: identity.missing
+      });
+      return true;
+    }
+    const website = identity.website;
+    const db = getDbClient2();
+    const built = await db.transaction(async () => {
+      const stored = await storedListing();
+      const claim = stored?.domain === website ? stored.claim : mintRankingClaim();
+      let listing;
+      try {
+        listing = buildListing(identity, parsed.body, claim);
+      } catch (error) {
+        return { ok: false, error };
+      }
+      await upsertSwarmConfig2({
+        scope: "global",
+        key: TELEMETRY_RANKING_KEY,
+        value: JSON.stringify(listing)
+      });
+      await setEnabled(true);
+      db.afterCommit(() => emitOptedIn(listing));
+      return { ok: true, listing };
+    });
+    if (!built.ok) {
+      const issue = built.error instanceof ZodError ? built.error.issues[0] : undefined;
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        error: issue ? `Invalid ${issue.path.join(".") || "listing"}: ${issue.message}` : "Invalid listing"
+      }));
+      return true;
+    }
+    const { listing } = built;
+    scheduleIntegrationsReload();
+    optIn.respond(res, 200, {
+      domain: listing.domain,
+      claim: listing.claim,
+      listing,
+      fileJson: rankingEntryFile(listing),
+      prUrl: rankingPrUrl(listing),
+      verifyUrl: await verifyUrl(listing)
+    });
+    return true;
+  }
+  if (optOut.match(req.method, pathSegments)) {
+    const parsed = await optOut.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    if (!await ensureConfigAdmin(req, res, "config.write.any"))
+      return true;
+    const listing = await storedListing();
+    await setEnabled(false);
+    if (listing)
+      emitOptedOut(listing.domain);
+    scheduleIntegrationsReload();
+    optOut.respond(res, 200, {
+      enabled: false,
+      leaveUrl: listing ? rankingLeaveUrl(listing.domain) : null
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/http/config.ts
 var MAX_ENV_PRESENCE_KEYS = 200;
 var SECRETS_FORCE_MASK_NOTE = " (secret values masked: this token cannot read secrets in this scope)";
 function stripApiOnlyKeys(configs) {
@@ -7944,6 +8454,8 @@ async function handleConfig(req, res, pathSegments, queryParams) {
       if (scope === "global" && key === "SWARM_ORG_WEBSITE") {
         await fillOrgLogoFromWebsite(String(value));
       }
+      if (scope === "global")
+        await syncRankingAfterConfigChange(key, String(value));
       if (scope === "global") {
         scheduleIntegrationsReload();
       }
@@ -7979,6 +8491,7 @@ async function handleConfig(req, res, pathSegments, queryParams) {
       return true;
     }
     if (existing.scope === "global") {
+      await syncRankingAfterConfigChange(existing.key, null);
       scheduleIntegrationsReload();
     }
     if (existing.scope === "agent" && existing.scopeId && existing.key === AGENT_MAX_TASKS_CONFIG_KEY) {
@@ -8815,6 +9328,7 @@ var 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: object2({ id: string2() }),
@@ -8841,6 +9355,7 @@ var 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: object2({ id: string2() }),
@@ -8921,6 +9436,7 @@ var createEventRoute = route({
   method: "post",
   path: "/api/events",
   pattern: ["api", "events"],
+  session: bodyTask("taskId"),
   summary: "Store a single event",
   tags: ["Events"],
   body: eventBodySchema,
@@ -8937,6 +9453,7 @@ var 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: object2({
@@ -9011,7 +9528,7 @@ var getEventCountsRoute = route({
   auth: { apiKey: true }
 });
 var MAX_LATEST_PAIRS = 50;
-async function handleEvents(req, res, pathSegments, queryParams, _myAgentId) {
+async function handleEvents(req, res, pathSegments, queryParams, myAgentId) {
   if (createEventsBatchRoute.match(req.method, pathSegments)) {
     const parsed = await createEventsBatchRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
@@ -9085,7 +9602,8 @@ async function handleEvents(req, res, pathSegments, queryParams, _myAgentId) {
       until: parsed.query.until || undefined,
       limit: parsed.query.limit ?? 100,
       events: eventFilter,
-      latestPerDataField: latestPerDataField ? { events: latestEvents, dataFields } : undefined
+      latestPerDataField: latestPerDataField ? { events: latestEvents, dataFields } : undefined,
+      readableBy: readableByFor2(await resolveSessionActor2(req, myAgentId))
     });
     getEventsRoute.respond(res, 200, latestPerDataField ? { events, latestPerDataField: true } : { events });
     return true;
@@ -12509,110 +13027,6 @@ async function getLocalFleetStats(now = new Date) {
 
 // src/http/fleet-benchmark.ts
 init_telemetry();
-
-// src/http/used-by.ts
-init_zod();
-init_db3();
-init_telemetry();
-init_org_website();
-var CONSENT_KEY = "SWARM_USED_BY_CONSENT";
-var CONSENT_AT_KEY = "SWARM_USED_BY_CONSENT_AT";
-var GRANTED_NAME_KEY = "SWARM_USED_BY_ORG_NAME";
-var GRANTED_WEBSITE_KEY = "SWARM_USED_BY_ORG_WEBSITE";
-var TIMEOUT_MS = 1e4;
-var usedBy = route({
-  method: "post",
-  path: "/api/used-by",
-  pattern: ["api", "used-by"],
-  summary: "Grant or revoke the 'used by' logo consent",
-  description: "Records whether agent-swarm.dev may show this organization's logo as a company that uses Agent Swarm. Sends the organization name and website to the telemetry proxy, where a person approves each logo by hand. An explicit admin action, so it is not gated by the telemetry opt-out.",
-  tags: ["Telemetry"],
-  body: object2({ granted: boolean() }),
-  responses: {
-    200: {
-      description: "Consent recorded",
-      schema: object2({ granted: boolean(), changedAt: string2() })
-    },
-    400: {
-      description: "Organization name or website is not set (a revoke falls back to the identity of the last grant)"
-    },
-    401: { description: "Unauthorized" },
-    403: { description: "Only a config admin can change the consent" },
-    502: { description: "The telemetry proxy did not accept the consent" }
-  },
-  rbac: { permission: "config.write.any" }
-});
-async function globalConfig(key) {
-  const stored = (await getSwarmConfigs2({ scope: "global", key }))?.[0]?.value?.trim();
-  return stored || process.env[key]?.trim() || undefined;
-}
-async function telemetryProxyEndpoint(path) {
-  const feedback = await globalConfig("feedback_endpoint");
-  if (feedback && /^https?:\/\/[^/]+\/v1\/feedback\/?$/.test(feedback)) {
-    return feedback.replace(/\/v1\/feedback\/?$/, path);
-  }
-  return `${TELEMETRY_PROXY_ORIGIN}${path}`;
-}
-function usedByEndpoint() {
-  return telemetryProxyEndpoint("/v1/used-by");
-}
-async function handleUsedBy(req, res, pathSegments, queryParams, myAgentId) {
-  if (!usedBy.match(req.method, pathSegments))
-    return false;
-  const parsed = await usedBy.parse(req, res, pathSegments, queryParams);
-  if (!parsed)
-    return true;
-  if (!await ensureConfigAdmin(req, res, "config.write.any"))
-    return true;
-  const { granted } = parsed.body;
-  const currentName = await globalConfig("SWARM_ORG_NAME");
-  const currentWebsite = normalizeOrgWebsite(await globalConfig("SWARM_ORG_WEBSITE"));
-  const grantedName = granted ? undefined : await globalConfig(GRANTED_NAME_KEY);
-  const grantedWebsite = granted ? null : normalizeOrgWebsite(await globalConfig(GRANTED_WEBSITE_KEY));
-  const [orgName, orgWebsite] = grantedName && grantedWebsite ? [grantedName, grantedWebsite] : [currentName, currentWebsite];
-  if (!orgName || !orgWebsite) {
-    jsonError(res, "Set the organization name and website first", 400);
-    return true;
-  }
-  const installId = isTelemetryEnabled() ? await globalConfig("telemetry_installation_id") : undefined;
-  const orgDomain = await globalConfig("telemetry_org_domain");
-  const changedAt = new Date().toISOString();
-  try {
-    const response = await fetch(await usedByEndpoint(), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        ...installId ? { install_id: installId } : {},
-        org_name: orgName,
-        org_website: orgWebsite,
-        ...orgDomain ? { org_domain: orgDomain } : {},
-        granted,
-        changed_at: changedAt
-      }),
-      signal: AbortSignal.timeout(TIMEOUT_MS)
-    });
-    if (!response.ok) {
-      jsonError(res, `The telemetry proxy answered ${response.status}`, 502);
-      return true;
-    }
-  } catch {
-    jsonError(res, "Could not reach the telemetry proxy", 502);
-    return true;
-  }
-  await upsertSwarmConfig2({ scope: "global", key: CONSENT_KEY, value: String(granted) });
-  await upsertSwarmConfig2({ scope: "global", key: CONSENT_AT_KEY, value: changedAt });
-  if (granted) {
-    await upsertSwarmConfig2({ scope: "global", key: GRANTED_NAME_KEY, value: orgName });
-    await upsertSwarmConfig2({ scope: "global", key: GRANTED_WEBSITE_KEY, value: orgWebsite });
-  }
-  scheduleIntegrationsReload();
-  const owner = await resolveHttpFavoriteOwner(req, myAgentId);
-  trackRelayed("used_by.consent_changed", { granted }, { actor: owner?.userId ? { userId: owner.userId } : undefined, emitter: "ui" });
-  usedBy.respond(res, 200, { granted, changedAt });
-  return true;
-}
-
-// src/http/fleet-benchmark.ts
 var FLEET_TTL_MS = 24 * 60 * 60 * 1000;
 var FLEET_FAILURE_TTL_MS = 60 * 60 * 1000;
 var LOCAL_TTL_MS = 10 * 60 * 1000;
@@ -12871,6 +13285,7 @@ var 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,
@@ -12886,6 +13301,7 @@ var 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.",
   tags: ["FS"],
@@ -12905,6 +13321,7 @@ var 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,
@@ -12917,6 +13334,7 @@ var 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"],
@@ -12933,6 +13351,7 @@ var 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,
@@ -12947,6 +13366,7 @@ var 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,
@@ -12995,7 +13415,7 @@ async function handleFs(req, res, pathSegments, queryParams, myAgentId) {
     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);
@@ -13004,7 +13424,7 @@ async function handleFs(req, res, pathSegments, queryParams, myAgentId) {
     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);
@@ -13013,7 +13433,7 @@ async function handleFs(req, res, pathSegments, queryParams, myAgentId) {
     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);
@@ -13052,6 +13472,10 @@ async function handleFs(req, res, pathSegments, queryParams, myAgentId) {
       return true;
     if (!await getTaskById2(parsed.params.taskId))
       return notFound(res, "Task not found");
+    if (!await canReadSession2(req, myAgentId, parsed.params.taskId)) {
+      jsonError(res, SESSION_READ_DENIED2, 403);
+      return true;
+    }
     listTaskFilesRoute.respond(res, 200, {
       attachments: await getTaskAttachments2(parsed.params.taskId)
     });
@@ -13187,11 +13611,15 @@ function backingProviderId(attachment) {
     return "local-fs";
   return null;
 }
-async function findAttachment(taskId, attachmentId, res) {
+async function findAttachment(req, myAgentId, taskId, attachmentId, res) {
   if (!await getTaskById2(taskId)) {
     notFound(res, "Task not found");
     return null;
   }
+  if (!await canReadSession2(req, myAgentId, taskId)) {
+    jsonError(res, SESSION_READ_DENIED2, 403);
+    return null;
+  }
   const attachment = (await getTaskAttachments2(taskId)).find((item) => item.id === attachmentId);
   if (!attachment) {
     notFound(res, "Attachment not found");
@@ -13333,20 +13761,21 @@ var listState = route({
   },
   auth: { apiKey: true }
 });
+var inboxStateItemSchema = object2({
+  itemType: InboxItemTypeSchema,
+  itemId: string2().min(1),
+  status: InboxItemStatusSchema,
+  snoozeUntil: string2().datetime().optional(),
+  readAt: string2().datetime().optional(),
+  lastReadAt: string2().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.")
+});
 var 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: object2({
-    userId: string2(),
-    itemType: InboxItemTypeSchema,
-    itemId: string2().min(1),
-    status: InboxItemStatusSchema,
-    snoozeUntil: string2().datetime().optional(),
-    readAt: string2().datetime().optional()
-  }),
+  body: inboxStateItemSchema.extend({ userId: string2() }),
   responses: {
     200: {
       description: "Upserted inbox state row",
@@ -13357,6 +13786,27 @@ var upsertState = route({
   },
   auth: { apiKey: true }
 });
+var 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: object2({
+    userId: string2(),
+    items: array2(inboxStateItemSchema).min(1).max(200)
+  }),
+  responses: {
+    200: {
+      description: "Upserted inbox state rows in request order",
+      schema: object2({ items: array2(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" }
+});
 async function handleInboxState(req, res, pathSegments, queryParams) {
   if (listState.match(req.method, pathSegments)) {
     const parsed = await listState.parse(req, res, pathSegments, queryParams);
@@ -13370,6 +13820,24 @@ async function handleInboxState(req, res, pathSegments, queryParams) {
     listState.respond(res, 200, { items });
     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 getDbClient2().transaction(async () => {
+        const rows = [];
+        for (const item of parsed.body.items) {
+          rows.push(await upsertInboxState2({ ...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)
@@ -13381,7 +13849,8 @@ async function handleInboxState(req, res, pathSegments, queryParams) {
         itemId: parsed.body.itemId,
         status: parsed.body.status,
         snoozeUntil: parsed.body.snoozeUntil,
-        readAt: parsed.body.readAt
+        readAt: parsed.body.readAt,
+        lastReadAt: parsed.body.lastReadAt
       });
       upsertState.respond(res, 200, { item });
     } catch (err) {
@@ -17790,6 +18259,7 @@ var 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"],
   rbac: { permission: "memory.write.consolidated" },
@@ -18267,6 +18737,7 @@ var 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 },
@@ -21714,7 +22185,7 @@ var listTasks = route({
   path: "/api/tasks",
   pattern: ["api", "tasks"],
   summary: "List tasks with filters",
-  description: "Returns tasks with the full `task` text replaced by a bounded `taskPreview` and completion/integration blobs dropped by default — list views only need the preview. Pass `fields=full` to restore the full `AgentTask`, or `fields=timeline` for the narrow shape the dashboard timeline draws. Fetch a single task in full via `GET /api/tasks/{id}`. `total` (the filtered row count, ignoring limit/offset) is computed only with `includeTotal=true`.",
+  description: "Returns tasks with the full `task` text replaced by a bounded `taskPreview` and completion/integration blobs dropped by default — list views only need the preview. Pass `fields=full` to restore the full `AgentTask`, or `fields=timeline` for the narrow shape the dashboard timeline draws. Every shape gives a user caller only tasks of sessions they can read. Fetch a single task in full via `GET /api/tasks/{id}`. `total` (the filtered row count, ignoring limit/offset) is computed only with `includeTotal=true`.",
   tags: ["Tasks"],
   query: object2({
     status: string2().optional(),
@@ -21753,6 +22224,7 @@ var createTask = route({
   method: "post",
   path: "/api/tasks",
   pattern: ["api", "tasks"],
+  session: bodyTask("parentTaskId"),
   summary: "Create a new task",
   tags: ["Tasks"],
   body: object2({
@@ -21808,6 +22280,7 @@ var promoteDraftTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/promote-draft",
   pattern: ["api", "tasks", null, "promote-draft"],
+  session: { taskParam: "id" },
   summary: "Promote a draft task out of the pre-dispatch draft state",
   description: "Transitions a `draft` task (#1240 — created with attachments still uploading) to its normal dispatch-eligible status: `offered` if it was offered to an agent, `pending` if it has an owning agent (the common case — UI-composer tasks default to Lead), otherwise `unassigned`. Called by the UI composer once its attachment upload batch settles, whether every file uploaded, some failed, or all failed — a draft must never be stranded by an upload error. Idempotent: calling it on a task that already left `draft` returns the current task unchanged rather than erroring, so a retried request is safe.",
   tags: ["Tasks"],
@@ -21823,6 +22296,7 @@ var updateSession = route({
   method: "put",
   path: "/api/tasks/{id}/session",
   pattern: ["api", "tasks", null, "session"],
+  session: { taskParam: "id" },
   summary: "Update provider session ID and harness metadata for a task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21856,6 +22330,7 @@ var cancelTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/cancel",
   pattern: ["api", "tasks", null, "cancel"],
+  session: { taskParam: "id" },
   summary: "Cancel a pending or in-progress task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21870,6 +22345,7 @@ var steerTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/steer",
   pattern: ["api", "tasks", null, "steer"],
+  session: { taskParam: "id" },
   summary: "Deliver a steering message to a running task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21898,6 +22374,7 @@ var getTaskSteeringMessagesRoute = route({
   method: "get",
   path: "/api/tasks/{id}/steering-messages",
   pattern: ["api", "tasks", null, "steering-messages"],
+  session: { taskParam: "id" },
   summary: "List steering messages for a task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21924,6 +22401,7 @@ var markSteeringDeliveredRoute = route({
   method: "post",
   path: "/api/steering-messages/{id}/delivered",
   pattern: ["api", "steering-messages", null, "delivered"],
+  session: { steeringParam: "id" },
   summary: "Mark a steering message delivered",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21947,6 +22425,7 @@ var markSteeringHandledRoute = route({
   method: "post",
   path: "/api/steering-messages/{id}/handled",
   pattern: ["api", "steering-messages", null, "handled"],
+  session: { steeringParam: "id" },
   summary: "Mark a steering message handled",
   description: "Optionally accepts a JSON body `{ note?: string }` — a short acceptance note describing how the steering was incorporated, persisted as `handledNote`.",
   tags: ["Tasks"],
@@ -21969,6 +22448,7 @@ var markSteeringUndeliverableRoute = route({
   method: "post",
   path: "/api/steering-messages/{id}/undeliverable",
   pattern: ["api", "steering-messages", null, "undeliverable"],
+  session: { steeringParam: "id" },
   summary: "Promote an undeliverable steering message",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -21992,6 +22472,7 @@ var getTask = route({
   method: "get",
   path: "/api/tasks/{id}",
   pattern: ["api", "tasks", null],
+  session: { taskParam: "id" },
   summary: "Get task details with logs and attachments",
   description: "Returns the full `AgentTask` row decorated with `logs` (capped by `logsLimit`) and `attachments` (pointer-based artifacts stored on the task, ordered by `created_at`).",
   tags: ["Tasks"],
@@ -22001,6 +22482,7 @@ var getTask = route({
   }),
   responses: {
     200: { description: "Task with logs and attachments", schema: GetTaskResponseSchema },
+    403: { description: "A user caller cannot read the task's session" },
     404: { description: "Task not found" }
   }
 });
@@ -22008,6 +22490,7 @@ var updateTaskProgressRoute = route({
   method: "post",
   path: "/api/tasks/{id}/progress",
   pattern: ["api", "tasks", null, "progress"],
+  session: { taskParam: "id" },
   summary: "Update task progress text",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -22025,6 +22508,7 @@ var finishTask = route({
   method: "post",
   path: "/api/tasks/{id}/finish",
   pattern: ["api", "tasks", null, "finish"],
+  session: { taskParam: "id" },
   summary: "Mark task as completed or failed (runner endpoint)",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -22070,6 +22554,7 @@ var pauseTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/pause",
   pattern: ["api", "tasks", null, "pause"],
+  session: { taskParam: "id" },
   summary: "Pause an in-progress task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -22084,6 +22569,7 @@ var resumeTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/resume",
   pattern: ["api", "tasks", null, "resume"],
+  session: { taskParam: "id" },
   summary: "Resume a paused task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -22098,6 +22584,7 @@ var supersedeTaskRoute = route({
   method: "post",
   path: "/api/tasks/{id}/supersede",
   pattern: ["api", "tasks", null, "supersede"],
+  session: { taskParam: "id" },
   summary: "Supersede an in-progress task (terminate + spawn resume follow-up)",
   description: 'Marks the original task `superseded` (terminal) and creates a fresh `taskType="resume"` follow-up so a worker can pick up the work in a new provider session. Workflow-step tasks (those with `workflowRunStepId`) are carved out: the original is marked `failed` with reason `superseded_workflow_task` and no follow-up is created — the workflow engine\'s retry/failure policy applies.',
   tags: ["Tasks"],
@@ -22118,6 +22605,7 @@ var updateTaskVcsRoute = route({
   method: "patch",
   path: "/api/tasks/{id}/vcs",
   pattern: ["api", "tasks", null, "vcs"],
+  session: { taskParam: "id" },
   summary: "Update VCS (PR/MR) info for a task",
   tags: ["Tasks"],
   params: object2({ id: string2() }),
@@ -22138,6 +22626,7 @@ var updateTaskTitleRoute = route({
   method: "patch",
   path: "/api/tasks/{id}/title",
   pattern: ["api", "tasks", null, "title"],
+  session: { taskParam: "id" },
   summary: "Set or clear a task's display title (session rename)",
   description: "Sets a human-facing display title override on a task. The sessions UI only reads this from root tasks (session list items), but titles on child tasks are harmless. Pass `title: null` (or an empty string) to clear the override and fall back to the task prompt.",
   tags: ["Tasks"],
@@ -22154,17 +22643,21 @@ var updateTaskTitleRoute = route({
     ungated: "mirrors the pre-RBAC PATCH /api/tasks/{id}/vcs sibling route: bearer auth only"
   }
 });
-async function canSteerTask(req, myAgentId, task) {
+async function hasSessionWrite(req, myAgentId, taskId) {
+  const access = await sessionAccessFor2(await resolveSessionActor2(req, myAgentId), taskId);
+  return hasSessionAccess(access, "write");
+}
+async function canSteerTask(req, myAgentId, task, sessionAccess = "none") {
+  const auth = getRequestAuth(req);
   const resource = {
     kind: "task",
     taskId: task.id,
-    requestedByUserId: task.requestedByUserId,
+    requestedByUserId: auth?.kind === "user" && sessionAccess === "write" ? auth.userId : task.requestedByUserId,
     creatorAgentId: task.creatorAgentId,
     agentId: task.agentId
   };
   let principal;
   let verb;
-  const auth = getRequestAuth(req);
   if (auth?.kind === "operator") {
     principal = { kind: "operator" };
     verb = "task.steer.own";
@@ -22273,6 +22766,7 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       if (validated.length > 0)
         source = validated;
     }
+    const actor = await resolveSessionActor2(req, myAgentId);
     const filters = {
       status,
       agentId: parsed.query.agentId || undefined,
@@ -22288,7 +22782,8 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       requestedByUserIdIsNull: parsed.query.requestedByUserId === "none" || undefined,
       orderBy: parsed.query.orderBy,
       limit: parsed.query.limit,
-      offset: parsed.query.offset
+      offset: parsed.query.offset,
+      readableBy: actor.kind === "user" ? { userId: actor.userId } : undefined
     };
     const tasks = parsed.query.fields === "full" ? await getAllTasks2(filters) : parsed.query.fields === "timeline" ? await getAllTasks2(filters, { fields: "timeline" }) : await getAllTasks2(filters, { slim: true });
     if (parsed.query.includeTotal === "true") {
@@ -22346,6 +22841,10 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, `You don't have context for parent task ${parentTask.id}.`, 403);
       return true;
     }
+    if (parentTask && !await hasSessionWrite(req, myAgentId, parentTask.id)) {
+      jsonError(res, SESSION_WRITE_DENIED2, 403);
+      return true;
+    }
     if (principal.kind === "agent" && parsed.body.contextKey && parsed.body.contextKey !== parentTask?.contextKey && chatThreadOfContextKey(parsed.body.contextKey) && !can({ principal, verb: "integration.chat.post", resource: { kind: "none" }, source: "http" }).allow) {
       jsonError(res, "Permission denied: only a lead can bind a task to a chat thread.", 403);
       return true;
@@ -22545,7 +23044,13 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, "Task not found", 404);
       return true;
     }
-    if (!await canSteerTask(req, myAgentId, task)) {
+    const sessionActor = await resolveSessionActor2(req, myAgentId);
+    const steerAccess = await sessionAccessFor2(sessionActor, task.id);
+    if (!hasSessionAccess(steerAccess, "write")) {
+      jsonError(res, SESSION_WRITE_DENIED2, 403);
+      return true;
+    }
+    if (!await canSteerTask(req, myAgentId, task, steerAccess)) {
       jsonError(res, "Forbidden: caller cannot steer this task", 403);
       return true;
     }
@@ -22585,6 +23090,10 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, "Task not found", 404);
       return true;
     }
+    if (!await canReadSession2(req, myAgentId, parsed.params.id)) {
+      jsonError(res, SESSION_READ_DENIED2, 403);
+      return true;
+    }
     getTaskSteeringMessagesRoute.respond(res, 200, {
       messages: await getSteeringMessagesForTask2(parsed.params.id)
     });
@@ -22603,13 +23112,18 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       return true;
     }
     if (parsed.query.taskId) {
+      if (!await canReadSession2(req, myAgentId, parsed.query.taskId)) {
+        jsonError(res, SESSION_READ_DENIED2, 403);
+        return true;
+      }
       const task = await getTaskById2(parsed.query.taskId);
       const messages = task?.agentId === myAgentId ? await getPendingSteeringForTask2(parsed.query.taskId) : [];
       getPendingSteeringMessagesRoute.respond(res, 200, { messages });
       return true;
     }
+    const actor = await resolveSessionActor2(req, myAgentId);
     getPendingSteeringMessagesRoute.respond(res, 200, {
-      messages: await getPendingSteeringForAgent2(myAgentId)
+      messages: await getPendingSteeringForAgent2(myAgentId, readableByFor2(actor))
     });
     return true;
   }
@@ -22750,6 +23264,11 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, "Task not found", 404);
       return true;
     }
+    const readAccess = await sessionAccessFor2(await resolveSessionActor2(req, myAgentId), task.id);
+    if (!hasSessionAccess(readAccess, "read")) {
+      jsonError(res, "You don't have access to this session. Ask the owner to share it.", 403);
+      return true;
+    }
     const logs = await getLogsByTaskId2(parsed.params.id, parsed.query.logsLimit ?? 200);
     const attachments = await getTaskAttachments2(parsed.params.id);
     getTask.respond(res, 200, {
@@ -22901,7 +23420,7 @@ async function handleTasks(req, res, pathSegments, queryParams, myAgentId) {
       jsonError(res, "Missing X-Agent-ID header", 400);
       return true;
     }
-    const pausedTasks = await getPausedTasksForAgent2(myAgentId);
+    const pausedTasks = await getPausedTasksForAgent2(myAgentId, readableByFor2(await resolveSessionActor2(req, myAgentId)));
     const tasks = await Promise.all(pausedTasks.map(async (task) => {
       const requestedBy = await buildTaskRequestedBy(task);
       return {
@@ -26764,6 +27283,7 @@ ${templateBody}` : templateBody;
 
 // src/http/realtime.ts
 init_zod();
+init_users();
 init_rbac();
 
 // src/realtime/browser.generated.txt
@@ -26777,14 +27297,14 @@ var realtimeTicketRoute = route({
   pattern: ["api", "realtime", "ticket"],
   summary: "Issue a one-shot dashboard realtime ticket",
   tags: ["Rooms"],
-  rbac: { permission: "comb.presence" },
+  description: "The ticket authorizes one dashboard socket for presence rooms: Comb drives (`comb.presence`) and sessions (`session.presence`). An operator-key tab's picked user (`X-Swarm-User-Id`) rides on the ticket so session presence can check that user's access.",
+  rbac: { permission: "session.presence", alsoAdmits: ["comb.presence"] },
   responses: {
     200: {
       description: "One-shot realtime ticket",
       schema: object2({ ticket: string2(), expiresAt: number2().int() })
     },
-    403: { description: "Comb presence is not allowed" },
-    404: { description: "Comb is not enabled" }
+    403: { description: "Presence is not allowed" }
   }
 });
 route({
@@ -26801,29 +27321,28 @@ route({
 async function handleRealtimeTicket(req, res, pathSegments, queryParams) {
   if (!realtimeTicketRoute.match(req.method, pathSegments))
     return false;
-  if (!getCombConfig().enabled) {
-    jsonError(res, "Comb is not enabled", 404);
-    return true;
-  }
   const parsed = await realtimeTicketRoute.parse(req, res, pathSegments, queryParams);
   if (!parsed)
     return true;
   const auth = getRequestAuth(req);
   if (!auth || auth.kind === "agent" || auth.kind === "guest" || auth.kind === "controller") {
-    jsonError(res, "Comb presence requires dashboard authentication", 403);
+    jsonError(res, "Presence requires dashboard authentication", 403);
     return true;
   }
   const principal = auth.kind === "operator" ? { kind: "operator" } : { kind: "user", userId: auth.userId };
-  if (!can({
-    principal,
-    verb: "comb.presence",
-    resource: { kind: "none" },
-    source: "http"
-  }).allow) {
-    jsonError(res, "Comb presence requires the comb.presence permission", 403);
+  const allowed = (verb) => can({ principal, verb, resource: { kind: "none" }, source: "http" }).allow;
+  if (!allowed("comb.presence") && !allowed("session.presence")) {
+    jsonError(res, "Presence requires the comb.presence or session.presence permission", 403);
     return true;
   }
-  realtimeTicketRoute.respond(res, 200, issueRealtimeTicket(auth));
+  let dashboardUserId;
+  if (auth.kind === "operator" && !auth.page) {
+    const picked = dashboardUserIdHeader(req);
+    const user = picked ? await findUserById(picked) : null;
+    if (user?.status === "active")
+      dashboardUserId = user.id;
+  }
+  realtimeTicketRoute.respond(res, 200, issueRealtimeTicket(dashboardUserId ? { ...auth, dashboardUserId } : auth));
   return true;
 }
 async function handleRealtimeAsset(req, res) {
@@ -30712,6 +31231,7 @@ var agentTaskRoute = route({
   method: "post",
   path: "/api/internal/script-runs/{runId}/agent-task",
   pattern: ["api", "internal", "script-runs", null, "agent-task"],
+  session: bodyTask("parentTaskId"),
   operationId: "script_runs_internal_agent_task",
   summary: "Create or wait for a script workflow agent task step",
   tags: ["Script Runs"],
@@ -31191,6 +31711,9 @@ var upsertRoute2 = route({
   method: "post",
   path: "/api/scripts/upsert",
   pattern: ["api", "scripts", "upsert"],
+  auth: {
+    userNamesAgent: "dashboard script playground: a user runs or saves a script in a chosen agent's scope"
+  },
   operationId: "scripts_upsert",
   summary: "Create or update a reusable script",
   description: "Explicit script upserts run a TypeScript typecheck before writing.",
@@ -31215,6 +31738,9 @@ var runRoute = route({
   method: "post",
   path: "/api/scripts/run",
   pattern: ["api", "scripts", "run"],
+  auth: {
+    userNamesAgent: "dashboard script playground: a user runs or saves a script in a chosen agent's scope"
+  },
   operationId: "scripts_run",
   summary: "Run a reusable or inline script",
   description: "Inline source skips typecheck and is auto-saved as a scratch script only on success.",
@@ -32185,6 +32711,7 @@ var createSessionLogsRoute = route({
   method: "post",
   path: "/api/session-logs",
   pattern: ["api", "session-logs"],
+  session: bodyTask("taskId"),
   summary: "Store session logs",
   tags: ["Session Data"],
   body: object2({
@@ -32206,6 +32733,7 @@ var getSessionLogsByTask = route({
   method: "get",
   path: "/api/tasks/{taskId}/session-logs",
   pattern: ["api", "tasks", null, "session-logs"],
+  session: { taskParam: "taskId" },
   summary: "Get session logs for a task",
   tags: ["Session Data"],
   params: object2({ taskId: string2() }),
@@ -32224,6 +32752,7 @@ var createSessionCostRoute = route({
   method: "post",
   path: "/api/session-costs",
   pattern: ["api", "session-costs"],
+  session: bodyTask("taskId"),
   summary: "Store session cost record",
   tags: ["Session Data"],
   body: object2({
@@ -32322,7 +32851,7 @@ var listSessionCosts = route({
     }
   }
 });
-async function handleSessionData(req, res, pathSegments, queryParams, _myAgentId) {
+async function handleSessionData(req, res, pathSegments, queryParams, myAgentId) {
   if (createSessionLogsRoute.match(req.method, pathSegments)) {
     const parsed = await createSessionLogsRoute.parse(req, res, pathSegments, queryParams);
     if (!parsed)
@@ -32361,6 +32890,10 @@ async function handleSessionData(req, res, pathSegments, queryParams, _myAgentId
       jsonError(res, "Task not found", 404);
       return true;
     }
+    if (!await canReadSession2(req, myAgentId, task.id)) {
+      jsonError(res, SESSION_READ_DENIED2, 403);
+      return true;
+    }
     const logs = await getSessionLogsByTaskId2(parsed.params.taskId, parsed.query?.limit);
     getSessionLogsByTask.respond(res, 200, { logs });
     return true;
@@ -32507,6 +33040,8 @@ init_zod();
 init_db3();
 init_steering();
 init_users();
+init_rbac();
+init_bus();
 init_types();
 init_request_auth_context();
 init_runtime_pools_flag();
@@ -32555,6 +33090,9 @@ var mintSessionTokenRoute = route({
   method: "post",
   path: "/api/sessions/tokens",
   pattern: ["api", "sessions", "tokens"],
+  session: {
+    none: "user tokens cannot mint: the handler admits only the operator key or the task's own runtime"
+  },
   summary: "Mint an ephemeral task or runtime token",
   description: "Operators can mint task or runtime tokens. Runtime tokens can mint task tokens for their own assigned tasks. Child tokens expire with their parent runtime.",
   tags: ["Sessions"],
@@ -32617,7 +33155,8 @@ var listSessions = route({
     q: string2().optional(),
     requestedByUserId: string2().min(1).optional(),
     contextKeyPrefix: string2().min(1).optional(),
-    fields: _enum2(["full", "slim"]).optional()
+    fields: _enum2(["full", "slim"]).optional(),
+    scope: _enum2(["mine", "shared"]).optional()
   }),
   responses: {
     200: {
@@ -32637,23 +33176,68 @@ var getSession = route({
   method: "get",
   path: "/api/sessions/{rootTaskId}",
   pattern: ["api", "sessions", null],
+  session: { taskParam: "rootTaskId" },
   summary: "Get a session — root task + the entire descendant chain",
   tags: ["Sessions"],
   params: object2({ rootTaskId: string2() }),
   responses: {
     200: {
-      description: "Root task + chain (ordered by createdAt)",
+      description: "Root task + chain (ordered by createdAt), plus the caller's `access` and the session `owner`",
       schema: object2({
         root: TaskWithSteeringSchema,
-        chain: array2(TaskWithSteeringSchema)
+        chain: array2(TaskWithSteeringSchema),
+        access: SessionAccessSchema,
+        owner: SessionOwnerSchema.nullable()
       })
     },
     401: { description: "Unauthorized" },
+    403: { description: "The caller has no access to this session" },
+    404: { description: "Root task not found" }
+  },
+  auth: { apiKey: true }
+});
+var getSessionShares = route({
+  method: "get",
+  path: "/api/sessions/{rootTaskId}/shares",
+  pattern: ["api", "sessions", null, "shares"],
+  session: { taskParam: "rootTaskId" },
+  summary: "List a session's active shares",
+  description: "Active shares only. `everyone` is the access every user has; `users` are per-person shares. A session with no shares is private to its owner.",
+  tags: ["Sessions"],
+  params: object2({ rootTaskId: string2() }),
+  responses: {
+    200: { description: "Active shares", schema: SessionSharesSchema },
+    401: { description: "Unauthorized" },
+    403: { description: "The caller has no access to this session" },
     404: { description: "Root task not found" }
   },
   auth: { apiKey: true }
 });
-async function handleSessions(req, res, pathSegments, queryParams) {
+var putSessionShares = route({
+  method: "put",
+  path: "/api/sessions/{rootTaskId}/shares",
+  pattern: ["api", "sessions", null, "shares"],
+  session: { taskParam: "rootTaskId" },
+  summary: "Set who can view or edit a session",
+  description: "Owner only. The body is the full desired state: users left out lose access. Changed targets have their active share revoked and a new one inserted in one transaction; shares are never deleted.",
+  tags: ["Sessions"],
+  params: object2({ rootTaskId: string2() }),
+  body: SessionSharesUpdateSchema,
+  responses: {
+    200: { description: "Active shares after the change", schema: SessionSharesSchema },
+    400: { description: "Validation error or unknown user" },
+    401: { description: "Unauthorized" },
+    403: { description: "Only the session owner can share it" },
+    404: { description: "Root task not found" },
+    409: { description: "The session has no owner, so it is already open to everyone" }
+  },
+  auth: { apiKey: true },
+  rbac: { permission: "session.share" }
+});
+async function accessForRoot(actor, root) {
+  return actor.kind === "bypass" ? "owner" : sessionAccessForRoot(actor.userId, root);
+}
+async function handleSessions(req, res, pathSegments, queryParams, myAgentId) {
   if (mintSessionTokenRoute.match(req.method, pathSegments)) {
     const auth = getRequestAuth(req);
     if (auth?.kind !== "operator" && !(auth?.kind === "agent" && auth.runtimeId)) {
@@ -32730,21 +33314,30 @@ async function handleSessions(req, res, pathSegments, queryParams) {
     if (!parsed)
       return true;
     const sources = parsed.query.source ? parsed.query.source.split(",").map((s) => s.trim()).filter(Boolean) : undefined;
-    const baseOpts = {
-      limit: parsed.query.limit,
-      offset: parsed.query.offset,
+    const actor = await resolveSessionActor2(req, myAgentId);
+    if (actor.kind === "bypass" && parsed.query.scope) {
+      listSessions.respond(res, 200, {
+        sessions: [],
+        total: 0,
+        limit: parsed.query.limit ?? 25,
+        offset: parsed.query.offset ?? 0
+      });
+      return true;
+    }
+    const filterOpts = {
       source: sources,
       q: parsed.query.q,
       requestedByUserId: parsed.query.requestedByUserId,
-      contextKeyPrefix: parsed.query.contextKeyPrefix
+      contextKeyPrefix: parsed.query.contextKeyPrefix,
+      ...actor.kind === "user" ? { viewer: { userId: actor.userId, scope: parsed.query.scope ?? "all" } } : {}
+    };
+    const baseOpts = {
+      ...filterOpts,
+      limit: parsed.query.limit,
+      offset: parsed.query.offset
     };
     const sessions = parsed.query.fields === "full" ? await listRecentSessions2(baseOpts) : await listRecentSessions2({ ...baseOpts, slim: true });
-    const total = await countSessions2({
-      source: sources,
-      q: parsed.query.q,
-      requestedByUserId: parsed.query.requestedByUserId,
-      contextKeyPrefix: parsed.query.contextKeyPrefix
-    });
+    const total = await countSessions2(filterOpts);
     listSessions.respond(res, 200, {
       sessions,
       total,
@@ -32762,6 +33355,20 @@ async function handleSessions(req, res, pathSegments, queryParams) {
       jsonError(res, "Root task not found", 404);
       return true;
     }
+    const sessionRoot = await getSessionRoot(root.id) ?? {
+      id: root.id,
+      requestedByUserId: root.requestedByUserId ?? null
+    };
+    const access = await accessForRoot(await resolveSessionActor2(req, myAgentId), sessionRoot);
+    if (access === "none") {
+      jsonError(res, "You don't have access to this session. Ask the owner to share it.", 403);
+      return true;
+    }
+    const ownerUser = sessionRoot.requestedByUserId ? await findUserById(sessionRoot.requestedByUserId) : null;
+    const owner = sessionRoot.requestedByUserId ? {
+      id: sessionRoot.requestedByUserId,
+      name: ownerUser?.name ?? sessionRoot.requestedByUserId
+    } : null;
     const chain = await getRootTaskChain2(parsed.params.rootTaskId);
     const tasks = [root, ...chain];
     const [steering, citations] = await Promise.all([
@@ -32773,7 +33380,69 @@ async function handleSessions(req, res, pathSegments, queryParams) {
       ...steering.get(task.id),
       citations: citations.get(task.id)
     });
-    getSession.respond(res, 200, { root: decorate(root), chain: chain.map(decorate) });
+    getSession.respond(res, 200, {
+      root: decorate(root),
+      chain: chain.map(decorate),
+      access,
+      owner
+    });
+    return true;
+  }
+  if (getSessionShares.match(req.method, pathSegments)) {
+    const parsed = await getSessionShares.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const root = await getSessionRoot(parsed.params.rootTaskId);
+    if (!root) {
+      jsonError(res, "Root task not found", 404);
+      return true;
+    }
+    const access = await accessForRoot(await resolveSessionActor2(req, myAgentId), root);
+    if (access === "none") {
+      jsonError(res, "You don't have access to this session. Ask the owner to share it.", 403);
+      return true;
+    }
+    getSessionShares.respond(res, 200, toSessionSharesState(await listActiveSessionShares(root.id)));
+    return true;
+  }
+  if (putSessionShares.match(req.method, pathSegments)) {
+    const parsed = await putSessionShares.parse(req, res, pathSegments, queryParams);
+    if (!parsed)
+      return true;
+    const auth = getRequestAuth(req);
+    const actor = await resolveSessionActor2(req, myAgentId);
+    const principal = auth?.kind === "user" ? { kind: "user", userId: auth.userId } : auth?.kind === "operator" && !myAgentId ? { kind: "operator" } : null;
+    if (!principal || !can({ principal, verb: "session.share", resource: { kind: "none" }, source: "http" }).allow) {
+      jsonError(res, "Only the session owner can share it", 403);
+      return true;
+    }
+    const root = await getSessionRoot(parsed.params.rootTaskId);
+    if (!root) {
+      jsonError(res, "Root task not found", 404);
+      return true;
+    }
+    if (!root.requestedByUserId) {
+      jsonError(res, "This session has no owner, so it is already open to everyone", 409);
+      return true;
+    }
+    if (actor.kind === "user" && actor.userId !== root.requestedByUserId) {
+      jsonError(res, "Only the session owner can share it", 403);
+      return true;
+    }
+    const userIds = [...new Set(parsed.body.users.map((user) => user.userId))];
+    if (userIds.length !== parsed.body.users.length) {
+      jsonError(res, "Each user may appear only once", 400);
+      return true;
+    }
+    for (const userId of userIds) {
+      if (!await findUserById(userId)) {
+        jsonError(res, `Unknown user ${userId}`, 400);
+        return true;
+      }
+    }
+    const state = await setSessionShares(root, parsed.body, actor.kind === "user" ? actor.userId : null);
+    realtimeBus.publish(sessionAccessTopic(root.id), null);
+    putSessionShares.respond(res, 200, state);
     return true;
   }
   return false;
@@ -34175,11 +34844,12 @@ async function handleStats(req, res, pathSegments, queryParams, myAgentId) {
       return true;
     const limit = parsed.query.limit ?? 100;
     const agentId = parsed.query.agentId;
+    const readableBy = readableByFor2(await resolveSessionActor2(req, myAgentId));
     let logs = [];
     if (agentId) {
-      logs = (await getLogsByAgentId2(agentId)).slice(0, limit);
+      logs = (await getLogsByAgentId2(agentId, readableBy)).slice(0, limit);
     } else {
-      logs = await getAllLogs2(limit);
+      logs = await getAllLogs2(limit, readableBy);
     }
     listLogs.respond(res, 200, { logs });
     return true;
@@ -34235,7 +34905,7 @@ async function handleStats(req, res, pathSegments, queryParams, myAgentId) {
     return true;
   }
   if (getConcurrentContextRoute.match(req.method, pathSegments)) {
-    const context = await getConcurrentContext2();
+    const context = await getConcurrentContext2(readableByFor2(await resolveSessionActor2(req, myAgentId)));
     getConcurrentContextRoute.respond(res, 200, context);
     return true;
   }
@@ -38306,10 +38976,11 @@ var 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),
@@ -38341,7 +39012,7 @@ var httpServer = createHttpServer(async (req, res) => {
   });
 });
 var detachRealtime = attachRealtimeTransport(httpServer);
-var { attachControllerTransport } = await import("./controllers-connect-6yhwqv9v.js");
+var { attachControllerTransport } = await import("./controllers-connect-gkxmqw9d.js");
 var detachControllers = attachControllerTransport(httpServer);
 var stopWorkerNudges = startWorkerNudgeListener();
 var stopRoomDeletion = realtimeBus.subscribe("room:namespace-deleted", (namespace) => {
@@ -38370,7 +39041,7 @@ async function shutdown() {
     sessionsProcessed: getServerSessionsProcessed()
   });
   if (hasCapability("scheduling")) {
-    const { stopScheduler } = await import("./index-e4tsa1h7.js");
+    const { stopScheduler } = await import("./index-8pwc1jc8.js");
     stopScheduler();
   }
   stopHeartbeat2();
@@ -38382,7 +39053,7 @@ async function shutdown() {
   await stopSlackApp2();
   await stopChatSdk();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { stopOAuthKeepalive } = await import("./keepalive-d4nzs76x.js");
+    const { stopOAuthKeepalive } = await import("./keepalive-3nr4st3r.js");
     await stopOAuthKeepalive();
   }
   stopOAuthPendingGc();
@@ -38462,21 +39133,21 @@ try {
   console.warn("[startup] CAPABILITIES upgrade seed failed (non-fatal):", err);
 }
 try {
-  const { ensurePricingSeeded } = await import("./boot-seeds-w2hmkxn5.js");
+  const { ensurePricingSeeded } = await import("./boot-seeds-xs9a8dx1.js");
   ensurePricingSeeded();
-  const { startPricingRefreshLoop } = await import("./pricing-refresh-6ehwkcmp.js");
+  const { startPricingRefreshLoop } = await import("./pricing-refresh-5nvme3sm.js");
   startPricingRefreshLoop();
 } catch (err) {
   console.error("[startup] Failed to seed pricing rows:", err);
 }
 try {
-  const { ensureModelProfilesSeeded } = await import("./boot-seeds-w2hmkxn5.js");
+  const { ensureModelProfilesSeeded } = await import("./boot-seeds-xs9a8dx1.js");
   await ensureModelProfilesSeeded();
 } catch (err) {
   console.error("[startup] Failed to seed model profiles:", err);
 }
 try {
-  const { ensureRbacSeeded } = await import("./boot-seeds-w2hmkxn5.js");
+  const { ensureRbacSeeded } = await import("./boot-seeds-xs9a8dx1.js");
   ensureRbacSeeded();
 } catch (err) {
   console.error("[startup] Failed to sync RBAC seed rows:", err);
@@ -38484,7 +39155,7 @@ try {
     throw err;
 }
 try {
-  const { runAllSeeders } = await import("./index-039x2sag.js");
+  const { runAllSeeders } = await import("./index-s7ckdajq.js");
   await runAllSeeders({ scriptEmbeddingMode: "skip" });
 } catch (err) {
   console.error("[startup] Failed to seed built-in entities:", err);
@@ -38546,39 +39217,39 @@ httpServer.listen(port, async () => {
   await initWorkflows2();
   await startScriptRunSupervisor(getMcpBaseUrl());
   if (hasCapability("scheduling")) {
-    const { startScheduler } = await import("./index-e4tsa1h7.js");
-    const { getExecutorRegistry } = await import("./index-1r8hw4vd.js");
+    const { startScheduler } = await import("./index-8pwc1jc8.js");
+    const { getExecutorRegistry } = await import("./index-dg2tmj99.js");
     const intervalMs = Number(process.env.SCHEDULER_INTERVAL_MS) || 1e4;
     startScheduler(getExecutorRegistry(), intervalMs, {
       runId: globalState.__runId
     });
   }
   if (!isEnvFlagEnabled("HEARTBEAT_DISABLE", false)) {
-    const { startHeartbeat } = await import("./index-qyjbb7br.js");
+    const { startHeartbeat } = await import("./index-nxa6me0q.js");
     const heartbeatMs = Number(process.env.HEARTBEAT_INTERVAL_MS) || 90000;
     startHeartbeat(heartbeatMs);
   }
   startPoolRouting();
   startRuntimeSupervisor();
   if (process.env.OAUTH_KEEPALIVE_DISABLE !== "true") {
-    const { startOAuthKeepalive } = await import("./keepalive-d4nzs76x.js");
+    const { startOAuthKeepalive } = await import("./keepalive-3nr4st3r.js");
     startOAuthKeepalive();
   }
   if (process.env.OAUTH_REFRESH_SWEEP_DISABLE !== "true") {
-    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-3f25djq3.js");
+    const { startOAuthRefreshSweep } = await import("./oauth-refresh-sweep-9q2t0y3q.js");
     startOAuthRefreshSweep();
   }
   startOAuthPendingGc();
   await startMemoryGc();
   await startDbRetention();
   startHumanFreeDrain();
-  import("./boot-reembed-4kx69j3g.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
+  import("./boot-reembed-qr8a894z.js").then(({ runBootReembed }) => runBootReembed()).catch((err) => {
     console.error("[boot-reembed] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-reembed-db0wwgy1.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
+  import("./boot-reembed-rj85jjhw.js").then(({ runBootReembedScripts }) => runBootReembedScripts()).catch((err) => {
     console.error("[boot-reembed-scripts] startup backfill failed (non-fatal):", err);
   });
-  import("./boot-scrub-sweep-tfv4d3mm.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
+  import("./boot-scrub-sweep-eyfvn6v9.js").then(({ runBootScrubSweep }) => runBootScrubSweep()).catch((err) => {
     console.error("[boot-scrub-sweep] startup scrub failed (non-fatal):", err);
   });
 }).on("error", (err) => {