@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.173.0",
+  "version": "2.1.0",
   "description": "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   "keywords": [
     "agent-swarm.dev",
@@ -168,11 +168,6 @@
     "docs:mcp": "bun scripts/generate-mcp-docs.ts",
     "docs:openapi": "bun scripts/generate-openapi.ts",
     "docs:business-use": "bun scripts/generate-business-use-docs.ts",
-    "pm2-start": "pm2 start ecosystem.config.cjs",
-    "pm2-stop": "pm2 stop ecosystem.config.cjs",
-    "pm2-restart": "pm2 restart ecosystem.config.cjs",
-    "pm2-logs": "pm2 logs swarm-api swarm-ui swarm-lead swarm-worker",
-    "pm2-status": "pm2 status swarm-api swarm-ui swarm-lead swarm-worker",
     "seed": "bun scripts/seed.ts",
     "seed:clean": "bun scripts/seed.ts --clean",
     "seed:people": "bun scripts/seed-people.ts",
@@ -180,16 +175,17 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.10",
-    "@desplega.ai/slack-mock": "^0.4.0",
+    "@desplega.ai/slack-mock": "^0.4.1",
     "@desplega/model-catalog": "workspace:*",
     "@desplega/model-routing": "workspace:*",
     "@faker-js/faker": "^10.4.0",
-    "@opencode/plugin": "2.0.29",
-    "@opencode/sdk": "2.0.29",
+    "@opencode/plugin": "2.0.31",
+    "@opencode/sdk": "2.0.31",
     "@oxlint/plugins": "1.78.0",
     "@types/bun": "latest",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "dependency-cruiser": "^18.0.0",
+    "happy-dom": "^20.14.5",
     "konsistent": "1.0.0-beta.1",
     "openapi-typescript": "^7",
     "oxlint": "1.78.0",
@@ -203,15 +199,18 @@
     "bun": ">=1.3.12"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.8.0",
+    "@agentclientprotocol/sdk": "1.9.0",
     "@ai-sdk/openai": "^3.0.41",
-    "@anthropic-ai/claude-agent-sdk": "0.3.299",
-    "@anthropic-ai/sdk": "^0.133.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.301",
+    "@anthropic-ai/sdk": "^0.135.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",
+    "@chat-adapter/discord": "4.41.1",
+    "@chat-adapter/slack": "4.41.1",
+    "@chat-adapter/teams": "4.41.1",
+    "@chat-adapter/telegram": "4.41.1",
     "@cursor/sdk": "1.0.37",
     "@desplega.ai/business-use": "^0.4.2",
-    "@desplega.ai/localtunnel": "^2.2.0",
     "@earendil-works/pi-agent-core": "^1.2.0",
     "@earendil-works/pi-ai": "^1.2.0",
     "@earendil-works/pi-coding-agent": "^1.2.0",
@@ -219,7 +218,7 @@
     "@jitl/quickjs-singlefile-mjs-release-sync": "0.32.0",
     "@linear/sdk": "^77.0.0",
     "@modelcontextprotocol/sdk": "1.31.0",
-    "@openai/codex": "0.162.1",
+    "@openai/codex": "0.163.0",
     "@openfort/openfort-node": "^0.9.1",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.218.0",
@@ -230,15 +229,16 @@
     "@opentelemetry/sdk-node": "^0.218.0",
     "@opentelemetry/semantic-conventions": "^1.41.1",
     "@slack/bolt": "^4.6.0",
+    "@slack/web-api": "7.13.0",
     "@types/react": "^19.2.7",
     "@x402/core": "^2.5.0",
     "@x402/evm": "^2.5.0",
     "@x402/fetch": "^2.5.0",
     "ai": "^6.0.116",
+    "chat": "4.41.1",
     "cron-parser": "^5.4.0",
     "date-fns": "^4.1.0",
     "e2b": "2.26.0",
-    "hono": "^4.12.3",
     "ink": "^6.5.1",
     "oauth4webapi": "^3.8.5",
     "openai": "^6.22.0",

package/src/agentmail/handlers.ts

