@desplega.ai/agent-swarm 1.162.0 → 1.164.0

package/src/http/memory.ts

@@ -7,6 +7,16 @@ import { CANDIDATE_SET_MULTIPLIER } from "../be/memory/constants";
 import { listEdgesForAgent } from "../be/memory/edges-store";
 import { expandCandidatesWithGraph } from "../be/memory/graph-expansion";
 import { indexMemoryContent } from "../be/memory/index-content";
+import {
+  checkChunkIntegrity,
+  estimateTokens,
+  getMemoryChunks,
+  getPosteriorsByIds,
+  listMemoryKeys,
+  MEMORY_KEYS_DEFAULT_PREFIX,
+  MEMORY_KEYS_MAX_LIMIT,
+  posteriorMean,
+} from "../be/memory/key-browser";
 import { MemoryKeyError } from "../be/memory/key-guard";
 import { MEMORY_KEY_MAX_LENGTH } from "../be/memory/key-paths";
 import { refreshLinks } from "../be/memory/link-resolver";
@@ -223,15 +233,24 @@ const MemoryListResultItemSchema = z.object({
   chunkIndex: z.number(),
   totalChunks: z.number(),
   tags: z.array(z.string()),
+  key: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  rating: z.number().describe("Usefulness posterior mean alpha / (alpha + beta); 0.5 = no signal"),
 });
 
 const listMemory = route({
   method: "post",
   path: "/api/memory/list",
   pattern: ["api", "memory", "list"],
-  summary: "List or semantically search memories across all agents (debug/admin)",
+  summary: "List or semantically search memories (debug/admin)",
+  description:
+    "The operator key, a user, and the lead see every agent's memories. Any other agent (an `aseph_` session token, or the shared key with `X-Agent-ID`) sees only its own memories and swarm-scope memories.",
   tags: ["Memory"],
   auth: { apiKey: true },
+  rbac: {
+    ungated:
+      "read-only listing; the handler narrows an agent principal to its own and swarm-scope rows",
+  },
   body: z.object({
     query: z
       .string()
@@ -266,6 +285,136 @@ const listMemory = route({
   },
 });
 
+// Mirrors `MemoryKeySummary` (src/be/memory/key-browser.ts).
+const MemoryKeySummarySchema = z.object({
+  key: z.string(),
+  scope: AgentMemoryScopeSchema,
+  agentId: z.string().nullable(),
+  memoryId: z.string(),
+  name: z.string(),
+  source: AgentMemorySourceSchema,
+  chunkRows: z.number(),
+  totalChunks: z.number(),
+  complete: z.boolean(),
+  chars: z.number(),
+  estTokens: z.number(),
+  accessCount: z.number(),
+  lastAccessedAt: z.string().nullable(),
+  rating: z.number(),
+  alpha: z.number(),
+  beta: z.number(),
+  usefulRatings: z.number(),
+  notUsefulRatings: z.number(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+const listMemoryKeysRoute = route({
+  method: "get",
+  path: "/api/memory/keys",
+  pattern: ["api", "memory", "keys"],
+  summary:
+    "One aggregate row per keyed memory under a key prefix: chunks, usage, rating, estimated tokens (debug/admin)",
+  description:
+    "The operator key, a user, and the lead see every agent's memories. Any other agent sees only its own memories and swarm-scope memories.",
+  tags: ["Memory"],
+  auth: { apiKey: true },
+  query: z.object({
+    prefix: z
+      .string()
+      .min(1)
+      .max(MEMORY_KEY_MAX_LENGTH)
+      .default(MEMORY_KEYS_DEFAULT_PREFIX)
+      .describe("Literal, case-sensitive key prefix (default '/longterm/')."),
+    limit: z.coerce.number().int().min(1).max(MEMORY_KEYS_MAX_LIMIT).default(MEMORY_KEYS_MAX_LIMIT),
+  }),
+  responses: {
+    200: {
+      description:
+        "Keyed memories grouped by (key, scope, agentId). accessCount is summed over chunk rows; rating pools alpha/beta over chunk rows; estTokens = ceil(chars / 4)",
+      schema: z.object({
+        prefix: z.string(),
+        keys: z.array(MemoryKeySummarySchema),
+        truncated: z.boolean(),
+      }),
+    },
+    400: { description: "Validation error" },
+  },
+});
+
+const MemoryChunkSchema = z.object({
+  id: z.string(),
+  agentId: z.string().nullable(),
+  scope: AgentMemoryScopeSchema,
+  key: z.string().nullable(),
+  name: z.string(),
+  content: z.string(),
+  source: AgentMemorySourceSchema,
+  sourceTaskId: z.string().nullable(),
+  sourcePath: z.string().nullable(),
+  chunkIndex: z.number(),
+  totalChunks: z.number(),
+  tags: z.array(z.string()),
+  createdAt: z.string(),
+  updatedAt: z.string().nullable(),
+  accessedAt: z.string(),
+  expiresAt: z.string().nullable(),
+  accessCount: z.number(),
+  embeddingModel: z.string().nullable(),
+  rating: z.number(),
+  alpha: z.number(),
+  beta: z.number(),
+  version: z.number(),
+  estTokens: z.number(),
+});
+
+const getMemoryChunksRoute = route({
+  method: "get",
+  path: "/api/memory/chunks",
+  pattern: ["api", "memory", "chunks"],
+  summary:
+    "Every chunk row of one memory in chunkIndex order, with a chunk-integrity check (debug/admin). Does not count as an access",
+  description:
+    "Visibility matches the memory list: an agent other than the lead gets 404 for another agent's agent-scope memory.",
+  tags: ["Memory"],
+  auth: { apiKey: true },
+  query: z
+    .object({
+      memoryId: z.string().uuid().optional().describe("Any chunk row of the memory."),
+      key: z.string().min(1).max(MEMORY_KEY_MAX_LENGTH).optional(),
+      scope: AgentMemoryScopeSchema.optional(),
+      agentId: z
+        .string()
+        .optional()
+        .describe("Owner agent id; pass an empty string for rows without one."),
+    })
+    .refine((q) => q.memoryId || q.key, { message: "memoryId or key required" }),
+  responses: {
+    200: {
+      description: "Chunk rows and integrity findings",
+      schema: z.object({
+        key: z.string().nullable(),
+        scope: AgentMemoryScopeSchema,
+        agentId: z.string().nullable(),
+        chunks: z.array(MemoryChunkSchema),
+        estTokens: z.number(),
+        integrity: z.object({
+          ok: z.boolean(),
+          expectedChunks: z.number(),
+          presentIndexes: z.array(z.number()),
+          missingIndexes: z.array(z.number()),
+          duplicateIndexes: z.array(z.number()),
+          conflictingTotals: z.array(z.number()),
+          outOfRangeIds: z.array(z.string()),
+          issues: z.array(z.string()),
+        }),
+      }),
+    },
+    400: { description: "Validation error" },
+    404: { description: "Memory not found" },
+  },
+});
+
 // Mirrors `MemoryVecPopulateStats` (src/be/memory/types.ts).
 const MemoryVecPopulateStatsSchema = z.object({
   attempted: z.number(),
@@ -395,11 +544,15 @@ const deleteMemoryById = route({
   path: "/api/memory/{id}",
   pattern: ["api", "memory", null],
   summary: "Delete a single memory by ID (debug/admin)",
+  description:
+    "The operator key and users may delete any memory. The lead may delete its own memories and swarm-scope memories. Any other agent may delete only its own agent-scope memories.",
   tags: ["Memory"],
   auth: { apiKey: true },
+  rbac: { permission: "memory.delete.any" },
   params: z.object({ id: z.string().uuid() }),
   responses: {
     200: { description: "Memory deleted", schema: z.object({ deleted: z.boolean() }) },
+    403: { description: "Caller may not delete this memory" },
     404: { description: "Memory not found" },
   },
 });
@@ -643,6 +796,12 @@ async function ingestPrincipal(
   return { kind: "agent", agentId: "", isLead: false };
 }
 
+/** Whose rows a memory list may show. `seesAll` lifts the own-or-swarm filter. */
+function memoryListViewer(principal: RbacPrincipal): { agentId: string; seesAll: boolean } {
+  const seesAll = can({ principal, verb: "memory.read.any", source: "http" }).allow;
+  return { agentId: principal.kind === "agent" ? principal.agentId : "", seesAll };
+}
+
 export async function handleMemory(
   req: IncomingMessage,
   res: ServerResponse,
@@ -852,6 +1011,9 @@ export async function handleMemory(
 
     const { query, agentId, scope, source, sourcePath, limit, offset } = parsed.body;
     const store = getMemoryStore();
+    // Humans and the lead see every agent's rows; any other agent sees its own
+    // rows plus swarm-scope rows (the store's non-lead scope conditions).
+    const viewer = memoryListViewer(await ingestPrincipal(req, myAgentId));
     const pageLimit = Math.min(limit, 100);
     const pathNeedle = sourcePath?.trim().toLowerCase();
     const matchesPath = (p: string | null) =>
@@ -866,10 +1028,10 @@ export async function handleMemory(
           4096,
           Math.max(offset + pageLimit, pageLimit) * CANDIDATE_SET_MULTIPLIER,
         );
-        let candidates = await store.search(queryEmbedding ?? new Float32Array(0), agentId ?? "", {
+        let candidates = await store.search(queryEmbedding ?? new Float32Array(0), viewer.agentId, {
           scope,
           limit: candidateLimit,
-          isLead: true,
+          isLead: viewer.seesAll,
           source,
           queryText: query.trim(),
         });
@@ -904,6 +1066,9 @@ export async function handleMemory(
             chunkIndex: r.chunkIndex,
             totalChunks: r.totalChunks,
             tags: r.tags,
+            key: r.key ?? null,
+            updatedAt: r.updatedAt ?? null,
+            rating: posteriorMean(r.alpha, r.beta),
           })),
           total: candidates.length,
           limit: pageLimit,
@@ -917,13 +1082,14 @@ export async function handleMemory(
         scope,
         limit: pageLimit,
         offset,
-        isLead: true,
+        isLead: viewer.seesAll,
         ownerAgentId: agentId,
         source,
         sourcePath: pathNeedle,
       };
-      const rows = await store.list(agentId ?? "", listOptions);
-      const total = await store.count(agentId ?? "", listOptions);
+      const rows = await store.list(viewer.agentId, listOptions);
+      const total = await store.count(viewer.agentId, listOptions);
+      const posteriors = await getPosteriorsByIds(rows.map((r) => r.id));
 
       listMemory.respond(res, 200, {
         results: rows.map((r) => ({
@@ -943,6 +1109,12 @@ export async function handleMemory(
           chunkIndex: r.chunkIndex,
           totalChunks: r.totalChunks,
           tags: r.tags,
+          key: r.key ?? null,
+          updatedAt: r.updatedAt ?? null,
+          rating: (() => {
+            const p = posteriors.get(r.id);
+            return p ? posteriorMean(p.alpha, p.beta) : 0.5;
+          })(),
         })),
         total,
         limit: pageLimit,
@@ -956,6 +1128,88 @@ export async function handleMemory(
     return true;
   }
 
+  if (listMemoryKeysRoute.match(req.method, pathSegments)) {
+    const parsed = await listMemoryKeysRoute.parse(
+      req,
+      res,
+      pathSegments,
+      parseQueryParams(req.url || ""),
+    );
+    if (!parsed) return true;
+    const { prefix, limit } = parsed.query;
+    const viewer = memoryListViewer(await ingestPrincipal(req, myAgentId));
+    const { keys, truncated } = await listMemoryKeys({
+      prefix,
+      limit,
+      visibleToAgentId: viewer.seesAll ? undefined : viewer.agentId,
+    });
+    listMemoryKeysRoute.respond(res, 200, {
+      prefix,
+      keys: keys.map((k) => ({
+        ...k,
+        scope: AgentMemoryScopeSchema.parse(k.scope),
+        source: AgentMemorySourceSchema.parse(k.source),
+      })),
+      truncated,
+    });
+    return true;
+  }
+
+  if (getMemoryChunksRoute.match(req.method, pathSegments)) {
+    const parsed = await getMemoryChunksRoute.parse(
+      req,
+      res,
+      pathSegments,
+      parseQueryParams(req.url || ""),
+    );
+    if (!parsed) return true;
+    const { memoryId, key, scope, agentId } = parsed.query;
+    // Same visibility as the list: a hidden memory reads as not found.
+    const viewer = memoryListViewer(await ingestPrincipal(req, myAgentId));
+    const visibility = { visibleToAgentId: viewer.seesAll ? undefined : viewer.agentId };
+    const doc = memoryId
+      ? await getMemoryChunks({ memoryId }, visibility)
+      : await getMemoryChunks({ key: key as string, scope, agentId }, visibility);
+    if (!doc) {
+      jsonError(res, "Memory not found", 404);
+      return true;
+    }
+    const chunks = doc.chunks.map((c) => ({
+      id: c.id,
+      agentId: c.agentId,
+      scope: AgentMemoryScopeSchema.parse(c.scope),
+      key: c.key,
+      name: c.name,
+      content: c.content,
+      source: AgentMemorySourceSchema.parse(c.source),
+      sourceTaskId: c.sourceTaskId,
+      sourcePath: c.sourcePath,
+      chunkIndex: c.chunkIndex,
+      totalChunks: c.totalChunks,
+      tags: c.tags,
+      createdAt: c.createdAt,
+      updatedAt: c.updatedAt ?? null,
+      accessedAt: c.accessedAt,
+      expiresAt: c.expiresAt ?? null,
+      accessCount: c.accessCount ?? 0,
+      embeddingModel: c.embeddingModel ?? null,
+      rating: posteriorMean(c.alpha, c.beta),
+      alpha: c.alpha,
+      beta: c.beta,
+      version: c.version ?? 1,
+      estTokens: estimateTokens(c.content.length),
+    }));
+    getMemoryChunksRoute.respond(res, 200, {
+      key: doc.key,
+      scope: AgentMemoryScopeSchema.parse(doc.scope),
+      agentId: doc.agentId,
+      chunks,
+      estTokens: estimateTokens(chunks.reduce((sum, c) => sum + c.content.length, 0)),
+      integrity: checkChunkIntegrity(chunks),
+    });
+    return true;
+  }
+
   if (editMemory.match(req.method, pathSegments)) {
     if (!myAgentId) {
       jsonError(res, "Missing X-Agent-ID header", 400);
@@ -1062,6 +1316,21 @@ export async function handleMemory(
     if (!parsed) return true;
 
     const store = getMemoryStore();
+    const memory = await store.peek(parsed.params.id);
+    if (!memory) {
+      jsonError(res, "Memory not found", 404);
+      return true;
+    }
+    const decision = can({
+      principal: await ingestPrincipal(req, myAgentId),
+      verb: "memory.delete.any",
+      resource: { kind: "owned", ownerAgentId: memory.agentId, scope: memory.scope },
+      source: "http",
+    });
+    if (!decision.allow) {
+      jsonError(res, `Forbidden: ${decision.reason}`, 403);
+      return true;
+    }
     const deleted = await store.delete(parsed.params.id);
     if (!deleted) {
       jsonError(res, "Memory not found", 404);

package/src/http/repos.ts

@@ -1,14 +1,12 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import {
-  createSwarmRepo,
-  deleteSwarmRepo,
-  getSwarmRepoById,
-  getSwarmRepos,
-  updateSwarmRepo,
-} from "../be/db";
+import { createSwarmRepo, deleteSwarmRepo, getSwarmRepoById, getSwarmRepos } from "../be/db";
+import { updateSwarmRepoChecked } from "../be/repo-checked-update";
+import { changesAllowMerge } from "../be/repo-merge-policy";
+import { can } from "../rbac";
 import { emitIntegrationConnected } from "../telemetry";
 import { RepoGuidelinesInputSchema, RepoHooksSchema, SwarmRepoSchema } from "../types";
+import { agentFirstPrincipal } from "./request-principal";
 import { route } from "./route-def";
 import { json, jsonError } from "./utils";
 
@@ -63,8 +61,13 @@ const createRepo = route({
   responses: {
     201: { description: "Repo created", schema: SwarmRepoSchema },
     400: { description: "Validation error", schema: z.object({ error: z.string() }) },
+    403: {
+      description: "Only the lead, the operator or a user can turn allowMerge on",
+      schema: z.object({ error: z.string() }),
+    },
     409: { description: "Duplicate repo", schema: z.object({ error: z.string() }) },
   },
+  rbac: { permission: "repo.merge-policy.write" },
 });
 
 const updateRepo = route({
@@ -85,9 +88,14 @@ const updateRepo = route({
   }),
   responses: {
     200: { description: "Repo updated", schema: SwarmRepoSchema },
+    403: {
+      description: "Only the lead, the operator or a user can change allowMerge",
+      schema: z.object({ error: z.string() }),
+    },
     404: { description: "Repo not found", schema: z.object({ error: z.string() }) },
     409: { description: "Duplicate repo", schema: z.object({ error: z.string() }) },
   },
+  rbac: { permission: "repo.merge-policy.write" },
 });
 
 const deleteRepo = route({
@@ -105,11 +113,26 @@ const deleteRepo = route({
 
 // ─── Handler ─────────────────────────────────────────────────────────────────
 
+/** The refusal text when the caller may not change allowMerge, or null when they may. */
+async function allowMergeRefusal(
+  req: IncomingMessage,
+  myAgentId: string | undefined,
+): Promise<string | null> {
+  const decision = can({
+    principal: await agentFirstPrincipal(req, myAgentId),
+    verb: "repo.merge-policy.write",
+    resource: { kind: "none" },
+    source: "http",
+  });
+  return decision.allow ? null : `Forbidden: ${decision.reason}`;
+}
+
 export async function handleRepos(
   req: IncomingMessage,
   res: ServerResponse,
   pathSegments: string[],
   queryParams: URLSearchParams,
+  myAgentId: string | undefined,
 ): Promise<boolean> {
   if (getRepo.match(req.method, pathSegments)) {
     const parsed = await getRepo.parse(req, res, pathSegments, queryParams);
@@ -137,6 +160,13 @@ export async function handleRepos(
   if (createRepo.match(req.method, pathSegments)) {
     const parsed = await createRepo.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
+    if (changesAllowMerge(null, parsed.body.guidelines)) {
+      const refusal = await allowMergeRefusal(req, myAgentId);
+      if (refusal) {
+        jsonError(res, refusal, 403);
+        return true;
+      }
+    }
     try {
       const repo = await createSwarmRepo({
         url: parsed.body.url,
@@ -168,20 +198,30 @@ export async function handleRepos(
     const parsed = await updateRepo.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
     try {
-      const updated = await updateSwarmRepo(parsed.params.id, {
-        url: parsed.body.url,
-        name: parsed.body.name,
-        clonePath: parsed.body.clonePath,
-        defaultBranch: parsed.body.defaultBranch,
-        autoClone: parsed.body.autoClone,
-        hooks: parsed.body.hooks,
-        guidelines: parsed.body.guidelines,
-      });
-      if (!updated) {
+      // The comparison with the stored allowMerge, the decision and the write share one
+      // transaction, so a stale edit cannot overwrite a merge-policy change committed after it.
+      const result = await updateSwarmRepoChecked(
+        parsed.params.id,
+        {
+          url: parsed.body.url,
+          name: parsed.body.name,
+          clonePath: parsed.body.clonePath,
+          defaultBranch: parsed.body.defaultBranch,
+          autoClone: parsed.body.autoClone,
+          hooks: parsed.body.hooks,
+          guidelines: parsed.body.guidelines,
+        },
+        () => allowMergeRefusal(req, myAgentId),
+      );
+      if (result.kind === "refused") {
+        jsonError(res, result.refusal, 403);
+        return true;
+      }
+      if (result.kind === "not-found") {
         jsonError(res, "Repo not found", 404);
         return true;
       }
-      json(res, updated);
+      json(res, result.repo);
     } catch (error) {
       const msg = (error as Error).message;
       if (msg.includes("UNIQUE constraint")) {

package/src/http/request-principal.ts

@@ -20,3 +20,22 @@ export async function requestPrincipal(
   const agent = await getAgentById(myAgentId);
   return { kind: "agent", agentId: myAgentId, isLead: agent?.isLead ?? false };
 }
+
+/**
+ * The principal of a keyed HTTP request that may act as an agent. Workers share the swarm API
+ * key, so the key alone authenticates as the operator. An X-Agent-ID, or an `aseph_` session
+ * token, names the agent on top of it, and its lead flag is read live. A user token stays the
+ * user. A request with no agent identity is the operator, as for the dashboard and the runner.
+ * Unlike `requestPrincipal`, an agent identity wins over the operator key.
+ */
+export async function agentFirstPrincipal(
+  req: IncomingMessage,
+  myAgentId: string | undefined,
+): Promise<RbacPrincipal> {
+  const auth = getRequestAuth(req);
+  if (auth?.kind === "user") return { kind: "user", userId: auth.userId };
+  const agentId = auth?.kind === "agent" ? auth.agentId : myAgentId;
+  if (!agentId) return { kind: "operator" };
+  const agent = await getAgentById(agentId);
+  return { kind: "agent", agentId, isLead: agent?.isLead === true };
+}

package/src/http/session-cost-recompute.ts

@@ -5,6 +5,7 @@ import type {
   SessionCostModelBreakdown,
   SessionCostSource,
 } from "../types";
+import { AMP_ESTIMATE_MODELS, ampBillsCacheWrites, resolveAmpModel } from "../utils/amp-models";
 
 const PER_MILLION = 1_000_000;
 
@@ -121,6 +122,52 @@ function unpricedResult(
   };
 }
 
+/**
+ * An amp row with no per-model usage means the thread export failed, and the
+ * adapter sent the stream's token totals under the requested mode or pin.
+ * Recording $0 would let the session skip budget admission, so the totals are
+ * priced at the pin, or at the model the mode is known to run, falling back to
+ * the `medium` model when the pin has no rates. The row is tagged `estimated`.
+ */
+async function estimateAmpCost(
+  input: SessionCostRecomputeInput,
+  lookupRate: PricingRateLookup,
+): Promise<SessionCostRecomputeResult> {
+  let selection: ReturnType<typeof resolveAmpModel> | undefined;
+  try {
+    selection = resolveAmpModel(input.model);
+  } catch {
+    selection = undefined;
+  }
+  const candidates = [
+    ...new Set([
+      selection?.pin,
+      selection ? AMP_ESTIMATE_MODELS[selection.baseMode] : undefined,
+      AMP_ESTIMATE_MODELS.medium,
+    ]),
+  ].filter((model): model is string => !!model);
+  for (const model of candidates) {
+    // Same rule as the export parser: only Anthropic bills cache creation as writes.
+    const writes = ampBillsCacheWrites(model);
+    const costUsd = await priceModel(
+      "amp",
+      {
+        model,
+        inputTokens: input.inputTokens + (writes ? 0 : input.cacheWriteTokens),
+        outputTokens: input.outputTokens,
+        cacheReadTokens: input.cacheReadTokens,
+        cacheWriteTokens: writes ? input.cacheWriteTokens : 0,
+      },
+      null,
+      input.atEpochMs,
+      lookupRate,
+    );
+    if (costUsd != null)
+      return { totalCostUsd: costUsd, costSource: "estimated", modelBreakdown: undefined };
+  }
+  return unpricedResult(input, undefined);
+}
+
 export async function recomputeSessionCost(
   input: SessionCostRecomputeInput,
   lookupRate: PricingRateLookup,
@@ -135,6 +182,23 @@ export async function recomputeSessionCost(
     };
   }
 
+  // Amp's own recorded cost (`amp threads usage`) is what it billed, including
+  // subagent threads the token counts miss. The adapter sends it only when
+  // every request was billed through Amp, so it wins over the token price,
+  // which still fills the per-model breakdown.
+  if (input.provider === "amp" && input.harnessCostUsd > 0) {
+    const priced = await recomputeSessionCost({ ...input, harnessCostUsd: 0 }, lookupRate);
+    return {
+      totalCostUsd: input.harnessCostUsd,
+      costSource: "harness",
+      modelBreakdown: priced.modelBreakdown,
+    };
+  }
+
+  // amp's top-level model is the mode or pin it was asked for; only the thread
+  // export's per-model usage says what ran and how its cache tokens bill.
+  if (input.provider === "amp" && !modelUsageEntries) return estimateAmpCost(input, lookupRate);
+
   const split = cacheWriteSplit(input);
   const usages: SessionCostModelUsageInput[] = modelUsageEntries
     ? modelUsageEntries

package/src/http/session-data.ts

@@ -13,6 +13,7 @@ import {
   getSessionCostsFiltered,
   getSessionLogsByTaskId,
   getTaskById,
+  refreshActiveSessionOnActivity,
 } from "../be/db";
 import { recordSessionCost } from "../otel";
 import { incrementServerSessionsProcessed } from "../server-runtime-counters";
@@ -319,6 +320,16 @@ export async function handleSessionData(
         cli: parsed.body.cli || "claude",
         lines: parsed.body.lines,
       });
+      // Every harness streams its output through this endpoint, so a task that
+      // is producing output keeps its session alive here instead of per
+      // provider. Best-effort: a liveness write must never fail log storage.
+      if (parsed.body.taskId) {
+        try {
+          await refreshActiveSessionOnActivity(parsed.body.taskId);
+        } catch (error) {
+          console.warn("[HTTP] Failed to refresh session liveness from session logs:", error);
+        }
+      }
       createSessionLogsRoute.respond(res, 201, {
         success: true,
         count: parsed.body.lines.length,

package/src/http/tasks.ts

@@ -888,7 +888,15 @@ export async function handleTasks(
     let requestedByUserId = trustedUserId ?? undefined;
     const trustBodyRequestedByUserId = process.env.TRUST_BODY_REQUESTED_BY_USER_ID !== "false";
     if (trustBodyRequestedByUserId && !requestedByUserId && parsed.body.requestedByUserId) {
-      const candidate = await findUserById(parsed.body.requestedByUserId);
+      // A worker on the shared key is not the operator: its X-Agent-ID names it, so the body
+      // hint is dropped like it is when the worker has a requester of its own.
+      const mayAssign = can({
+        principal: await resolveTaskWritePrincipal(req, myAgentId),
+        verb: "task.requester.assign",
+        resource: { kind: "none" },
+        source: "http",
+      }).allow;
+      const candidate = mayAssign ? await findUserById(parsed.body.requestedByUserId) : null;
       if (candidate) requestedByUserId = candidate.id;
     }