@desplega.ai/agent-swarm 2.0.0 → 2.1.0

package/src/slack/render-v2.ts

@@ -51,7 +51,7 @@ import {
   splitSlackSectionText,
 } from "./blocks";
 import { buildAskClosure, type ClosureState, closureState } from "./closure";
-import { reactionName, type SlackReactionEvent } from "./reaction-shortcode";
+import { completedStatusIcon, reactionName, type SlackReactionEvent } from "./reaction-shortcode";
 import { getAgentDisplayName, getAgentEmoji } from "./responses";
 import {
   _resetSlackSessionStatusForTests,
@@ -346,7 +346,7 @@ async function taskStateGlyph(
     case "paused":
       return "⏸️";
     case "completed":
-      return "✅";
+      return completedStatusIcon();
     case "failed":
       return "❌";
     case "cancelled":
@@ -496,7 +496,9 @@ function threadHeaderText(tasks: AgentTask[], now: Date, duration: string): stri
   // A parked deferral is stored `completed`, but the ask is not answered yet.
   if (tasks.some((task) => isAwaitingWake(task, tasks))) return `🧵 ⏳ waiting — ${duration}`;
   const hasFailure = tasks.some((task) => task.status === "failed");
-  return hasFailure ? `🧵 ❌ done with failures — ${duration}` : `🧵 ✅ done — ${duration}`;
+  return hasFailure
+    ? `🧵 ❌ done with failures — ${duration}`
+    : `🧵 ${completedStatusIcon()} done — ${duration}`;
 }
 
 export async function renderThreadTree(
@@ -909,7 +911,7 @@ async function outcomeContent(task: AgentTask, slackReplySent: boolean): Promise
     const agentName = task.agentId
       ? ((await getAgentById(task.agentId))?.name ?? "Agent")
       : "Agent";
-    return `✅ ${agentName} completed`;
+    return `${completedStatusIcon()} ${agentName} completed`;
   }
   // A deferral is `completed` in the database but unfinished to a human: the
   // work resumes in a wake-up task. Rendering it ✅ told the thread the ask
@@ -917,7 +919,10 @@ async function outcomeContent(task: AgentTask, slackReplySent: boolean): Promise
   if (isDeferred) {
     return withStatusLead("⏳", outcomeText(slackTaskOutput(task), "Deferred."));
   }
-  return withStatusLead("✅", outcomeText(slackTaskOutput(task), "Task completed."));
+  return withStatusLead(
+    completedStatusIcon(),
+    outcomeText(slackTaskOutput(task), "Task completed."),
+  );
 }
 
 async function agentDisplayNameFor(task: AgentTask): Promise<string> {
@@ -947,7 +952,7 @@ export async function childOutcomeContent(
     );
   }
   if (slackReplySent && !isDeferredTask(task)) {
-    return `↳ ✅ ${agentName} completed`;
+    return `↳ ${completedStatusIcon()} ${agentName} completed`;
   }
   if (isDeferredTask(task)) {
     return withStatusLead(
@@ -956,7 +961,7 @@ export async function childOutcomeContent(
     );
   }
   return withStatusLead(
-    `↳ ✅ ${agentName} — result:`,
+    `↳ ${completedStatusIcon()} ${agentName} — result:`,
     outcomeText(slackTaskOutput(task), "Task completed."),
   );
 }

package/src/slack/responses.ts

@@ -15,6 +15,7 @@ import {
   markdownToSlack,
   splitSlackSectionText,
 } from "./blocks";
+import { completedStatusIcon } from "./reaction-shortcode";
 import { getSlackOutputAttachments } from "./task-attachments";
 import { slackTaskOutput } from "./task-output";
 
@@ -67,7 +68,7 @@ export function formatInlineCompletionOutputChunks(opts: {
   taskId: string;
   output: string;
 }): string[] {
-  const header = `✅ *${opts.agentName}* completed with output (${getTaskLink(opts.taskId)}):\n\n`;
+  const header = `${completedStatusIcon()} *${opts.agentName}* completed with output (${getTaskLink(opts.taskId)}):\n\n`;
   const slackOutput = markdownToSlack(opts.output.trim());
   return splitSlackSectionText(header + slackOutput);
 }