@@ -91,32 +91,42 @@ function extractNameFromField(from: string): string | undefined {
 }
 
 /**
- * Check if an inbox domain is allowed by the filter.
- * Returns true if no filter is set or the inbox domain matches.
+ * Check an email address against comma-separated filter entries.
+ * An entry containing "@" matches that exact address; a bare entry matches any
+ * address on that domain. Comparison is case-insensitive.
+ */
+function matchesAddressFilter(email: string, filter: string): boolean {
+  const address = email.trim().toLowerCase();
+  const domain = address.split("@")[1];
+  if (!domain) return false;
+  return filter
+    .split(",")
+    .map((entry) => entry.trim().toLowerCase())
+    .some((entry) => (entry.includes("@") ? entry === address : entry === domain));
+}
+
+/**
+ * Check if an inbox address is allowed by the filter (full addresses or domains).
+ * Returns true if no filter is set or the inbox matches an entry.
  */
 export function isInboxAllowed(inboxId: string, filter: string | undefined): boolean {
   if (!filter) return true;
-  const allowedDomains = filter.split(",").map((d) => d.trim().toLowerCase());
-  const inboxDomain = inboxId.split("@")[1]?.toLowerCase();
-  return !!inboxDomain && allowedDomains.includes(inboxDomain);
+  return matchesAddressFilter(inboxId, filter);
 }
 
 /**
- * Check if a sender domain is allowed by the filter.
- * Returns true if no filter is set or at least one sender domain matches.
+ * Check if a sender address is allowed by the filter (full addresses or domains).
+ * Returns true if no filter is set or at least one sender matches an entry.
  */
 export function isSenderAllowed(
   from: AgentMailMessage["from_"],
   filter: string | undefined,
 ): boolean {
   if (!filter) return true;
-  const allowedDomains = filter.split(",").map((d) => d.trim().toLowerCase());
   const fromAddresses = Array.isArray(from) ? from : [from || ""];
   return fromAddresses.some((addr) => {
     const emailMatch = addr.match(/<([^>]+)>/);
-    const email = emailMatch?.[1] ?? addr;
-    const domain = email.split("@")[1]?.toLowerCase();
-    return !!domain && allowedDomains.includes(domain);
+    return matchesAddressFilter(emailMatch?.[1] ?? addr, filter);
   });
 }
 

package/src/apps/definition.ts

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { listScriptConnections } from "../be/script-connections";
 import { getScriptById } from "../be/scripts/db";
 import { getSavedScriptOwnerAgentId } from "../be/scripts/run-saved";
+import { checkQuickJSCompat, quickJSCompatWarnings } from "../scripts-runtime/quickjs-compat";
 import catalog from "./catalog.generated.json";
 import {
   crossPageDefinitionIssues,
@@ -592,6 +593,21 @@ export function collectScriptReferences(definition: unknown): Map<string, string
   return references;
 }
 
+/**
+ * Advisory quickjs compatibility warnings for every script that the
+ * definition's actions and sync sources run. Never a validation issue.
+ */
+export async function scriptCompatWarnings(definition: unknown): Promise<string[]> {
+  const warnings: string[] = [];
+  for (const [scriptId, paths] of collectScriptReferences(definition)) {
+    const script = await getScriptById(scriptId);
+    if (!script) continue;
+    const report = checkQuickJSCompat(script.source, { fsMode: script.fsMode });
+    warnings.push(...quickJSCompatWarnings(report, paths.join(", ")));
+  }
+  return warnings;
+}
+
 /**
  * Is this agent-scoped script foreign to the writing principal? Operators
  * (no writer identity at all) may wire anything; an agent may wire its own;

package/src/azure-devops/api.ts

@@ -3,6 +3,7 @@
  * and resolving the bot identity behind the PAT. Uses raw fetch, no SDK.
  */
 
+import { scrubSecrets } from "../utils/secret-scrubber";
 import {
   getAzureDevOpsOrgUrl,
   getAzureDevOpsToken,
@@ -163,7 +164,9 @@ export async function likeAzureDevOpsComment(
   try {
     const resp = await fetch(url, { method: "POST", headers: headers() });
     if (!resp.ok) {
-      console.error(`[AzureDevOps] Failed to like comment: ${resp.status} ${await resp.text()}`);
+      console.error(
+        `[AzureDevOps] Failed to like comment: ${resp.status} ${scrubSecrets(await resp.text())}`,
+      );
     }
   } catch (err) {
     console.error(`[AzureDevOps] Error liking comment:`, err);
@@ -189,9 +192,56 @@ export async function postAzureDevOpsPullRequestComment(
       }),
     });
     if (!resp.ok) {
-      console.error(`[AzureDevOps] Failed to post comment: ${resp.status} ${await resp.text()}`);
+      console.error(
+        `[AzureDevOps] Failed to post comment: ${resp.status} ${scrubSecrets(await resp.text())}`,
+      );
     }
   } catch (err) {
     console.error(`[AzureDevOps] Error posting comment:`, err);
   }
 }
