@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/http/model-profiles.ts

@@ -0,0 +1,303 @@
+// Model profiles CRUD (runbooks/model-tiers.md § Model profiles).
+//
+// A profile is a named harness + model + optional effort. Lead picks one per
+// task (`profile` on send-task / POST /api/tasks) or sets it as an agent's
+// default (PATCH /api/agents/{id}/runtime { profile }); claim resolves it.
+// Reads are open to every caller; writes are operator-only (`models.profiles.write`).
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { isAlias } from "@desplega/model-catalog";
+import { z } from "zod";
+import { resolveHttpAuditUserId } from "../be/audit-user";
+import {
+  createModelProfile,
+  deleteModelProfile,
+  getModelProfileByName,
+  listModelProfiles,
+  modelProfileReferences,
+  updateModelProfile,
+} from "../be/db/model-profiles";
+import { explicitModelError } from "../be/model-validation";
+import { supportedReasoningLevels } from "../providers/reasoning-effort";
+import { can } from "../rbac";
+import {
+  ModelProfileNameSchema,
+  ModelProfileSchema,
+  type ProviderName,
+  ProviderNameSchema,
+  type ReasoningEffort,
+  ReasoningEffortSchema,
+} from "../types";
+import { agentFirstPrincipal } from "./request-principal";
+import { route } from "./route-def";
+import { jsonError } from "./utils";
+
+const listProfiles = route({
+  method: "get",
+  path: "/api/model-profiles",
+  pattern: ["api", "model-profiles"],
+  summary: "List model profiles",
+  description:
+    "Every model profile, ordered by harness then name. Filter by `harness` to see what an agent on that harness can run.",
+  tags: ["Models"],
+  query: z.object({ harness: ProviderNameSchema.optional() }),
+  responses: {
+    200: {
+      description: "Model profiles",
+      schema: z.object({ profiles: z.array(ModelProfileSchema) }),
+    },
+  },
+});
+
+const getProfile = route({
+  method: "get",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Get one model profile",
+  tags: ["Models"],
+  params: z.object({ name: z.string() }),
+  responses: {
+    200: { description: "The model profile", schema: ModelProfileSchema },
+    404: { description: "No profile with that name" },
+  },
+});
+
+const createProfile = route({
+  method: "post",
+  path: "/api/model-profiles",
+  pattern: ["api", "model-profiles"],
+  summary: "Create a model profile",
+  description:
+    "A profile runs on one harness. `model` must run on that harness and be in the model catalog unless `allowCustomModel` is true (a gateway id, a fresh launch); a `latest:` alias is accepted and resolves at claim. `effort` must be a level the harness and model support. Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  body: z.object({
+    name: ModelProfileNameSchema,
+    harness: ProviderNameSchema,
+    model: z.string().trim().min(1),
+    effort: ReasoningEffortSchema.nullable().optional(),
+    allowCustomModel: z.boolean().optional().default(false),
+    description: z.string().trim().max(500).nullable().optional(),
+  }),
+  responses: {
+    201: { description: "Profile created", schema: ModelProfileSchema },
+    400: { description: "Validation error" },
+    403: { description: "Forbidden" },
+    409: { description: "A profile with that name exists" },
+  },
+});
+
+const updateProfile = route({
+  method: "patch",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Update a model profile",
+  description:
+    "Changes the model, effort, custom-model flag or description; the name and harness are fixed. Omit a field to keep it; `effort: null` clears it. Applies to tasks claimed after the change. Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  params: z.object({ name: z.string() }),
+  body: z.object({
+    model: z.string().trim().min(1).optional(),
+    effort: ReasoningEffortSchema.nullable().optional(),
+    allowCustomModel: z.boolean().optional(),
+    description: z.string().trim().max(500).nullable().optional(),
+  }),
+  responses: {
+    200: { description: "Profile updated", schema: ModelProfileSchema },
+    400: { description: "Validation error" },
+    403: { description: "Forbidden" },
+    404: { description: "No profile with that name" },
+  },
+});
+
+const deleteProfile = route({
+  method: "delete",
+  path: "/api/model-profiles/{name}",
+  pattern: ["api", "model-profiles", null],
+  summary: "Delete a model profile",
+  description:
+    "Refused (409) for a shipped `<harness>-<tier>` seed (edit it instead; it would come back at the next boot), and while an agent has the profile as its default or a task holds it (unfinished, or superseded and still owed its resume). Operator only (the shared API key).",
+  tags: ["Models"],
+  rbac: { permission: "models.profiles.write" },
+  params: z.object({ name: z.string() }),
+  responses: {
+    200: { description: "Profile deleted", schema: z.object({ deleted: z.literal(true) }) },
+    403: { description: "Forbidden" },
+    404: { description: "No profile with that name" },
+    409: { description: "The profile is a seed or still in use" },
+  },
+});
+
+/** Why `harness` + `model` + `effort` is not a valid profile, or null. */
+async function profileValueError(input: {
+  harness: ProviderName;
+  model: string;
+  effort: ReasoningEffort | null | undefined;
+  allowCustomModel: boolean;
+}): Promise<string | null> {
+  const modelError = await explicitModelError({
+    model: input.model,
+    allowCustomModel: input.allowCustomModel,
+    harnessProvider: input.harness,
+  });
+  if (modelError) return modelError;
+  // The levels the harness and model accept (as PATCH /runtime checks them); a
+  // supported level may still be a transport no-op, like Opencode `off`. An
+  // alias is judged once it resolves.
+  if (
+    input.effort &&
+    !isAlias(input.model) &&
+    !supportedReasoningLevels(input.harness, input.model).includes(input.effort)
+  ) {
+    return `Effort "${input.effort}" is not supported by ${input.model} on ${input.harness}.`;
+  }
+  return null;
+}
+
+/** Gate a write on `models.profiles.write`; writes a 403 and returns false on denial. */
+async function canWriteProfiles(
+  req: IncomingMessage,
+  res: ServerResponse,
+  myAgentId: string | undefined,
+): Promise<boolean> {
+  const decision = can({
+    principal: await agentFirstPrincipal(req, myAgentId),
+    verb: "models.profiles.write",
+    resource: { kind: "none" },
+    source: "http",
+  });
+  if (!decision.allow) {
+    jsonError(res, "Writing model profiles requires the operator", 403);
+    return false;
+  }
+  return true;
+}
+
+export async function handleModelProfiles(
+  req: IncomingMessage,
+  res: ServerResponse,
+  pathSegments: string[],
+  queryParams: URLSearchParams,
+  myAgentId: string | undefined,
+): Promise<boolean> {
+  if (listProfiles.match(req.method, pathSegments)) {
+    const parsed = await listProfiles.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    listProfiles.respond(res, 200, {
+      profiles: await listModelProfiles({ harness: parsed.query.harness }),
+    });
+    return true;
+  }
+
+  if (getProfile.match(req.method, pathSegments)) {
+    const parsed = await getProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    const profile = await getModelProfileByName(parsed.params.name);
+    if (!profile) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    getProfile.respond(res, 200, profile);
+    return true;
+  }
+
+  if (createProfile.match(req.method, pathSegments)) {
+    const parsed = await createProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await canWriteProfiles(req, res, myAgentId))) return true;
+    const body = parsed.body;
+    const error = await profileValueError({ ...body, effort: body.effort ?? null });
+    if (error) {
+      jsonError(res, error, 400);
+      return true;
+    }
+    const created = await createModelProfile(body, {
+      userId: await resolveHttpAuditUserId(req, myAgentId),
+    });
+    if (!created) {
+      jsonError(res, `Model profile "${body.name}" already exists`, 409);
+      return true;
+    }
+    createProfile.respond(res, 201, created);
+    return true;
+  }
+
+  if (updateProfile.match(req.method, pathSegments)) {
+    const parsed = await updateProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await canWriteProfiles(req, res, myAgentId))) return true;
+    const current = await getModelProfileByName(parsed.params.name);
+    if (!current) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    const body = parsed.body;
+    const error = await profileValueError({
+      harness: current.harness,
+      model: body.model ?? current.model,
+      effort: body.effort === undefined ? current.effort : body.effort,
+      allowCustomModel: body.allowCustomModel ?? current.allowCustomModel,
+    });
+    if (error) {
+      jsonError(res, error, 400);
+      return true;
+    }
+    const updated = await updateModelProfile(current.name, body, {
+      userId: await resolveHttpAuditUserId(req, myAgentId),
+    });
+    if (!updated) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    updateProfile.respond(res, 200, updated);
+    return true;
+  }
+
+  if (deleteProfile.match(req.method, pathSegments)) {
+    const parsed = await deleteProfile.parse(req, res, pathSegments, queryParams);
+    if (!parsed) return true;
+    if (!(await canWriteProfiles(req, res, myAgentId))) return true;
+    const current = await getModelProfileByName(parsed.params.name);
+    if (!current) {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    if (current.seededFrom?.startsWith("tier:")) {
+      jsonError(
+        res,
+        `"${current.name}" is a shipped tier profile and comes back at the next boot; edit it instead.`,
+        409,
+      );
+      return true;
+    }
+    const refs = await modelProfileReferences(current.name);
+    if (refs.agentIds.length > 0 || refs.openTaskCount > 0) {
+      jsonError(
+        res,
+        `"${current.name}" is in use: default of ${refs.agentIds.length} agent(s), held by ${refs.openTaskCount} unfinished or awaiting-resume task(s).`,
+        409,
+      );
+      return true;
+    }
+    // The count above is for the message; the delete re-checks in the same
+    // statement (migration 220 trigger), so a reference written since is a 409.
+    const outcome = await deleteModelProfile(current.name);
+    if (outcome === "in-use") {
+      jsonError(
+        res,
+        `"${current.name}" is in use by a task or an agent default created just now.`,
+        409,
+      );
+      return true;
+    }
+    if (outcome === "missing") {
+      jsonError(res, "Model profile not found", 404);
+      return true;
+    }
+    deleteProfile.respond(res, 200, { deleted: true });
+    return true;
+  }
+
+  return false;
+}

