@desplega.ai/agent-swarm 1.173.0 → 2.0.0

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,14 @@ 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 { isRuntimePoolsEnabled } from "../utils/runtime-pools-flag";
+import { buildTaskRequestedBy, TaskRequestedBySchema } from "./requested-by";
 import { route, runtimeInstanceHeader } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -100,27 +93,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 +109,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 +181,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 +201,31 @@ 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 },
+  task: TaskModelPinFields & { id: string },
   agent: Parameters<typeof recordClaimModelResolution>[1],
-): Promise<Awaited<ReturnType<typeof recordClaimModelResolution>>> {
+): Promise<Awaited<ReturnType<typeof recordClaimModelResolution>> & { model: string | undefined }> {
+  const pin = taskModelPin(task);
+  const cleared = {
+    model: pin,
+    resolvedModel: undefined,
+    modelSource: undefined,
+    modelAlias: undefined,
+  };
   try {
-    return await recordClaimModelResolution(task, agent);
+    return {
+      ...cleared,
+      ...(await recordClaimModelResolution({ ...task, model: pin }, agent)),
+    };
   } catch (error) {
     console.warn(`[/api/poll] model resolution failed for task ${task.id}:`, error);
-    return {};
+    return cleared;
   }
 }
 
@@ -422,7 +382,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 +479,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(
@@ -667,7 +627,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,

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/scripts.ts

@@ -765,6 +765,7 @@ export async function handleScripts(
       runtimeInstanceId,
       egressSecrets: credentials.egressSecrets,
       failedBindings: credentials.failedBindings,
+      userConfig: credentials.userConfig,
       apiConnections: getScriptApiConnectionDescriptors({ agentId: agent.id }),
       mcpConnections: getScriptMcpConnectionDescriptors({ agentId: agent.id }),
     });

package/src/http/stats.ts