+
+/** One JSON Patch operation on a work item. */
+export interface WorkItemFieldOp {
+  op: "add" | "replace";
+  path: string; // e.g. "/fields/System.State"
+  value: unknown;
+}
+
+/**
+ * Update work-item fields with one JSON Patch call. Returns whether it
+ * succeeded; failures are logged, never thrown, since callers are
+ * fire-and-forget lifecycle mirrors. The project segment is optional here.
+ * @see https://learn.microsoft.com/rest/api/azure/devops/wit/work-items/update
+ */
+export async function updateWorkItemFields(
+  orgBaseUrl: string,
+  workItemId: number,
+  ops: WorkItemFieldOp[],
+): Promise<boolean> {
+  const orgUrl = credentialedOrgUrl(orgBaseUrl);
+  if (!orgUrl) return false;
+  try {
+    const resp = await fetch(
+      `${orgUrl}/_apis/wit/workitems/${workItemId}?api-version=${API_VERSION}`,
+      {
+        method: "PATCH",
+        headers: { ...headers(), "Content-Type": "application/json-patch+json" },
+        body: JSON.stringify(ops),
+        redirect: "error",
+      },
+    );
+    if (!resp.ok) {
+      console.error(
+        `[AzureDevOps] Failed to update work item #${workItemId}: ${resp.status} ${scrubSecrets(await resp.text())}`,
+      );
+    }
+    return resp.ok;
+  } catch (err) {
+    console.error(
+      `[AzureDevOps] Error updating work item #${workItemId}:`,
+      scrubSecrets(err instanceof Error ? err.message : String(err)),
+    );
+    return false;
+  }
+}

package/src/azure-devops/boards-sync.ts