package/src/http/page-proxy.ts

@@ -6,10 +6,8 @@ import { route } from "./route-def";
 import { jsonError } from "./utils";
 
 /**
- * `/@swarm/api/*` proxy. Cookie-gated equivalent of the artifact-sdk proxy
- * (src/artifact-sdk/server.ts:42-69), but lives on the MAIN API server and
- * authenticates via the page-session cookie instead of basic-auth + a per-
- * artifact tunnel.
+ * `/@swarm/api/*` proxy. Lives on the MAIN API server and authenticates via
+ * the page-session cookie.
  *
  * Flow:
  *   1. Browser hits `/@swarm/api/<rest>` from inside an iframe of `/p/:id`.

package/src/http/pages-public.ts

@@ -7,7 +7,7 @@
  *
  * Scope of THIS module (step-3):
  *   - `auth_mode === 'public'`: ungated. HTML responses inline-inject the
- *     `BROWSER_SDK_JS` constant from `src/artifact-sdk/browser-sdk.ts` (reused
+ *     `BROWSER_SDK_JS` constant from `src/pages/browser-sdk.ts` (reused
  *     verbatim — no token-injection hook on the client). SVG responses serve
  *     raw bytes with a restrictive CSP and no injected scripts. JSON responses
  *     302-redirect to the SPA `/pages/:id` route (the JSON renderer lives
@@ -23,9 +23,13 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { BROWSER_SDK_JS, SWARM_UI_JS } from "../artifact-sdk/browser-sdk";
-import { feedbackOverlayScripts, isPageFeedbackRequested } from "../artifact-sdk/feedback-overlay";
 import { getPage, incrementPageViewCount } from "../be/db";
+import { BROWSER_SDK_JS, SWARM_UI_JS } from "../pages/browser-sdk";
+import {
+  feedbackKeyGuardScript,
+  feedbackOverlayScripts,
+  isPageFeedbackRequested,
+} from "../pages/feedback-overlay";
 import { type Page, PageSchema } from "../types";
 import { getAppUrl, getConfiguredAppUrls } from "../utils/constants";
 import { getNodeEnv } from "../utils/node-env";
@@ -170,8 +174,8 @@ const PAGE_HEAD_DEFAULTS = `<base target="_blank">
   }
 </style>`;
 
-function injectBrowserSdk(html: string): string {
-  const injection = `${PAGE_HEAD_DEFAULTS}<script>${BROWSER_SDK_JS}</script><script>${SWARM_UI_JS}</script>`;
+function injectBrowserSdk(html: string, headFirst = ""): string {
+  const injection = `${headFirst}${PAGE_HEAD_DEFAULTS}<script>${BROWSER_SDK_JS}</script><script>${SWARM_UI_JS}</script>`;
   // Use the first occurrence of `<head>` (case-insensitive). A page that
   // doesn't have a `<head>` element (raw fragment) still gets the SDK at the
   // front of the document.
@@ -646,10 +650,12 @@ export async function handlePagesPublic(
   // text/html — inject SDK + serve. Append the self-print snippet when the
   // export button requested it, and the feedback overlay when
   // `?__swarm-feedback` is on (the overlay hides itself in print).
+  // The feedback key guard goes first in <head> so it runs before page scripts.
+  const feedback = isPageFeedbackRequested(queryParams);
   const html =
-    injectBrowserSdk(page.body) +
+    injectBrowserSdk(page.body, feedback ? feedbackKeyGuardScript() : "") +
     (wantsPrint ? PRINT_AUTOTRIGGER_SCRIPT : "") +
-    (isPageFeedbackRequested(queryParams) ? feedbackOverlayScripts(page.id) : "");
+    (feedback ? feedbackOverlayScripts(page.id) : "");
   const headers: Record<string, string> = {
     "Content-Type": "text/html; charset=utf-8",
     "Cache-Control": "no-store",

package/src/http/pages.ts

@@ -19,6 +19,7 @@ import {
   updatePage,
   withFavoriteFlags,
 } from "../be/db";
+import { getPageEditCounter } from "../be/db/page-versions";
 import { snapshotPage } from "../pages/version";
 import { resolveTemplate } from "../prompts/resolver";
 // Side-effect import: registers `task.page.feedback`.
@@ -227,7 +228,7 @@ const updatePageRoute = route({
 /**
  * POST /api/pages/:id/feedback — turn the element comments collected by the
  * in-page feedback overlay (`?__swarm-feedback`, see
- * `src/artifact-sdk/feedback-overlay.ts`) into one task for the lead. In the
+ * `src/pages/feedback-overlay.ts`) into one task for the lead. In the
  * dashboard the SPA calls it with its bearer for the page it shows. A page
  * opened directly reaches it through the `/@swarm/api/*` page proxy, which
  * pins `X-Page-Id` to the cookie's page, so a page can only file feedback on
@@ -482,17 +483,6 @@ function withShareUrls<T extends { id: string; slug: string }>(
   };
 }
 
-/**
- * Compute the page's "edit counter" — `MAX(page_versions.version) + 1`. Means
- * "this is the N-th edit since the page was created". After the first PUT the
- * value is 2 (one snapshot row → version 1 → counter becomes 2). This is the
- * value POST and PUT return as `version` on the wire.
- */
-async function pageEditCounter(pageId: string): Promise<number> {
-  const versions = await getPageVersions(pageId);
-  return versions.length > 0 ? versions[0]!.version + 1 : 1;
-}
-
 /**
  * Viewer and page-supplied text sits inside a `<page_feedback>` block in the
  * task prompt. Defuse any tag of that name so the text cannot close the block
@@ -843,7 +833,7 @@ export async function handlePages(
     updatePageRoute.respond(res, 200, {
       id: updated.id,
       key: updated.key,
-      version: await pageEditCounter(updated.id),
+      version: await getPageEditCounter(updated.id),
     });
     return true;
   }

package/src/http/poll.ts

@@ -19,7 +19,6 @@ import {
   getTaskAttachments,
   getTaskById,
   getUnassignedTaskIdsForAgent,
-  getUserById,
   hasCapacity,
   isExtensionAgent,
   recordBudgetRefusalNotification,
@@ -27,7 +26,6 @@ import {
   updateAgentStatusFromCapacity,
   upsertChannelActivityCursor,
 } from "../be/db";
-import { renderIdentity, resolveIdentity } from "../be/identity";
 import {
   parseModelTierOverridesHeader,
   recordClaimModelResolution,
@@ -37,19 +35,16 @@ import { poolTaskRunsOnHarness } from "../be/model-validation";
 import { getRuntimeInstanceById, touchRuntimeInstance } from "../be/multi-runtime";
 import { hasCapability } from "../server";
 import { fetchChannelActivity } from "../slack/channel-activity";
+import { type TaskModelPinFields, taskModelPin } from "../tasks/model-pin";
 import { emitTaskTelemetry, resolveTriggerSurface } from "../telemetry-trigger";
-import {
-  AgentTaskSchema,
-  BudgetRefusedTriggerSchema,
-  TaskAttachmentSchema,
-  UserCommsPrefsSchema,
-  UserSchema,
-} from "../types";
+import { AgentTaskSchema, BudgetRefusedTriggerSchema, TaskAttachmentSchema } from "../types";
 import { ensure } from "../utils/business-use";
 import { isLeadChannelMonitoringEnabled } from "../utils/lead-monitor-channels";
 import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
-import { getUserCommsPrefs } from "../utils/requester-comms";
+import { getRequestAuth, type HttpRequestAuth } from "../utils/request-auth-context";
 import { isRuntimePoolsEnabled } from "../utils/runtime-pools-flag";
+import { readsRepoSecrets } from "./config";
+import { buildTaskRequestedBy, TaskRequestedBySchema } from "./requested-by";
 import { route, runtimeInstanceHeader } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -100,27 +95,11 @@ const PollTriggerAttachmentSchema = TaskAttachmentSchema.pick({
   sizeBytes: true,
 });
 
-// Requester projection sent on `task_assigned` triggers — either the resolved
-// user's identity fields, or (when no `requestedByUserId` is recorded) just a
-// rendered `name` for the UNKNOWN-identity sentinel.
-const PollRequestedBySchema = UserSchema.pick({
-  id: true,
-  name: true,
-  email: true,
-  role: true,
-  notes: true,
-}).extend({
-  // Absent for the UNKNOWN-identity sentinel (Slack-only requester, no users row).
-  id: z.string().optional(),
-  // Structured communication preferences from `users.metadata.comms`.
-  comms: UserCommsPrefsSchema.optional(),
-});
-
 const PollTaskOfferedTriggerSchema = z.object({
   type: z.literal("task_offered"),
   taskId: z.string(),
   task: AgentTaskSchema,
-  requestedBy: PollRequestedBySchema.optional(),
+  requestedBy: TaskRequestedBySchema.optional(),
 });
 
 const PollTaskAssignedTriggerSchema = z.object({
@@ -132,7 +111,7 @@ const PollTaskAssignedTriggerSchema = z.object({
   task: AgentTaskSchema.extend({
     attachments: z.array(PollTriggerAttachmentSchema),
   }),
-  requestedBy: PollRequestedBySchema.optional(),
+  requestedBy: TaskRequestedBySchema.optional(),
 });
 
 // `budget_refused` reuses the canonical `BudgetRefusedTriggerSchema` entity
@@ -204,38 +183,6 @@ const pollTriggers = route({
 const CHANNEL_ACTIVITY_INTERVAL_MS = 60_000; // Check at most once per 60s
 let lastChannelActivityCheckAt = 0;
 
-function getRequesterNotes(notes: string | undefined): string | undefined {
-  return typeof notes === "string" && notes.trim().length > 0 ? notes : undefined;
-}
-
-/**
- * Resolve the requester projection for a task trigger. If the task carries a
- * machine-recorded external id (today: the Slack user field) but no
- * requestedByUserId, render the explicit UNKNOWN sentinel instead of silently
- * omitting the section: never a substituted human (Rule 33 /
- * provenance-or-silence).
- */
-async function buildTriggerRequestedBy(task: {
-  requestedByUserId?: string | null;
-  slackUserId?: string | null;
-}): Promise<z.infer<typeof PollRequestedBySchema> | undefined> {
-  const user = task.requestedByUserId ? await getUserById(task.requestedByUserId) : undefined;
-  if (user) {
-    return {
-      id: user.id,
-      name: user.name,
-      email: user.email,
-      role: user.role,
-      notes: getRequesterNotes(user.notes),
-      comms: getUserCommsPrefs(user),
-    };
-  }
-  if (task.slackUserId) {
-    return { name: renderIdentity(await resolveIdentity("slack", task.slackUserId)) };
-  }
-  return undefined;
-}
-
 /**
  * Slim attachment projection for the `task_assigned` poll trigger — just
  * enough (id, name, mimeType, sizeBytes) for the worker to build a one-shot
@@ -256,16 +203,40 @@ async function attachmentsForTrigger(
 /**
  * Claim-time model resolution (runbooks/model-tiers.md). Never blocks a claim:
  * a resolution failure leaves the worker on its own local resolution.
+ *
+ * The trigger's `model` is the task's own pin, not the column: a re-claimed
+ * row carries the model its previous session reported, and the worker treats
+ * `task.model` as a pin that beats the agent's current MODEL_OVERRIDE. The
+ * previous claim record is overwritten for the same reason.
  */
 async function claimModelFields(
-  task: { id: string; model?: string | null; modelTier?: string | null },
-  agent: Parameters<typeof recordClaimModelResolution>[1],
-): Promise<Awaited<ReturnType<typeof recordClaimModelResolution>>> {
+  task: TaskModelPinFields & {
+    id: string;
+    profile?: string | null;
+    effort?: string | null;
+    vcsRepo?: string | null;
+  },
+  agent: Parameters<typeof recordClaimModelResolution>[1] & { isLead?: boolean },
+  auth: HttpRequestAuth | null,
+): Promise<Awaited<ReturnType<typeof recordClaimModelResolution>> & { model: string | undefined }> {
+  const pin = taskModelPin(task);
+  const cleared = {
+    model: pin,
+    resolvedModel: undefined,
+    modelSource: undefined,
+    modelAlias: undefined,
+    resolvedProfile: undefined,
+  };
   try {
-    return await recordClaimModelResolution(task, agent);
+    return {
+      ...cleared,
+      ...(await recordClaimModelResolution({ ...task, model: pin }, agent, {
+        includeRepoSecrets: readsRepoSecrets(auth, agent),
+      })),
+    };
   } catch (error) {
     console.warn(`[/api/poll] model resolution failed for task ${task.id}:`, error);
-    return {};
+    return cleared;
   }
 }
 
