@desplega.ai/agent-swarm 1.173.0 → 2.1.0

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/additive-buffer.ts

@@ -22,8 +22,10 @@
  *     the underlying context becomes irrelevant — e.g. user cancels).
  *
  * Concurrency: single-process, single-event-loop. No cross-instance locking.
- * Flush callbacks run sequentially per key (the buffer is cleared BEFORE the
- * callback fires, so re-enqueues during `onFlush` create a fresh buffer).
+ * The buffer is cleared BEFORE the callback fires, so re-enqueues during
+ * `onFlush` create a fresh buffer, and its flush can start while the earlier
+ * `onFlush` for the same key still runs. A caller that needs per-key order
+ * must serialize inside `onFlush`.
  */
 
 export type BufferFlushReason = "timer" | "manual";

package/src/tasks/context-key.ts

@@ -14,6 +14,9 @@
  * Key schema:
  *   task:slack:{channelId}:{threadTs}
  *   task:agentmail:{threadId}
+ *   task:chat-sdk:{adapter}:{encodeURIComponent(platformThreadId)}
+ *                                                 (Chat SDK thread ids carry `:`, so the
+ *                                                  part after the adapter is URI-encoded)
  *   task:trackers:github:{owner}:{repo}:{issue|pr}:{number}
  *   task:trackers:gitlab:{projectId}:{mr|issue}:{iid}
  *   task:trackers:azure-devops:{repositoryId}:pr:{pullRequestId}
@@ -39,13 +42,20 @@
 
 const SEPARATOR = ":";
 
-export type ContextKeyFamily = "slack" | "agentmail" | "trackers" | "schedule" | "workflow";
+export type ContextKeyFamily =
+  | "slack"
+  | "agentmail"
+  | "chat-sdk"
+  | "trackers"
+  | "schedule"
+  | "workflow";
 
 export type TrackerProvider = "github" | "gitlab" | "azure-devops" | "linear" | "jira";
 
 export type ParsedContextKey =
   | { family: "slack"; parts: { channelId: string; threadTs: string } }
   | { family: "agentmail"; parts: { threadId: string } }
+  | { family: "chat-sdk"; parts: { adapter: string; threadId: string } }
   | {
       family: "trackers";
       subFamily: "github";
@@ -101,6 +111,42 @@ export function slackContextKey(input: { channelId: string; threadTs: string }):
   return ["task", "slack", channelId, threadTs].join(SEPARATOR);
 }
 
+/**
+ * Chat SDK thread ids are `<adapter>:<platform id>` and the platform id itself
+ * may contain `:` (Telegram `telegram:<chatId>:<topicId>`, Slack
+ * `slack:<channel>:<ts>`). The adapter stays a plain key part; the rest is
+ * URI-encoded so the key keeps a fixed part count. `parseContextKey` returns
+ * the original thread id in `parts.threadId`.
+ */
+export function chatSdkContextKey(threadId: string): string {
+  const raw = typeof threadId === "string" ? threadId : "";
+  const separatorIndex = raw.indexOf(SEPARATOR);
+  if (separatorIndex <= 0 || separatorIndex === raw.length - 1) {
+    throw new Error(
+      `context-key: chat-sdk thread id must be "<adapter>:<id>" (got ${JSON.stringify(threadId)})`,
+    );
+  }
+  const adapter = assertSafePart(raw.slice(0, separatorIndex), "adapter");
+  const rest = encodeURIComponent(raw.slice(separatorIndex + 1));
+  return ["task", "chat-sdk", adapter, rest].join(SEPARATOR);
+}
+
+/**
+ * The Chat SDK thread a contextKey points at, or null when the key is missing,
+ * malformed, or of another family. Never throws.
+ */
+export function chatThreadOfContextKey(
+  key: string | null | undefined,
+): { adapter: string; threadId: string } | null {
+  if (!key) return null;
+  try {
+    const parsed = parseContextKey(key);
+    return parsed.family === "chat-sdk" ? parsed.parts : null;
+  } catch {
+    return null;
+  }
+}
+
 export function agentmailContextKey(input: { threadId: string }): string {
   const threadId = assertSafePart(input.threadId, "threadId");
   return ["task", "agentmail", threadId].join(SEPARATOR);
@@ -255,6 +301,19 @@ export function parseContextKey(key: string): ParsedContextKey {
       }
       return { family: "agentmail", parts: { threadId: parts[2] as string } };
     }