@@ -3,7 +3,6 @@ import { z } from "zod";
 import {
   getAgentStatusCounts,
   getAllLogs,
-  getAllServices,
   getConcurrentContext,
   getLogsByAgentId,
   getScheduledTasks,
@@ -14,7 +13,7 @@ import {
 import { getDbRetentionStats } from "../be/db-retention";
 import { isSteeringEnabled } from "../be/steering";
 import type { AgentLog } from "../types";
-import { AgentLogSchema, ScheduledTaskSchema, ServiceSchema } from "../types";
+import { AgentLogSchema, ScheduledTaskSchema } from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { isMultiRuntimeEnabled } from "../utils/multi-runtime";
 import { resolveHttpFavoriteOwner } from "./favorite-owner";
@@ -166,22 +165,6 @@ const getMetrics = route({
   },
 });
 
-const listServices = route({
-  method: "get",
-  path: "/api/services",
-  pattern: ["api", "services"],
-  summary: "List all registered services",
-  tags: ["Stats"],
-  query: z.object({
-    status: z.string().optional(),
-    agentId: z.string().optional(),
-    name: z.string().optional(),
-  }),
-  responses: {
-    200: { description: "Service list", schema: z.object({ services: z.array(ServiceSchema) }) },
-  },
-});
-
 const listScheduledTasks = route({
   method: "get",
   path: "/api/scheduled-tasks",
@@ -295,18 +278,6 @@ export async function handleStats(
     return true;
   }
 
-  if (listServices.match(req.method, pathSegments)) {
-    const parsed = await listServices.parse(req, res, pathSegments, queryParams);
-    if (!parsed) return true;
-    const services = await getAllServices({
-      status: (parsed.query.status as import("../types").ServiceStatus) || undefined,
-      agentId: parsed.query.agentId || undefined,
-      name: parsed.query.name || undefined,
-    });
-    listServices.respond(res, 200, { services });
-    return true;
-  }
-
   if (listScheduledTasks.match(req.method, pathSegments)) {
     const parsed = await listScheduledTasks.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;

package/src/http/tasks.ts

@@ -45,6 +45,7 @@ import {
 import { getTaskCitations, TaskCitationSchema } from "../be/task-citations";
 import { findUserById } from "../be/users";
 import { can, type RbacPrincipal, type RbacResource } from "../rbac";
+import { chatThreadOfContextKey } from "../tasks/context-key";
 import { TaskCreationBlockedError } from "../tasks/errors";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { guardTerminalTaskResultWrite } from "../tasks/terminal-result-guard";
@@ -76,6 +77,7 @@ import { ensure } from "../utils/business-use";
 import { getRequestAuth } from "../utils/request-auth-context";
 import { scrubSecrets } from "../utils/secret-scrubber";
 import { rejectGuest } from "./request-principal";
+import { buildTaskRequestedBy, TaskRequestedBySchema } from "./requested-by";
 import { route } from "./route-def";
 import { jsonError, parseBody } from "./utils";
 
@@ -110,6 +112,7 @@ const AgentTaskSummarySchema = AgentTaskSchema.pick({
   modelSource: true,
   modelAlias: true,
   effort: true,
+  resolvedEffort: true,
   provider: true,
   requestedByUserId: true,
   progress: true,
@@ -308,6 +311,10 @@ const createTask = route({
       description:
         "Validation error, an unknown `model` (set `allowCustomModel` to store a custom id), or agentId/offeredTo targets an extension identity",
     },
+    403: {
+      description:
+        "An agent caller names a parentTaskId it neither owns nor created, or a non-lead agent binds the task to a chat thread",
+    },
     422: {
       description: "Task creation blocked by an extension",
       schema: z.object({
@@ -357,6 +364,8 @@ const updateSession = route({
       claudeSessionId: z.string().min(1),
       provider: ProviderNameSchema.exclude(["devin"]).optional(),
       model: z.string().optional(),
+      // Effort the session runs at; null when the harness default applies.
+      effort: ReasoningEffortSchema.nullable().optional(),
       providerMeta: z.object({ transport: z.enum(["cli", "sdk"]).optional() }).optional(),
       harnessVariant: z.string().optional(),
       harnessVariantMeta: z.record(z.string(), z.unknown()).optional(),
@@ -592,7 +601,14 @@ const listPausedTasks = route({
     200: {
       description: "Paused task list",
       schema: z.object({
-        tasks: z.array(AgentTaskSchema.extend({ attachments: z.array(TaskAttachmentSchema) })),
+        tasks: z.array(
+          AgentTaskSchema.extend({
+            attachments: z.array(TaskAttachmentSchema),
+            // Same requester projection a fresh task_assigned trigger carries,
+            // so a resumed session gets the same requester-profile prompt.
+            requestedBy: TaskRequestedBySchema.optional(),
+          }),
+        ),
       }),
     },
   },
@@ -954,6 +970,41 @@ export async function handleTasks(
     const parentTask = parsed.body.parentTaskId
       ? await getTaskById(parsed.body.parentTaskId)
       : null;
+    // The child inherits the parent's thread context, so an agent caller must own or
+    // have created the parent. Operator and user callers keep their access.
+    const principal = await resolveTaskWritePrincipal(req, myAgentId);
+    if (
+      parentTask &&
+      !can({
+        principal,
+        verb: "task.parent.attach",
+        resource: {
+          kind: "task",
+          taskId: parentTask.id,
+          requestedByUserId: parentTask.requestedByUserId,
+          creatorAgentId: parentTask.creatorAgentId,
+          agentId: parentTask.agentId,
+        },
+        source: "http",
+      }).allow
+    ) {
+      jsonError(res, `You don't have context for parent task ${parentTask.id}.`, 403);
+      return true;
+    }
+    // A chat-sdk contextKey binds the task to a chat thread that its assignee and creator
+    // may then read and post to. An agent may only name a thread other than the parent's
+    // with the lead's chat post permission.
+    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;
+    }
     let assetKey: string | undefined;
     try {
       const inheritedKey = parentTask?.key;
@@ -1083,6 +1134,7 @@ export async function handleTasks(
       parsed.body.model,
       "harnessVariant" in parsed.body ? parsed.body.harnessVariant : undefined,
       "harnessVariantMeta" in parsed.body ? parsed.body.harnessVariantMeta : undefined,
+      "effort" in parsed.body ? parsed.body.effort : undefined,
     );
     if (!task) {
       jsonError(res, "Task not found", 404);
@@ -1667,10 +1719,14 @@ export async function handleTasks(
     }
     const pausedTasks = await getPausedTasksForAgent(myAgentId);
     const tasks = await Promise.all(
-      pausedTasks.map(async (task) => ({
-        ...task,
-        attachments: await getTaskAttachments(task.id),
-      })),
+      pausedTasks.map(async (task) => {
+        const requestedBy = await buildTaskRequestedBy(task);
+        return {
+          ...task,
+          attachments: await getTaskAttachments(task.id),
+          ...(requestedBy && { requestedBy }),
+        };
+      }),
     );
     listPausedTasks.respond(res, 200, { tasks });
     return true;

package/src/http/utils.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { getActiveTaskCount } from "../be/db";
 import type { SwarmSpan } from "../otel";
 import { isEnvFlagEnabled } from "../utils/env-flag";
+import { getNodeEnv } from "../utils/node-env";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
 export function duplicateGuardedQueryKey(query: URLSearchParams): string | undefined {
@@ -41,6 +42,18 @@ function getAllowedOrigins(): string[] {
     .filter(Boolean);
 }
 
+/**
+ * Loopback origins on any port are trusted in local development
+ * (`NODE_ENV=development`, set by `start:http` and `dev:http`). The dashboard
+ * dev server, Playwright, or a second worktree pick arbitrary ports, and every
+ * loopback page already runs on the developer's machine. The production binary
+ * and the Docker image run without NODE_ENV, so this never applies there.
+ */
+function isDevLoopbackOrigin(origin: string): boolean {
+  if (getNodeEnv() !== "development") return false;
+  return /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d{1,5})?$/.test(origin);
+}
+
 /**
  * Decide whether `origin` may receive credentialed CORS headers.
  * Unset or blank uses the built-in hosted/dev allowlist. Exact entries retain
@@ -50,6 +63,7 @@ function getAllowedOrigins(): string[] {
  * Bare `*`, `https://*`, other wildcard positions, and non-origin URLs are ignored.
  */
 function originAllowedForCredentials(origin: string): boolean {
+  if (isDevLoopbackOrigin(origin)) return true;
   return getAllowedOrigins().some((entry) => {
     if (!entry.includes("*")) return entry === origin;