@@ -37,6 +37,7 @@ import { azureDevOpsWorkItemContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import type { TrackerSync } from "../tracker/types";
 import { isTerminalTaskStatus } from "../types";
+import { workflowEventBus } from "../workflows/event-bus";
 import { resolveAzureDevOpsBotIdentity } from "./api";
 import {
   AZURE_DEVOPS_BOT_NAME,
@@ -561,7 +562,7 @@ export async function handleWorkItemUpdated(event: WorkItemUpdatedEvent): Promis
   const org = orgFor(event);
   if (!org) return dropUntrustedOrg(event.eventType);
 
-  return await handleDelivery(org, event.id, update.workItemId, async () => {
+  const routeAssignment = async (): Promise<HandlerResult> => {
     const bot = await resolveBot(org.url);
     if (!isBotString(change.newValue, bot) || isBotString(change.oldValue, bot)) {
       return { created: false };
@@ -579,6 +580,21 @@ export async function handleWorkItemUpdated(event: WorkItemUpdatedEvent): Promis
       },
       "assigned",
     );
+  };
+
+  return await handleDelivery(org, event.id, update.workItemId, async () => {
+    const result = await routeAssignment();
+    // Published inside the receipt and lock so a retried delivery cannot repeat it.
+    workflowEventBus.emit("azure-devops.work_item.assigned", {
+      work_item_id: update.workItemId,
+      title: update.revision.fields["System.Title"],
+      project: update.revision.fields["System.TeamProject"],
+      action: "assigned",
+      assigned_to: change.newValue,
+      previous_assignee: change.oldValue,
+      user_login: update.revisedBy?.uniqueName ?? update.revisedBy?.id,
+    });
+    return result;
   });
 }
 
@@ -598,31 +614,45 @@ export async function handleWorkItemCommented(
   const org = orgFor(event);
   if (!org) return dropUntrustedOrg(event.eventType);
 
+  const routeComment = async (): Promise<HandlerResult> => {
+    const bot = await resolveBot(org.url);
+    const actor = parseIdentityString(item.fields["System.ChangedBy"]);
+    if (isBotIdentity(actor, bot)) return { created: false };
+
+    const { mentioned, text } = inspectMention(item.fields["System.History"], bot);
+    if (!mentioned) return { created: false };
+
+    return await routeToTask(
+      {
+        eventId: event.id,
+        eventType: event.eventType,
+        workItemId: item.id,
+        fields: item.fields,
+        org,
+        actor,
+      },
+      "mentioned_comment",
+      text,
+    );
+  };
+
   const commentKey = ref ? `comment:${trackerKey(org, item.id)}:${ref.commentId}` : undefined;
   return await handleDelivery(
     org,
     event.id,
     item.id,
     async () => {
-      const bot = await resolveBot(org.url);
-      const actor = parseIdentityString(item.fields["System.ChangedBy"]);
-      if (isBotIdentity(actor, bot)) return { created: false };
-
-      const { mentioned, text } = inspectMention(item.fields["System.History"], bot);
-      if (!mentioned) return { created: false };
-
-      return await routeToTask(
-        {
-          eventId: event.id,
-          eventType: event.eventType,
-          workItemId: item.id,
-          fields: item.fields,
-          org,
-          actor,
-        },
-        "mentioned_comment",
-        text,
-      );
+      const result = await routeComment();
+      // Published inside the receipt and lock so a retried delivery cannot repeat it.
+      workflowEventBus.emit("azure-devops.work_item.commented", {
+        work_item_id: item.id,
+        title: item.fields["System.Title"],
+        project: item.fields["System.TeamProject"],
+        action: "commented",
+        comment: item.fields["System.History"],
+        user_login: item.fields["System.ChangedBy"],
+      });
+      return result;
     },
     commentKey,
   );

package/src/azure-devops/index.ts

@@ -30,6 +30,7 @@ export {
   handlePullRequestCommented,
   handlePullRequestCreated,
 } from "./handlers";
+export { initAzureDevOpsOutbound, teardownAzureDevOpsOutbound } from "./outbound";
 export type {
   AzureDevOpsWebhookEvent,
   PullRequestCommentedEvent,

package/src/azure-devops/outbound.ts

@@ -0,0 +1,95 @@
+import { getDbClient } from "../be/db";
+import { getTrackerSync } from "../be/db-queries/tracker";
+import { onTaskStarted } from "../be/task-lifecycle-events";
+import type { AgentTask } from "../types";
+import { scrubSecrets } from "../utils/secret-scrubber";
+import { workflowEventBus } from "../workflows/event-bus";
+import { updateWorkItemFields } from "./api";
+
+const PROVIDER = "azure-devops";
+
+/**
+ * Target state names are process-specific (Agile Active/Closed, Scrum
+ * Committed/Done, Basic Doing/Done), so they are operator-set. Unset or blank
+ * means the swarm never changes the work item state.
+ */
+export function getWorkItemState(which: "STARTED" | "DONE"): string | null {
+  return process.env[`AZURE_DEVOPS_WORKITEM_STATE_${which}`]?.trim() || null;
+}
+
+/** Move the work item linked to `taskId` to `state`. Tasks without a link are ignored. */
+async function transitionLinkedWorkItem(taskId: string, state: string): Promise<void> {
+  const sync = await getTrackerSync(PROVIDER, "task", taskId);
+  if (!sync) return;
+  // externalId is `{orgKey}#{workItemId}`, orgKey `dev.azure.com/{org}` or `{org}.visualstudio.com`.
+  const [orgKey, id] = sync.externalId.split("#");
+  const workItemId = Number(id);
+  if (!orgKey || !Number.isInteger(workItemId)) return;
+  const ok = await updateWorkItemFields(`https://${orgKey}`, workItemId, [
+    { op: "add", path: "/fields/System.State", value: state },
+  ]);
+  if (ok) {
+    console.log(
+      scrubSecrets(`[AzureDevOps] Work item #${workItemId} -> ${state} (task ${taskId})`),
+    );
+  }
+}
+
+const transitionChains = new Map<string, Promise<void>>();
+
+/**
+ * Run transitions for one task in the order they were requested, so a slow
+ * "Doing" PATCH cannot land after "Done". Callers never wait on the chain.
+ */
+function enqueueTransition(taskId: string, state: string, eventName: string): void {
+  const run = (transitionChains.get(taskId) ?? Promise.resolve())
+    .then(() => transitionLinkedWorkItem(taskId, state))
+    .catch((error) => report(eventName, error));
+  transitionChains.set(taskId, run);
+  void run.then(() => {
+    if (transitionChains.get(taskId) === run) transitionChains.delete(taskId);
+  });
+}
+
+function report(eventName: string, error: unknown): void {
+  console.error(
+    `[AzureDevOps Outbound] ${eventName} handler failed:`,
+    scrubSecrets(error instanceof Error ? error.message : String(error)),
+  );
+}
+
+function handleTaskStarted(task: AgentTask): void {
+  const state = getWorkItemState("STARTED");
+  if (state) enqueueTransition(task.id, state, "task.started");
+}
+
+const onTaskCompleted = (data: unknown): void => {
+  const { taskId } = (data ?? {}) as { taskId?: string };
+  const state = getWorkItemState("DONE");
+  if (taskId && state) enqueueTransition(taskId, state, "task.completed");
+};
+
+let subscribed = false;
+let startedHookRegistered = false;
+
+/** Subscribe work-item state transitions to task lifecycle events. Idempotent, API-server only. */
+export function initAzureDevOpsOutbound(): void {
+  if (subscribed) return;
+  subscribed = true;
+  // onTaskStarted has no unregister, so register once and gate on `subscribed`.
+  if (!startedHookRegistered) {
+    startedHookRegistered = true;
+    onTaskStarted((task) => {
+      // startTask/claimTask can emit inside a transaction; a rollback must not reach Azure.
+      if (subscribed) getDbClient().afterCommit(() => handleTaskStarted(task));
+    });
+  }
+  workflowEventBus.on("task.completed", onTaskCompleted);
+}
+
+/** Unsubscribe from lifecycle events (tests, config reloads). */
+export function teardownAzureDevOpsOutbound(): void {
+  if (!subscribed) return;
+  subscribed = false;
+  workflowEventBus.off("task.completed", onTaskCompleted);
+}

package/src/be/boot-seeds.ts

@@ -18,10 +18,12 @@
 import type { Database } from "bun:sqlite";
 import { getDb } from "./db";
 import { ensureRbacSeedsSynced } from "./rbac-roles";
+import { seedModelProfiles } from "./seed-model-profiles";
 import { seedPricingFromModelsDev } from "./seed-pricing";
 
 const pricingSeededDbs = new WeakSet<Database>();
 const rbacSyncedDbs = new WeakSet<Database>();
+const modelProfilesSeededDbs = new WeakSet<Database>();
 
 /** Seed the pricing table from the vendored models.dev snapshot. */
 export function ensurePricingSeeded(): void {
@@ -38,3 +40,12 @@ export function ensureRbacSeeded(): void {
   ensureRbacSeedsSynced();
   rbacSyncedDbs.add(db);
 }
+
+/** Seed the shipped `<harness>-<tier>` model profiles (src/be/seed-model-profiles.ts). */
+export async function ensureModelProfilesSeeded(): Promise<void> {
+  const db = getDb();
+  if (modelProfilesSeededDbs.has(db)) return;
+  const inserted = await seedModelProfiles();
+  if (inserted > 0) console.log(`[startup] Seeded ${inserted} model profiles`);
+  modelProfilesSeededDbs.add(db);
+}

package/src/be/config-refs.ts

@@ -0,0 +1,60 @@
+/**
+ * Config references: `{ "$config": "KEY" }` leaves inside a JSON config value
+ * that point at another config key (usually a secret). Pure, no DB access: the
+ * caller supplies the lookup and decides which keys are allowed.
+ */
+
+export interface ConfigRef {
+  $config: string;
+}
+
+/** True when `value` is exactly `{ "$config": "<non-empty string>" }`. */
+export function isConfigRef(value: unknown): value is ConfigRef {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  const ref = (value as { $config?: unknown }).$config;
+  return keys.length === 1 && keys[0] === "$config" && typeof ref === "string" && ref.length > 0;
+}
+
+export class ConfigRefError extends Error {
+  constructor(
+    message: string,
+    readonly missingKeys: string[],
+  ) {
+    super(message);
+    this.name = "ConfigRefError";
+  }
+}
+
+/**
+ * Replace every `{ "$config": "KEY" }` leaf in `value` with `lookup(KEY)`.
+ * Walks arrays and plain objects. Missing keys (lookup returns undefined) are
+ * collected and reported in one error. A lookup that throws (for example on a
+ * forbidden key) propagates as-is.
+ */
+export function resolveConfigRefs<T>(
+  value: unknown,
+  lookup: (key: string) => string | undefined,
+): T {
+  const missing = new Set<string>();
+
+  const walk = (node: unknown): unknown => {
+    if (isConfigRef(node)) {
+      const resolved = lookup(node.$config);
+      if (resolved === undefined) missing.add(node.$config);
+      return resolved;
+    }
+    if (Array.isArray(node)) return node.map(walk);
+    if (node !== null && typeof node === "object") {
+      return Object.fromEntries(Object.entries(node).map(([k, v]) => [k, walk(v)]));
+    }
+    return node;
+  };
+
+  const result = walk(value);
+  if (missing.size > 0) {
+    const keys = [...missing].sort();
+    throw new ConfigRefError(`Unresolved config reference(s): ${keys.join(", ")}`, keys);
+  }
+  return result as T;
+}