+    case "chat-sdk": {
+      if (parts.length !== 4 || !parts[2] || !parts[3]) {
+        throw new Error(`context-key: malformed chat-sdk key: ${JSON.stringify(key)}`);
+      }
+      const adapter = parts[2];
+      let rest: string;
+      try {
+        rest = decodeURIComponent(parts[3]);
+      } catch {
+        throw new Error(`context-key: malformed chat-sdk key: ${JSON.stringify(key)}`);
+      }
+      return { family: "chat-sdk", parts: { adapter, threadId: `${adapter}:${rest}` } };
+    }
     case "schedule": {
       if (parts.length !== 3) {
         throw new Error(`context-key: malformed schedule key: ${JSON.stringify(key)}`);

package/src/tasks/model-pin.ts

@@ -0,0 +1,67 @@
+import type { AgentTask } from "../types";
+
+/** Missing fields read as unset, so a bare `{ model }` is its own pin. */
+export type TaskModelPinFields = {
+  [K in
+    | "model"
+    | "modelSource"
+    | "modelAlias"
+    | "modelTier"
+    | "resolvedModel"
+    | "claudeSessionId"]?: AgentTask[K] | null;
+};
+
+/**
+ * The task's own `model` pin, or undefined when the task has none.
+ *
+ * `agent_tasks.model` is not always the creator's pin: the worker reports the
+ * model it actually ran on `PUT /api/tasks/{id}/session`, which overwrites the
+ * column. So the pin is read from the claim-time record instead:
+ *   - `modelSource = "model"`: the task's own `model` won at claim. A `latest:`
+ *     alias survives only in `modelAlias` (the session report replaced `model`
+ *     with the concrete id), so the alias is the pin.
+ *   - `modelSource = "fallback:cli-unsupported:model"`: the task's own
+ *     `latest:` alias won, then the claiming CLI rejected what it resolved to.
+ *     The alias in `modelAlias` is the pin, with or without a `modelTier`.
+ *   - `modelSource = "fallback:cli-unsupported"` (a tier layer's alias fell
+ *     back) is not a pin. Rows written before the `:model` variant existed are
+ *     ambiguous; one with a `modelAlias` and no `modelTier` can only have come
+ *     from a `model` alias, so its alias is the pin. With a `modelTier` it stays
+ *     ambiguous and only the tier counts.
+ *   - no claim record and no session: `model` is still the creator's value.
+ * Anything else (a tier layer won, or `model` is just the session report) is
+ * not a pin: re-running the row must resolve the model again, from the agent's
+ * current config, instead of replaying the model of the previous run.
+ */
+export function taskModelPin(task: TaskModelPinFields): string | undefined {
+  if (task.modelSource === "model") return task.modelAlias ?? task.model ?? undefined;
+  if (task.modelSource === "fallback:cli-unsupported:model" && task.modelAlias) {
+    return task.modelAlias;
+  }
+  if (task.modelSource === "fallback:cli-unsupported" && task.modelAlias && !task.modelTier) {
+    return task.modelAlias;
+  }
+  if (!task.modelSource && !task.resolvedModel && !task.claudeSessionId) {
+    return task.model ?? undefined;
+  }
+  return undefined;
+}
+
+/**
+ * The model fields a re-run of the SAME task row (paused-task resume) passes to
+ * the spawn: the pin and the claim record that resolved it, or nothing, so the
+ * worker resolves the model from the agent's current config.
+ */
+export function resumedTaskModelSelection(task: TaskModelPinFields): {
+  model: string | undefined;
+  resolvedModel: string | undefined;
+  modelSource: string | undefined;
+} {
+  const pin = taskModelPin(task);
+  if (!pin) return { model: undefined, resolvedModel: undefined, modelSource: undefined };
+  return {
+    model: pin,
+    resolvedModel: task.resolvedModel ?? undefined,
+    modelSource: task.modelSource ?? undefined,
+  };
+}

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

@@ -32,6 +32,7 @@ import {
 } from "../types";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { taskAttachmentDisplayUrl } from "../utils/task-attachment-links";
+import { taskModelPin } from "./model-pin";
 import { createTaskWithSiblingAwareness } from "./sibling-awareness";
 // Side-effect import: registers task lifecycle templates in the in-memory registry.
 import "../tools/templates";
@@ -165,23 +166,8 @@ export function getNextResumeGeneration(parent: Pick<AgentTask, "tags">): number
  * reboot retry) must carry: the parent's portable `modelTier`, plus its
  * concrete `model` only when that `model` was a task-level pin.
  *
- * `agent_tasks.model` is not always the creator's pin: the worker reports the
- * model it actually ran on `POST /api/tasks/{id}/session`, which overwrites the
- * column. So the pin is read from the claim-time record instead:
- *   - `modelSource = "model"`: the task's own `model` won at claim. A `latest:`
- *     alias survives only in `modelAlias` (the session report replaced `model`
- *     with the concrete id), so the alias is what travels.
- *   - `modelSource = "fallback:cli-unsupported:model"`: the task's own
- *     `latest:` alias won, then the claiming CLI rejected what it resolved to.
- *     The alias in `modelAlias` travels, with or without a `modelTier`.
- *   - `modelSource = "fallback:cli-unsupported"` (a tier layer's alias fell
- *     back) is not a pin. Rows written before the `:model` variant existed are
- *     ambiguous; one with a `modelAlias` and no `modelTier` can only have come
- *     from a `model` alias, so its alias travels. With a `modelTier` it stays
- *     ambiguous and only the tier travels.
- *   - no claim record and no session: `model` is still the creator's value.
- * Anything else (a tier layer won, or `model` is just the session report) is
- * not a pin and is left off, so the resume resolves on its claiming worker.
+ * The pin rules live in `taskModelPin` (`./model-pin`); anything that is not
+ * a pin is left off, so the resume resolves on its claiming worker.
  *
  * `resolvedModel`, `modelSource` and `modelAlias` themselves are NOT copied:
  * claim time writes all three together for the task being claimed, and the
@@ -193,26 +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"> {
-  let model: string | undefined;
-  if (parent.modelSource === "model") {
-    model = parent.modelAlias ?? parent.model;
-  } else if (parent.modelSource === "fallback:cli-unsupported:model" && parent.modelAlias) {
-    model = parent.modelAlias;
-  } else if (
-    parent.modelSource === "fallback:cli-unsupported" &&
-    parent.modelAlias &&
-    !parent.modelTier
-  ) {
-    model = parent.modelAlias;
-  } else if (!parent.modelSource && !parent.resolvedModel && !parent.claudeSessionId) {
-    model = parent.model;
-  }
+): 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/acp-adapter.test.ts

