@desplega.ai/agent-swarm 2.4.3 → 2.4.5

package/src/http/core.ts

@@ -547,6 +547,8 @@ export async function handleCore(
         return true;
       }
       req.headers["x-runtime-instance-id"] = auth.runtimeId;
+    }
+    if (auth.tokenKind !== "task") {
       const sourceHeader = req.headers["x-source-task-id"];
       const taskId = Array.isArray(sourceHeader) ? sourceHeader[0] : sourceHeader;
       if (taskId !== undefined && (await getTaskById(taskId))?.agentId !== auth.agentId) {

package/src/http/fs.ts

@@ -1,18 +1,25 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { deleteTaskAttachment, getTaskAttachments, getTaskById } from "../be/db";
+import { appendDraftTaskText } from "../be/db/tasks/draft-text";
 import {
   ensureAgentFsCredentialsForAgent,
   inviteEmailToSharedOrg,
 } from "../be/seed/agent-fs-provision";
-import { MAX_TASK_ATTACHMENT_BYTES, recordTaskAttachmentUpload } from "../be/task-attachment-store";
-import { type FileObject, type FileScope, FilesError, normalizeFilesError } from "../fs/provider";
+import {
+  backingProviderId,
+  MAX_TASK_ATTACHMENT_BYTES,
+  recordTaskAttachmentUpload,
+  scopeFromAttachment,
+} from "../be/task-attachment-store";
+import { type FileObject, FilesError, normalizeFilesError } from "../fs/provider";
 import { getFileStorageProvider } from "../fs/registry";
 import { can, type RbacResource } from "../rbac";
 import { type TaskAttachment, TaskAttachmentSchema } from "../types";
 import { attachmentContentDisposition } from "../utils/content-disposition";
 import { getCurrentRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
+import { transcribeAudioNotes } from "../utils/transcription";
 import { requestPrincipal } from "./request-principal";
 import { route } from "./route-def";
 import { canReadSession, SESSION_READ_DENIED } from "./session-access";
@@ -147,7 +154,7 @@ const uploadTaskFileRoute = route({
   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.",
+    "Accepts a raw binary request body. Pass the display/path name as the `name` query parameter. An `audio/*` file uploaded to a `draft` task gets a `[File: …]` line and its transcript (or why there is none) appended to the task text before the response; a failed transcription never fails the upload.",
   tags: ["FS"],
   params: taskParams,
   query: uploadQuery,
@@ -331,7 +338,14 @@ export async function handleFs(
     const task = await getTaskById(parsed.params.taskId);
     if (!task) return notFound(res, "Task not found");
     if (!(await canMutateTask(task, myAgentId, req))) return forbidden(res);
-    return sendUpload(req, res, parsed.params.taskId, parsed.query, myAgentId ?? null);
+    return sendUpload(
+      req,
+      res,
+      parsed.params.taskId,
+      parsed.query,
+      myAgentId ?? null,
+      task.status === "draft",
+    );
   }
 
   if (listTaskFilesRoute.match(req.method, pathSegments)) {
@@ -366,6 +380,7 @@ async function sendUpload(
   taskId: string,
   query: z.infer<typeof uploadQuery>,
   agentId: string | null,
+  isDraft: boolean,
 ): Promise<boolean> {
   const body = await readRawBody(req, MAX_TASK_ATTACHMENT_BYTES);
   if (body === BODY_TOO_LARGE) {
@@ -417,10 +432,45 @@ async function sendUpload(
     isPrimary: query.isPrimary === "true",
     createdBy: auth?.kind === "user" ? auth.userId : undefined,
   });
+  const mimeType = contentType.split(";")[0]!.trim().toLowerCase();
+  if (isDraft && mimeType.startsWith("audio/")) {
+    await appendAudioTranscript(taskId, query.name, mimeType, body);
+  }
   uploadTaskFileRoute.respond(res, 201, attachment);
   return true;
 }
 
+/**
+ * A voice note uploaded to a draft (the composer's pre-dispatch window) gets
+ * its transcript in the task text, as one sent over Slack or a chat app does.
+ * Runs before the upload responds, so the composer promotes the draft only
+ * after the text is final. Never throws: the attachment has already landed.
+ */
+async function appendAudioTranscript(
+  taskId: string,
+  name: string,
+  mimeType: string,
+  body: Buffer,
+): Promise<void> {
+  try {
+    const notes = await transcribeAudioNotes(
+      [{ key: name, name, data: new Blob([body], { type: mimeType }), mimeType }],
+      "[fs]",
+    );
+    const note = notes.get(name);
+    if (!note) return;
+    if (!(await appendDraftTaskText(taskId, `[File: ${name} (${mimeType})]\n${note}`))) {
+      console.warn(`[fs] task ${taskId} left draft before the transcript of ${name} was added`);
+    }
+  } catch (error) {
+    console.warn(
+      scrubSecrets(
+        `[fs] could not add the transcript of ${name} to task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+      ),
+    );
+  }
+}
+
 async function sendDownload(res: ServerResponse, attachment: TaskAttachment): Promise<boolean> {
   const provider = getFileStorageProvider();
   if (backingProviderId(attachment) !== provider.id) {
@@ -491,36 +541,6 @@ async function sendDelete(res: ServerResponse, attachment: TaskAttachment): Prom
   return true;
 }
 
-// Resolve against the row's ACTUAL stored key + its own org/drive, rather than
-// reconstructing `tasks/<taskId>/<name>`. Attachments written to agent-fs via the
-// CLI live at arbitrary paths (`misc/…`, `smoke/…`); reconstruction mis-resolves
-// them, which previously caused downloads to 404 and deletes to orphan the real
-// file. New uploads have no stored key yet at scope-build time and keep the
-// forward-looking layout.
-function scopeFromAttachment(attachment: TaskAttachment): FileScope {
-  const storedKey = attachment.providerKey ?? attachment.path ?? "";
-  return {
-    taskId: attachment.taskId,
-    name: attachment.name,
-    key: storedKey.trim() ? storedKey : undefined,
-    orgId: attachment.orgId,
-    driveId: attachment.driveId,
-  };
-}
-
-// Which file-storage provider (if any) actually holds this attachment's bytes.
-// Only agent-fs objects and local-fs uploads are provider-backed; `shared-fs`
-// worker-volume pointers, `url`, and `page` attachments have no provider object,
-// so they must never be fetched or deleted through a provider (doing so would
-// mis-resolve and, on delete, orphan the real target). Note local-fs uploads are
-// recorded with kind "shared-fs" but an explicit local-fs providerId, so key off
-// both signals rather than kind alone.
-function backingProviderId(attachment: TaskAttachment): string | null {
-  if (attachment.kind === "agent-fs") return attachment.providerId ?? "agent-fs";
-  if (attachment.providerId === "local-fs") return "local-fs";
-  return null;
-}
-
 async function findAttachment(
   req: IncomingMessage,
   myAgentId: string | undefined,

package/src/http/mcp-body.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { MCP_MAX_REQUEST_BODY_BYTES } from "@/mcp-limits";
+import { parseBody, RequestBodyTooLargeError } from "./utils";
+
+/** Returned by `readMcpBody` after it has answered the request with 413. */
+export const MCP_BODY_TOO_LARGE = Symbol("mcp-body-too-large");
+
+/**
+ * Read and parse a JSON-RPC request body for an MCP HTTP handler, capped at
+ * `MCP_MAX_REQUEST_BODY_BYTES`. A declared Content-Length over the cap is
+ * refused before reading; otherwise the read stops once the cap is crossed.
+ * Either way the caller gets `MCP_BODY_TOO_LARGE` after a 413 with a JSON-RPC
+ * error body (the SDK transport's shape), and the body never reaches
+ * `JSON.parse`.
+ */
+export async function readMcpBody(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<unknown | typeof MCP_BODY_TOO_LARGE> {
+  try {
+    return await parseBody(req, MCP_MAX_REQUEST_BODY_BYTES);
+  } catch (error) {
+    if (!(error instanceof RequestBodyTooLargeError)) throw error;
+    res.writeHead(413, { "Content-Type": "application/json", Connection: "close" });
+    res.end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: {
+          code: -32000,
+          message: `Payload Too Large: Request body must not exceed ${MCP_MAX_REQUEST_BODY_BYTES} bytes`,
+        },
+        id: null,
+      }),
+    );
+    return MCP_BODY_TOO_LARGE;
+  }
+}

package/src/http/mcp-user.ts

@@ -12,6 +12,7 @@ import {
   markMcpTransportActivity,
   respondNoMcpSession,
 } from "./mcp";
+import { MCP_BODY_TOO_LARGE, readMcpBody } from "./mcp-body";
 
 function unauthorized(res: ServerResponse): true {
   res.writeHead(401, { "Content-Type": "application/json" });
@@ -59,11 +60,8 @@ export async function handleMcpUser(
   }
 
   if (req.method === "POST") {
-    const chunks: Buffer[] = [];
-    for await (const chunk of req) {
-      chunks.push(chunk);
-    }
-    const body = JSON.parse(Buffer.concat(chunks).toString());
+    const body = await readMcpBody(req, res);
+    if (body === MCP_BODY_TOO_LARGE) return true;
 
     let transport: StreamableHTTPServerTransport;
 

package/src/http/mcp.ts

@@ -13,6 +13,7 @@ import {
   parseTaskToolManifest,
   selectTaskTools,
 } from "@/utils/task-tool-manifest";
+import { MCP_BODY_TOO_LARGE, readMcpBody } from "./mcp-body";
 
 export type McpTransportActivity = Record<string, number>;
 export type McpSessionAgents = Record<string, string>;
@@ -166,19 +167,17 @@ export async function handleMcp(
   if (agentMismatch) return true;
 
   if (req.method === "POST") {
-    const chunks: Buffer[] = [];
-    for await (const chunk of req) {
-      chunks.push(chunk);
-    }
-    const body = JSON.parse(Buffer.concat(chunks).toString());
+    const body = await readMcpBody(req, res);
+    if (body === MCP_BODY_TOO_LARGE) return true;
+    const rpc = body as { method?: unknown; id?: unknown } | null;
 
-    if (!sessionId && body.method === "server/discover") {
+    if (!sessionId && rpc?.method === "server/discover") {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
         JSON.stringify({
           jsonrpc: "2.0",
           error: { code: -32601, message: "Method not found" },
-          id: body.id ?? null,
+          id: rpc.id ?? null,
         }),
       );
       return true;

package/src/http/memory.ts

@@ -35,6 +35,7 @@ import {
 } from "../be/memory/raters/types";
 import { rerank } from "../be/memory/reranker";
 import { getRetrievalsForAgent, hasRetrievalForTask } from "../be/memory/retrieval-store";
+import { searchMemoryCandidates } from "../be/memory/search-candidates";
 import { getUsefulnessStats } from "../be/memory/usefulness-stats";
 import { shouldPersistAutomaticTaskMemory } from "../memory/automatic-task-gate";
 import { buildRecallQuery } from "../memory/recall-query";
@@ -916,14 +917,19 @@ export async function handleMemory(
       const queryEmbedding = await provider.embed(query);
 
       const candidateLimit = Math.min(limit, 20) * CANDIDATE_SET_MULTIPLIER;
-      const candidates = await store.search(queryEmbedding ?? new Float32Array(0), myAgentId, {
-        scope,
-        limit: candidateLimit,
-        source,
-        isLead: false,
-        queryText: query,
-        keyPrefix,
-      });
+      const candidates = await searchMemoryCandidates(
+        store,
+        queryEmbedding ?? new Float32Array(0),
+        myAgentId,
+        {
+          scope,
+          limit: candidateLimit,
+          source,
+          isLead: false,
+          queryText: query,
+          keyPrefix,
+        },
+      );
       // Default-on 1-hop memory_link neighbor expansion (disable with
       // MEMORY_GRAPH_EXPANSION=0|false).
       const expanded = await expandCandidatesWithGraph(candidates, myAgentId, {
@@ -1039,13 +1045,18 @@ export async function handleMemory(
           4096,
           Math.max(offset + pageLimit, pageLimit) * CANDIDATE_SET_MULTIPLIER,
         );
-        let candidates = await store.search(queryEmbedding ?? new Float32Array(0), viewer.agentId, {
-          scope,
-          limit: candidateLimit,
-          isLead: viewer.seesAll,
-          source,
-          queryText: query.trim(),
-        });
+        let candidates = await searchMemoryCandidates(
+          store,
+          queryEmbedding ?? new Float32Array(0),
+          viewer.agentId,
+          {
+            scope,
+            limit: candidateLimit,
+            isLead: viewer.seesAll,
+            source,
+            queryText: query.trim(),
+          },
+        );
         if (agentId) {
           candidates = candidates.filter((c) => c.agentId === agentId);
         }

package/src/http/page-proxy.ts

@@ -1,7 +1,11 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getPage } from "../be/db";
 import { getApiKey } from "../utils/api-key";
-import { extractAndVerifyCookie, parseCookieHeader } from "../utils/page-session";
+import {
+  extractLegacyPageSession,
+  extractPageSession,
+  isCookieSafePageId,
+} from "../utils/page-session";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -11,7 +15,10 @@ import { jsonError } from "./utils";
  *
  * Flow:
  *   1. Browser hits `/@swarm/api/<rest>` from inside an iframe of `/p/:id`.
- *   2. We parse the `page_session` cookie, verify HMAC + expiry.
+ *   2. The browser SDK names its page in `X-Swarm-Page-Id` (else we read the
+ *      same-host `/p/<id>` Referer). We read that page's `page_session_<id>`
+ *      cookie (or the legacy `page_session`), verify HMAC + expiry, and
+ *      require the signed payload to name the same page.
  *   3. Look up the page and recover the signed viewer identity.
  *   4. Re-issue the request to the same API server's `/api/<rest>` with
  *      the operator bearer plus the original signed session token. The bearer NEVER
@@ -119,6 +126,48 @@ route({
 
 const PROXY_PREFIX = "/@swarm/api/";
 
+/** Request header the browser SDK uses to say which page's session to use. */
+export const PAGE_ID_REQUEST_HEADER = "x-swarm-page-id";
+
+const PAGE_PATH_RE = /^\/p\/([^/.]+)/;
+
+/**
+ * Which page the caller claims to be: the `X-Swarm-Page-Id` header, else the
+ * `/p/<id>` path of a same-host Referer (pages that call `fetch` directly
+ * instead of the SDK). This only selects which cookie to read. It grants
+ * nothing: the cookie's signed payload must still name this page, and the
+ * forwarded `X-Page-Id` comes from that payload. `undefined` means the caller
+ * named no page (a client predating per-page cookies). `null` means it named
+ * one that cannot be a page id.
+ * Exported for tests.
+ */
+export function requestedPageId(req: IncomingMessage): string | null | undefined {
+  const raw = req.headers[PAGE_ID_REQUEST_HEADER];
+  const fromHeader = Array.isArray(raw) ? raw[0] : raw;
+  if (fromHeader !== undefined) return isCookieSafePageId(fromHeader) ? fromHeader : null;
+
+  const referer = req.headers.referer;
+  if (!referer) return undefined;
+  let refererUrl: URL;
+  try {
+    refererUrl = new URL(referer);
+  } catch {
+    return undefined;
+  }
+  // A cross-site Referer must not pick a cookie: a custom header would force a
+  // CORS preflight, a Referer does not.
+  if (refererUrl.host !== req.headers.host) return undefined;
+  const match = PAGE_PATH_RE.exec(refererUrl.pathname);
+  if (!match) return undefined;
+  let fromReferer: string;
+  try {
+    fromReferer = decodeURIComponent(match[1]!);
+  } catch {
+    return undefined;
+  }
+  return isCookieSafePageId(fromReferer) ? fromReferer : undefined;
+}
+
 /**
  * Reject a proxied suffix that smells like path traversal or an attempt to
  * smuggle an extra path segment via percent-encoding (e.g. `%2e%2e`, `%2f`).
@@ -194,11 +243,18 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   }
 
   // ─── Cookie validation ────────────────────────────────────────────────────
-  const payload = await extractAndVerifyCookie(req);
-  if (!payload) {
+  const claimedPageId = requestedPageId(req);
+  const session =
+    claimedPageId === undefined
+      ? await extractLegacyPageSession(req)
+      : claimedPageId === null
+        ? null
+        : await extractPageSession(req, claimedPageId);
+  if (!session) {
     jsonError(res, "no page session", 401);
     return true;
   }
+  const { payload } = session;
 
   const page = await getPage(payload.pageId);
   if (!page) {
@@ -236,7 +292,7 @@ export async function handlePageProxy(req: IncomingMessage, res: ServerResponse)
   const headers: Record<string, string> = {
     Authorization: `Bearer ${apiKey}`,
     "X-Page-Id": page.id,
-    "X-Page-Session": parseCookieHeader(req.headers.cookie, "page_session") ?? "",
+    "X-Page-Session": session.token,
   };
   // The page owner is not the browser viewer. The receiving auth layer
   // verifies this original signed token before resolving any user identity.

package/src/http/pages-public.ts

@@ -13,7 +13,7 @@
  *     302-redirect to the SPA `/pages/:id` route (the JSON renderer lives
  *     in the SPA, not the API — step-6/7).
  *   - `auth_mode === 'authed'`: returns 401. step-4 narrows this to also
- *     accept a valid `page_session` cookie.
+ *     accept a valid `page_session_<id>` cookie.
  *   - `auth_mode === 'password'`: returns 401. step-5 narrows this to also
  *     accept `?key=` query param + HTTP Basic.
  *
@@ -33,7 +33,7 @@ import {
 import { type Page, PageSchema } from "../types";
 import { getAppUrl, getConfiguredAppUrls } from "../utils/constants";
 import { getNodeEnv } from "../utils/node-env";
-import { extractAndVerifyCookie, issuePageSessionCookie } from "../utils/page-session";
+import { extractAndVerifyCookie, pageSessionSetCookies } from "../utils/page-session";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { route } from "./route-def";
 
@@ -357,16 +357,15 @@ function buildCsp(): string {
 /**
  * Decide whether a page is reachable based on cookie alone. Public pages are
  * always reachable; authed AND password pages can ALSO pass via a valid
- * `page_session` cookie scoped to the same page id (the cookie is the proof
- * once the user has successfully unlocked once). For password pages, when
- * the cookie is absent/invalid the caller falls through to the `?key=` +
- * Basic-auth resolution path; for authed pages the caller surfaces 401.
+ * `page_session_<id>` cookie (or the legacy `page_session`) whose signed
+ * payload names this page (the cookie is the proof once the user has
+ * successfully unlocked once). For password pages, when the cookie is
+ * absent/invalid the caller falls through to the `?key=` + Basic-auth
+ * resolution path; for authed pages the caller surfaces 401.
  *
  * The caller passes the cookie payload (already verified by
- * `extractAndVerifyCookie`) — `null` when no cookie was sent or it failed
- * verification. Cross-page reuse (cookie for page A presented for page B)
- * surfaces as a distinct `403` so misconfigurations are debuggable, NOT a
- * generic 401.
+ * `extractAndVerifyCookie`, which ignores sessions for other pages) — `null`
+ * when no session for this page was sent or it failed verification.
  *
  * For password pages with no/bad cookie, returns `{ ok: false, status: 401,
  * needsPassword: true }` so the handler knows to try the password flow before
@@ -374,7 +373,7 @@ function buildCsp(): string {
  */
 type AccessResult =
   | { ok: true }
-  | { ok: false; status: 401 | 403; reason: string; needsPassword?: boolean };
+  | { ok: false; status: 401; reason: string; needsPassword?: boolean };
 
 function isAccessible(
   page: Page,
@@ -382,27 +381,9 @@ function isAccessible(
 ): AccessResult {
   if (page.authMode === "public") return { ok: true };
 
-  // Cookie-first path. A cookie scoped to a DIFFERENT page id is "stale" —
-  // for password mode we silently ignore it and fall through to the password
-  // flow so the user can recover via `?key=` / Basic without manual cookie
-  // clearing. For authed mode we surface 403 (the SPA's launch-retry path
-  // handles recovery; direct browser access to authed pages is rare).
-  if (cookiePayload) {
-    if (cookiePayload.pageId === page.id) return { ok: true };
-    if (page.authMode === "password") {
-      return {
-        ok: false,
-        status: 401,
-        reason: "password required",
-        needsPassword: true,
-      };
-    }
-    return {
-      ok: false,
-      status: 403,
-      reason: "page-session cookie scoped to a different page id",
-    };
-  }
+  // Cookie-first path. Sessions for other pages never reach here, so an open
+  // tab of page A no longer fails once page B is launched in the same browser.
+  if (cookiePayload?.pageId === page.id) return { ok: true };
 
   if (page.authMode === "authed") {
     return {
@@ -523,7 +504,7 @@ export async function handlePagesPublic(
   // Pull + verify the page-session cookie ONCE — `null` covers "no cookie",
   // "tampered signature", "expired", "malformed". The access decision below
   // discriminates per-authMode.
-  const cookiePayload = await extractAndVerifyCookie(req);
+  const cookiePayload = await extractAndVerifyCookie(req, page.id);
 
   const access = isAccessible(page, cookiePayload);
 
@@ -531,7 +512,7 @@ export async function handlePagesPublic(
   // password flow mints a fresh cookie inline. Empty string = no cookie to
   // attach. We thread this through the handler so the existing 200-response
   // paths below can opt-in without duplicating their branch logic.
-  let inlineSetCookie = "";
+  let inlineSetCookie: string[] = [];
 
   if (!access.ok) {
     // Password flow: cookie missing/invalid, try `?key=` then Basic.
@@ -547,7 +528,7 @@ export async function handlePagesPublic(
           matched = false;
         }
         if (matched) {
-          inlineSetCookie = await issuePageSessionCookie(page.id, {
+          inlineSetCookie = await pageSessionSetCookies(req, page.id, {
             dev: isLocalhostRequest(req),
           });
           // fall through to the regular 200 path below.
@@ -586,7 +567,7 @@ export async function handlePagesPublic(
     // that `respond()` writes via `res.writeHead()` — Node gives the latter
     // precedence, which is the value we want here anyway.
     res.setHeader("Cache-Control", "no-store");
-    if (inlineSetCookie) res.setHeader("Set-Cookie", inlineSetCookie);
+    if (inlineSetCookie.length > 0) res.setHeader("Set-Cookie", inlineSetCookie);
     publicPageJsonRoute.respond(res, 200, {
       id: page.id,
       version: 1, // edit-counter is API-internal; SPA reads via /api/pages/:id/versions
@@ -602,13 +583,13 @@ export async function handlePagesPublic(
 
   // SVG stays byte-for-byte intact, including when ?print=1 is supplied.
   if (page.contentType === "image/svg+xml") {
-    const headers: Record<string, string> = {
+    const headers: Record<string, string | string[]> = {
       "Content-Type": "image/svg+xml",
       "Cache-Control": page.authMode === "public" ? "public, max-age=1800" : "private, no-store",
       "X-Content-Type-Options": "nosniff",
       "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
     };
-    if (inlineSetCookie) headers["Set-Cookie"] = inlineSetCookie;
+    if (inlineSetCookie.length > 0) headers["Set-Cookie"] = inlineSetCookie;
     res.writeHead(200, headers);
     res.end(page.body);
     await bumpViewCount(page.id);
@@ -625,20 +606,22 @@ export async function handlePagesPublic(
   // `/p/:id` — render either HTML directly or 302→SPA for JSON.
   if (page.contentType === "application/json") {
     if (wantsPrint) {
-      const headers: Record<string, string> = {
+      const headers: Record<string, string | string[]> = {
         "Content-Type": "text/html; charset=utf-8",
         "Cache-Control": "no-store",
         "Content-Security-Policy": buildCsp(),
         "X-Content-Type-Options": "nosniff",
       };
-      if (inlineSetCookie) headers["Set-Cookie"] = inlineSetCookie;
+      if (inlineSetCookie.length > 0) headers["Set-Cookie"] = inlineSetCookie;
       res.writeHead(200, headers);
       res.end(printableJsonPageHtml(page));
       await bumpViewCount(page.id);
       return true;
     }
-    const headers: Record<string, string> = { Location: `${getAppBaseUrl()}/pages/${page.id}` };
-    if (inlineSetCookie) headers["Set-Cookie"] = inlineSetCookie;
+    const headers: Record<string, string | string[]> = {
+      Location: `${getAppBaseUrl()}/pages/${page.id}`,
+    };
+    if (inlineSetCookie.length > 0) headers["Set-Cookie"] = inlineSetCookie;
     res.writeHead(302, headers);
     res.end();
     // 302 redirects are intentionally NOT counted — they're a stop-over for
@@ -656,14 +639,14 @@ export async function handlePagesPublic(
     injectBrowserSdk(page.body, feedback ? feedbackKeyGuardScript() : "") +
     (wantsPrint ? PRINT_AUTOTRIGGER_SCRIPT : "") +
     (feedback ? feedbackOverlayScripts(page.id) : "");
-  const headers: Record<string, string> = {
+  const headers: Record<string, string | string[]> = {
     "Content-Type": "text/html; charset=utf-8",
     "Cache-Control": "no-store",
     "Content-Security-Policy": buildCsp(),
     // Defence-in-depth: prevent MIME sniffing and clickjacking outside the SPA.
     "X-Content-Type-Options": "nosniff",
   };
-  if (inlineSetCookie) headers["Set-Cookie"] = inlineSetCookie;
+  if (inlineSetCookie.length > 0) headers["Set-Cookie"] = inlineSetCookie;
   res.writeHead(200, headers);
   res.end(html);
   await bumpViewCount(page.id);

package/src/http/pages.ts

@@ -36,7 +36,7 @@ import {
 } from "../types";
 import { getAppUrl, getPublicMcpBaseUrl } from "../utils/constants";
 import { getNodeEnv } from "../utils/node-env";
-import { issuePageSessionCookie } from "../utils/page-session";
+import { pageSessionSetCookies } from "../utils/page-session";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { resolveHttpFavoriteOwner } from "./favorite-owner";
 import { route } from "./route-def";
@@ -175,7 +175,7 @@ const resolvePageRoute = route({
  *     `?key=` query / HTTP Basic on `/p/:id` directly (step-5). Bearer-side
  *     issuance would bypass the password check entirely.
  *
- * Response: 204 No Content + `Set-Cookie: page_session=<signed>; HttpOnly; ...`.
+ * Response: 204 No Content + `Set-Cookie: page_session_<id>=<signed>; HttpOnly; ...`.
  */
 const launchPageRoute = route({
   method: "post",
@@ -981,13 +981,13 @@ export async function handlePages(
         : auth?.kind === "operator"
           ? { name: `guest-${randomUUID().slice(0, 8)}`, op: true as const }
           : undefined;
-    const cookie = await issuePageSessionCookie(page.id, {
+    const cookies = await pageSessionSetCookies(req, page.id, {
       dev: isDevRequest(req),
       ...identity,
     });
 
     applyLaunchCors(req, res);
-    res.setHeader("Set-Cookie", cookie);
+    res.setHeader("Set-Cookie", cookies);
     res.writeHead(204);
     res.end();
     return true;

package/src/http/script-runs.ts

@@ -101,6 +101,7 @@ const agentTaskBodySchema = z.object({
   routingNote: z.string().max(200).optional(),
   tags: z.array(z.string()).optional(),
   priority: z.number().int().min(0).max(100).optional(),
+  dependsOn: z.array(z.uuid()).optional(),
   offerMode: z.boolean().optional(),
   dir: z.string().min(1).optional(),
   vcsRepo: z.string().min(1).optional(),
@@ -655,6 +656,7 @@ export async function handleScriptRuns(
                 : undefined,
             tags: parsed.body.tags,
             priority: parsed.body.priority,
+            dependsOn: parsed.body.dependsOn,
             offeredTo: parsed.body.offerMode ? parsed.body.agentId : undefined,
             taskType: "script-run-step",
             source: "mcp",