@@ -169,7 +170,7 @@ export async function sendTaskResponse(task: AgentTask): Promise<boolean> {
           thread_ts: task.slackThreadTs,
           text:
             task.slackReplySent || i > 0
-              ? `✅ ${agentName} completed${i > 0 ? ` (continued ${i + 1}/${blockBatches.length})` : ""}`
+              ? `${completedStatusIcon()} ${agentName} completed${i > 0 ? ` (continued ${i + 1}/${blockBatches.length})` : ""}`
               : body,
           username: getAgentDisplayName(agent),
           icon_emoji: getAgentEmoji(agent),
@@ -324,7 +325,7 @@ export async function updateToFinal(
     };
     completionBlockBatches = buildCompletedBlockBatches(completionOpts);
     blocks = completionBlockBatches[0] ?? buildCompletedBlocks(completionOpts);
-    text = task.slackReplySent ? `✅ ${agentName} completed` : body;
+    text = task.slackReplySent ? `${completedStatusIcon()} ${agentName} completed` : body;
   } else if (task.status === "cancelled") {
     blocks = buildCancelledBlocks({ agentName, taskId: task.id });
     text = "Task cancelled";
@@ -351,7 +352,7 @@ export async function updateToFinal(
         await sendWithPersona(app.client, {
           channel: task.slackChannelId,
           thread_ts: task.slackThreadTs ?? messageTs,
-          text: `✅ ${agentName} completed (continued ${i + 1}/${completionBlockBatches.length})`,
+          text: `${completedStatusIcon()} ${agentName} completed (continued ${i + 1}/${completionBlockBatches.length})`,
           username: getAgentDisplayName(agent),
           icon_emoji: getAgentEmoji(agent),
           blocks: completionBlockBatches[i],

package/src/slack/thread-buffer.ts

@@ -7,6 +7,9 @@ import {
 import { findUserByExternalId } from "../be/users";
 import { createAdditiveBuffer } from "../tasks/additive-buffer";
 import { slackContextKey } from "../tasks/context-key";
+import { TaskCreationBlockedError } from "../tasks/errors";
+import { scrubSecrets } from "../utils/secret-scrubber";
+import { ackSlackMessage } from "./ack";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
 import { resolveSlackUserId, rewriteSlackMentions } from "./enrich";
@@ -286,28 +289,44 @@ async function slackFlush(
   const dependsOn = !immediate && latestActiveTask ? [latestActiveTask.id] : undefined;
 
   const mostRecentTask = await getMostRecentTaskInThread(channelId, threadTs);
-  const { task, unattached } = await createSlackTaskWithFiles(
-    fullDescription,
-    {
-      agentId: lead?.id,
-      routingReason:
-        lead && mostRecentTask?.agentId === lead.id ? "continuity" : lead ? "skill" : undefined,
-      routingSource: lead ? "engine_default" : undefined,
-      source: "slack",
-      slackChannelId: channelId,
-      slackThreadTs: threadTs,
-      slackTriggerMessageTs: items.at(-1)!.ts,
-      slackUserId: originalRequesterId,
-      requestedByUserId,
-      dependsOn,
-      parentTaskId: mostRecentTask?.id,
-      // A human message in the thread: never answer it in the latest thread
-      // task's structured-output contract.
-      inheritParentOutputSchema: false,
-      contextKey: slackContextKey({ channelId, threadTs }),
-    },
-    inbound,
-  );
+  let created: Awaited<ReturnType<typeof createSlackTaskWithFiles>>;
+  try {
+    created = await createSlackTaskWithFiles(
+      fullDescription,
+      {
+        agentId: lead?.id,
+        routingReason:
+          lead && mostRecentTask?.agentId === lead.id ? "continuity" : lead ? "skill" : undefined,
+        routingSource: lead ? "engine_default" : undefined,
+        source: "slack",
+        slackChannelId: channelId,
+        slackThreadTs: threadTs,
+        slackTriggerMessageTs: items.at(-1)!.ts,
+        slackUserId: originalRequesterId,
+        requestedByUserId,
+        dependsOn,
+        parentTaskId: mostRecentTask?.id,
+        // A human message in the thread: never answer it in the latest thread
+        // task's structured-output contract.
+        inheritParentOutputSchema: false,
+        contextKey: slackContextKey({ channelId, threadTs }),
+      },
+      inbound,
+    );
+  } catch (error) {
+    if (!(error instanceof TaskCreationBlockedError)) throw error;
+
+    console.info(
+      "[Slack] pre.task.create blocked:",
+      error.extension.name,
+      scrubSecrets(error.reason),
+    );
+    if (app) {
+      await ackSlackMessage(app.client, channelId, items.at(-1)!.ts, "no_entry");
+    }
+    return;
+  }
+  const { task, unattached } = created;
 
   if (app) await notifySlackFileFailures(app.client, channelId, threadTs, unattached);
 

package/src/tasks/worker-follow-up.ts

@@ -179,13 +179,22 @@ export function getNextResumeGeneration(parent: Pick<AgentTask, "tags">): number
 export function inheritedModelSelection(
   parent: Pick<
     AgentTask,
-    "model" | "modelTier" | "modelSource" | "modelAlias" | "resolvedModel" | "claudeSessionId"
+    | "model"
+    | "modelTier"
+    | "modelSource"
+    | "modelAlias"
+    | "resolvedModel"
+    | "claudeSessionId"
+    | "profile"
   >,
-): Pick<CreateTaskOptions, "model" | "modelTier"> {
+): Pick<CreateTaskOptions, "model" | "modelTier" | "profile"> {
   const model = taskModelPin(parent);
+  // The task's own profile travels like its tier; an agent-default profile
+  // (`resolvedProfile` only) is re-resolved by the child's claim.
   return {
     ...(model ? { model } : {}),
     ...(parent.modelTier ? { modelTier: parent.modelTier } : {}),
+    ...(parent.profile ? { profile: parent.profile } : {}),
   };
 }
 

package/src/tests/agentmail-filters.test.ts

@@ -38,6 +38,27 @@ describe("isInboxAllowed", () => {
   test("rejects empty inbox id", () => {
     expect(isInboxAllowed("", "x.dev")).toBe(false);
   });
+
+  test("allows exact full-address match", () => {
+    expect(isInboxAllowed("bot@x.dev", "bot@x.dev")).toBe(true);
+  });
+
+  test("rejects another address on the same domain as a full-address entry", () => {
+    expect(isInboxAllowed("other@x.dev", "bot@x.dev")).toBe(false);
+  });
+
+  test("full-address match is case-insensitive", () => {
+    expect(isInboxAllowed("Bot@X.Dev", "bot@x.dev")).toBe(true);
+    expect(isInboxAllowed("bot@x.dev", "BOT@X.DEV")).toBe(true);
+  });
+
+  test("supports mixed address and domain entries", () => {
+    const filter = "bot@x.dev, y.xyz";
+    expect(isInboxAllowed("bot@x.dev", filter)).toBe(true);
+    expect(isInboxAllowed("anyone@y.xyz", filter)).toBe(true);
+    expect(isInboxAllowed("other@x.dev", filter)).toBe(false);
+    expect(isInboxAllowed("bot@evil.com", filter)).toBe(false);
+  });
 });
 
 describe("isSenderAllowed", () => {
@@ -94,4 +115,30 @@ describe("isSenderAllowed", () => {
   test("rejects non-matching domain in 'Name <email>' format", () => {
     expect(isSenderAllowed("Taras <t@evil.com>", "desplega.ai")).toBe(false);
   });
+
+  test("allows exact full-address match", () => {
+    expect(isSenderAllowed("alice@a.com", "alice@a.com")).toBe(true);
+  });
+
+  test("rejects another address on the same domain as a full-address entry", () => {
+    expect(isSenderAllowed("bob@a.com", "alice@a.com")).toBe(false);
+  });
+
+  test("full-address match is case-insensitive", () => {
+    expect(isSenderAllowed("Alice@A.com", "alice@a.com")).toBe(true);
+    expect(isSenderAllowed("alice@a.com", "ALICE@A.COM")).toBe(true);
+  });
+
+  test("matches a full address in 'Name <email>' format", () => {
+    expect(isSenderAllowed("Taras <t@gmail.com>", "t@gmail.com")).toBe(true);
+    expect(isSenderAllowed(["Someone <s@gmail.com>"], "t@gmail.com")).toBe(false);
+  });
+
+  test("supports mixed address and domain entries", () => {
+    const filter = "t@gmail.com, desplega.ai";
+    expect(isSenderAllowed("t@gmail.com", filter)).toBe(true);
+    expect(isSenderAllowed("anyone@desplega.ai", filter)).toBe(true);
+    expect(isSenderAllowed("other@gmail.com", filter)).toBe(false);
+    expect(isSenderAllowed(["other@gmail.com", "Taras <t@gmail.com>"], filter)).toBe(true);
+  });
 });

package/src/tests/apps-spike2.test.ts

@@ -987,6 +987,41 @@ describe("custom app actions", () => {
     );
   });
 
+  test("app writes return quickjs compat warnings for wired scripts without rejecting", async () => {
+    const saved = await upsertScriptByName({
+      name: `app_compat_${crypto.randomUUID().replaceAll("-", "")}`,
+      scope: "agent",
+      scopeId: AGENT_ID,
+      source: "export default async () => Buffer.from('aGk=', 'base64').toString();",
+      description: "Apps compat warning fixture",
+      intent: "Exercise quickjs compat warnings on app writes",
+      signatureJson: JSON.stringify({ args: { type: "object" }, result: { type: "string" } }),
+      agentId: AGENT_ID,
+      typeChecked: true,
+    });
+    const created = await request<{ app: { id: string }; warnings?: string[] }>("/api/apps", {
+      method: "POST",
+      body: JSON.stringify({
+        name: "Compat",
+        definition: {
+          ...baseDefinition,
+          actions: { decode: { kind: "script", scriptId: saved.script.id } },
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    expect(created.body.warnings).toEqual([
+      "actions.decode: quickjs compat (unsupportedGlobal, line 1): Buffer is not available under quickjs",
+    ]);
+
+    const cleared = await request<{ warnings?: string[] }>(`/api/apps/${created.body.app.id}`, {
+      method: "PUT",
+      body: JSON.stringify({ definition: baseDefinition }),
+    });
+    expect(cleared.status).toBe(200);
+    expect(cleared.body.warnings).toBeUndefined();
+  });
+
   test("agent writers cannot wire another agent's script; operator wiring is grandfathered", async () => {
     const OTHER_AGENT_ID = crypto.randomUUID();
     const foreign = await upsertScriptByName({