@@ -422,7 +393,7 @@ export async function handlePoll(
           const claimedTask = await claimOfferedTask(firstOfferedTask.id, myAgentId);
           if (claimedTask) {
             await recordRuntimeTask(claimedTask.id);
-            const offeredRequestedBy = await buildTriggerRequestedBy(claimedTask);
+            const offeredRequestedBy = await buildTaskRequestedBy(claimedTask);
             return {
               trigger: {
                 type: "task_offered",
@@ -519,8 +490,8 @@ export async function handlePoll(
             });
 
             // Resolve requesting user if available (UNKNOWN sentinel handling
-            // lives in buildTriggerRequestedBy).
-            const assignedRequestedBy = await buildTriggerRequestedBy(pendingTask);
+            // lives in buildTaskRequestedBy).
+            const assignedRequestedBy = await buildTaskRequestedBy(pendingTask);
             // The surface that started the whole chain, so the worker can tag
             // its session events with it (workers cannot read the task tree).
             const assignedTriggerSurface = await resolveTriggerSurface(
@@ -535,7 +506,7 @@ export async function handlePoll(
                 triggerSurface: assignedTriggerSurface,
                 task: {
                   ...pendingTask,
-                  ...(await claimModelFields(pendingTask, agent)),
+                  ...(await claimModelFields(pendingTask, agent, getRequestAuth(req))),
                   status: "in_progress",
                   attachments: await attachmentsForTrigger(pendingTask.id),
                 },
@@ -667,7 +638,7 @@ export async function handlePoll(
                     agentId: myAgentId,
                   });
                 });
-                const claimedRequestedBy = await buildTriggerRequestedBy(claimed);
+                const claimedRequestedBy = await buildTaskRequestedBy(claimed);
                 const claimedTriggerSurface = await resolveTriggerSurface(
                   claimed.id,
                   claimed.source,
@@ -679,7 +650,7 @@ export async function handlePoll(
                     triggerSurface: claimedTriggerSurface,
                     task: {
                       ...claimed,
-                      ...(await claimModelFields(claimed, agent)),
+                      ...(await claimModelFields(claimed, agent, getRequestAuth(req))),
                       attachments: await attachmentsForTrigger(claimed.id),
                     },
                     ...(claimedRequestedBy && { requestedBy: claimedRequestedBy }),

package/src/http/requested-by.ts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { getUserById } from "../be/db";
+import { renderIdentity, resolveIdentity } from "../be/identity";
+import { UserCommsPrefsSchema, UserSchema } from "../types";
+import { getUserCommsPrefs } from "../utils/requester-comms";
+
+// Requester projection sent with a task to the worker that runs it (poll
+// triggers, paused-task resume) — either the resolved user's identity fields,
+// or (when no `requestedByUserId` is recorded) just a rendered `name` for the
+// UNKNOWN-identity sentinel.
+export const TaskRequestedBySchema = UserSchema.pick({
+  id: true,
+  name: true,
+  email: true,
+  role: true,
+  notes: true,
+}).extend({
+  // Absent for the UNKNOWN-identity sentinel (Slack-only requester, no users row).
+  id: z.string().optional(),
+  // Structured communication preferences from `users.metadata.comms`.
+  comms: UserCommsPrefsSchema.optional(),
+});
+
+function getRequesterNotes(notes: string | undefined): string | undefined {
+  return typeof notes === "string" && notes.trim().length > 0 ? notes : undefined;
+}
+
+/**
+ * Resolve the requester projection for a task. If the task carries a
+ * machine-recorded external id (today: the Slack user field) but no
+ * requestedByUserId, render the explicit UNKNOWN sentinel instead of silently
+ * omitting the section: never a substituted human (Rule 33 /
+ * provenance-or-silence).
+ */
+export async function buildTaskRequestedBy(task: {
+  requestedByUserId?: string | null;
+  slackUserId?: string | null;
+}): Promise<z.infer<typeof TaskRequestedBySchema> | undefined> {
+  const user = task.requestedByUserId ? await getUserById(task.requestedByUserId) : undefined;
+  if (user) {
+    return {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      role: user.role,
+      notes: getRequesterNotes(user.notes),
+      comms: getUserCommsPrefs(user),
+    };
+  }
+  if (task.slackUserId) {
+    return { name: renderIdentity(await resolveIdentity("slack", task.slackUserId)) };
+  }
+  return undefined;
+}

package/src/http/script-runs.ts

@@ -611,7 +611,7 @@ export async function handleScriptRuns(
     if (!parsed) return true;
     const result = await executeRawLlm(parsed.body);
     if (result.status === "failed") {
-      json(res, { error: result.error }, 500);
+      jsonError(res, result.error, 500);
       return true;
     }
     rawLlmRoute.respond(res, 200, result.output);