@@ -667,6 +667,48 @@ new AgentSideConnection((connection) => new FakeAgent(connection), stream);
     expect(resolveAcpTarget(config).env(config).OPENCODE_CONFIG_CONTENT).toBe(content);
   });
 
+  test("OpenCode preset adds the helmcode block with an {env:} key reference, never the key", () => {
+    const sentinel = "sk-helmcode-acp-sentinel-0123456789";
+    const config = baseConfig({
+      model: "helmcode/glm5.3",
+      env: {
+        ACP_TARGET: "opencode",
+        HELMCODE_API_KEY: sentinel,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          provider: { helmcode: { options: { timeout: 1000 } } },
+        }),
+      },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(env.HELMCODE_API_KEY).toBe(sentinel);
+    expect(env.OPENCODE_CONFIG_CONTENT).not.toContain(sentinel);
+    const helmcode = JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider.helmcode;
+    expect(helmcode).toMatchObject({
+      npm: "@ai-sdk/openai-compatible",
+      name: "Helmcode",
+      env: [],
+      options: {
+        baseURL: "https://api.helmcode.com/v1",
+        apiKey: "{env:HELMCODE_API_KEY}",
+        timeout: 1000,
+      },
+    });
+    expect(helmcode.models["glm5.3"]).toMatchObject({
+      tool_call: true,
+      limit: { context: 1048576, output: 32768 },
+    });
+  });
+
+  test("OpenCode preset adds no custom block for a nan model", () => {
+    const config = baseConfig({
+      model: "nan/glm5.3-flash",
+      env: { ACP_TARGET: "opencode", NAN_API_KEY: "example-test-key" },
+    });
+    const env = resolveAcpTarget(config).env(config);
+    expect(env.NAN_API_KEY).toBe("example-test-key");
+    expect(JSON.parse(env.OPENCODE_CONFIG_CONTENT!).provider?.helmcode).toBeUndefined();
+  });
+
   test("OpenCode preset injects gateway even without a model fallback", () => {
     const config = baseConfig({
       model: "",

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/api-drain-worker-e2e.test.ts

@@ -28,7 +28,6 @@ let sut: Sut;
 let api: ApiClient;
 let fixtureDir: string;
 let fixturePath: string;
-let pm2StubPath: string;
 
 /** A `claude` that initializes, accepts the prompt, and then never answers. */
 const hangingFixtureSource = `#!/usr/bin/env bun
@@ -87,12 +86,8 @@ describe("API drain with a real worker", () => {
   beforeAll(async () => {
     fixtureDir = await mkdtemp("/tmp/api-drain-worker-");
     fixturePath = join(fixtureDir, "claude-fixture");
-    pm2StubPath = join(fixtureDir, "bin");
-    await Bun.$`mkdir -p ${pm2StubPath}`.quiet();
     await Bun.write(fixturePath, hangingFixtureSource);
-    await Bun.write(join(pm2StubPath, "pm2"), "#!/bin/sh\nexit 0\n");
     await Bun.$`chmod 755 ${fixturePath}`.quiet();
-    await Bun.$`chmod 755 ${join(pm2StubPath, "pm2")}`.quiet();
     sut = await startSut(
       false,
       {},
@@ -138,7 +133,7 @@ describe("API drain with a real worker", () => {
       cwd: repoRoot,
       env: {
         ...minimalEnv(),
-        PATH: `${pm2StubPath}:${process.env.PATH ?? "/usr/bin:/bin"}`,
+        PATH: process.env.PATH ?? "/usr/bin:/bin",
         HOME: home,
         AGENT_SWARM_API_KEY: sut.apiKey,
         API_KEY: sut.apiKey,

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({