@desplega.ai/agent-swarm 2.5.1 → 2.5.2

package/src/workflows/approval-notifications.ts

@@ -3,14 +3,228 @@ import {
   claimApprovalCancellationNotification,
   completeApprovalCancellationNotificationClaim,
   createTaskExtended,
+  getApprovalRequestById,
   getTaskById,
   releaseApprovalCancellationNotificationClaim,
+  updateApprovalRequestNotifications,
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { getSlackApp } from "../slack/app";
+import { resolveSlackConversationId } from "../slack/dm";
+import {
+  externalChannelToolError,
+  getChannelBlockReason,
+  isBlockExternalEnabled,
+} from "../slack/external-channel";
 import { TERMINAL_TASK_STATUSES } from "../types";
+import { getAppUrl } from "../utils/constants";
 import { scrubSecrets } from "../utils/secret-scrubber";
 
+/** Slack Block Kit caps a section block's text at 3000 characters. */
+const SLACK_SECTION_TEXT_LIMIT = 3000;
+
+function escapeSlackMrkdwn(text: string): string {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+/**
+ * Render the Slack "Questions" section text within Block Kit's 3000-character
+ * section limit. Labels are escaped so upstream text cannot inject mentions or
+ * links. When the list does not fit, the tail is replaced by a count; every
+ * question stays answerable on the dashboard page the card's button opens.
+ */
+export function buildSlackQuestionsSummary(
+  questions: ReadonlyArray<{ label: string }>,
+  timeoutText = "",
+): string {
+  const header = "*Questions:*\n";
+  const lines = questions.map((q) => `• ${escapeSlackMrkdwn(q.label.replace(/\s+/g, " ").trim())}`);
+  const fits = (shown: string[], omitted: number) => {
+    const tail =
+      omitted > 0 ? `\n_…and ${omitted} more. Answer all of them on the dashboard._` : "";
+    const text = `${header}${shown.join("\n")}${tail}${timeoutText}`;
+    return text.length <= SLACK_SECTION_TEXT_LIMIT ? text : null;
+  };
+
+  const full = fits(lines, 0);
+  if (full) return full;
+  for (let count = lines.length - 1; count >= 0; count--) {
+    const text = fits(lines.slice(0, count), lines.length - count);
+    if (text) return text;
+  }
+  return `${header}_${questions.length} questions. Answer them on the dashboard._`;
+}
+
+function formatTimeout(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.round((seconds % 3600) / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+
+export interface ApprovalNotificationChannel {
+  channel: "slack" | "email";
+  target: string;
+}
+
+export interface ApprovalNotificationsInput {
+  requestId: string;
+  title: string;
+  questions: ReadonlyArray<{ label: string }>;
+  timeoutSeconds?: number;
+  notifications: ReadonlyArray<ApprovalNotificationChannel>;
+}
+
+/** The DB calls the dispatch makes; the HITL executor injects its own. */
+export interface ApprovalNotificationsDb {
+  updateApprovalRequestNotifications: typeof updateApprovalRequestNotifications;
+  getApprovalRequestById: typeof getApprovalRequestById;
+}
+
+/**
+ * Post the "Approval Required" card for each notification channel and store
+ * the Slack `messageTs` on the request. Used by the workflow HITL executor and
+ * by `POST /api/approval-requests`, which checks the caller may post to Slack.
+ * Callers fire and forget: a Slack failure is logged and never fails the
+ * request. Email is not supported yet and is skipped.
+ */
+export async function dispatchApprovalNotifications(
+  input: ApprovalNotificationsInput,
+  db: ApprovalNotificationsDb = { updateApprovalRequestNotifications, getApprovalRequestById },
+): Promise<void> {
+  const { requestId, title, questions, timeoutSeconds, notifications } = input;
+  if (!notifications.length) return;
+
+  const approvalUrl = `${getAppUrl()}/approval-requests/${requestId}`;
+  const updatedChannels: Array<ApprovalNotificationChannel & { messageTs?: string }> = [
+    ...notifications,
+  ];
+  let updated = false;
+
+  for (let i = 0; i < notifications.length; i++) {
+    const notification = notifications[i]!;
+
+    if (notification.channel === "email") {
+      console.warn(`[HITL] Email notifications not yet supported (target: ${notification.target})`);
+      continue;
+    }
+
+    if (notification.channel === "slack") {
+      try {
+        const slackApp = getSlackApp();
+        if (!slackApp) {
+          console.warn("[HITL] Slack not initialized — cannot send notification");
+          continue;
+        }
+
+        // Same guard as the Slack tools: never post into a channel shared with another org.
+        if (isBlockExternalEnabled()) {
+          const conversationId = await resolveSlackConversationId(
+            slackApp.client,
+            notification.target,
+          );
+          const blockReason = await getChannelBlockReason(slackApp.client, conversationId);
+          if (blockReason) {
+            console.warn(`[HITL] ${externalChannelToolError(conversationId, blockReason)}`);
+            continue;
+          }
+        }
+
+        const questionsText = buildSlackQuestionsSummary(questions);
+
+        // The deadline is a caption under the button, not part of the ask.
+        const timeoutCaption =
+          timeoutSeconds !== undefined
+            ? [
+                {
+                  type: "context",
+                  elements: [
+                    {
+                      type: "mrkdwn",
+                      text: `⏱ Timeout: ${formatTimeout(timeoutSeconds)} — times out if not responded`,
+                    },
+                  ],
+                },
+              ]
+            : [];
+
+        const blocks = [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `🔔 *Approval Required: ${escapeSlackMrkdwn(title)}*`,
+            },
+          },
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: questionsText,
+            },
+          },
+          {
+            type: "actions",
+            elements: [
+              {
+                type: "button",
+                text: { type: "plain_text", text: "Review & Respond" },
+                url: approvalUrl,
+                style: "primary",
+              },
+            ],
+          },
+          ...timeoutCaption,
+        ];
+
+        const result = await slackApp.client.chat.postMessage({
+          channel: notification.target,
+          text: `Approval Required: ${escapeSlackMrkdwn(title)} — ${approvalUrl}`,
+          unfurl_links: false,
+          unfurl_media: false,
+          // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+          blocks: blocks as any,
+        });
+
+        if (result.ts) {
+          updatedChannels[i] = { ...notification, messageTs: result.ts };
+          updated = true;
+        }
+
+        console.log(
+          `[HITL] Slack notification sent to ${notification.target} for request ${requestId}`,
+        );
+      } catch (err) {
+        console.error(
+          `[HITL] Failed to send Slack notification to ${notification.target}:`,
+          scrubSecrets(err instanceof Error ? err.message : String(err)),
+        );
+      }
+    }
+  }
+
+  // Persist messageTs values back to DB
+  if (updated) {
+    try {
+      await db.updateApprovalRequestNotifications(requestId, updatedChannels);
+      // A cancel that landed while the card was posting found no messageTs to thread under.
+      const latest = await db.getApprovalRequestById(requestId);
+      if (latest?.status === "cancelled") {
+        await postApprovalCancellationUpdates(
+          [latest],
+          latest.resolutionReason ?? "Workflow run cancelled",
+        );
+      }
+    } catch (err) {
+      console.error(
+        "[HITL] Failed to update notification channels in DB:",
+        scrubSecrets(err instanceof Error ? err.message : String(err)),
+      );
+    }
+  }
+}
+
 export interface ApprovalSlackClient {
   chat: {
     postMessage(input: {

package/src/workflows/executors/human-in-the-loop.ts

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import type { ExecutorMeta } from "../../types";
-import { getAppUrl } from "../../utils/constants";
 import { scrubSecrets } from "../../utils/secret-scrubber";
-import { postApprovalCancellationUpdates } from "../approval-notifications";
+import { dispatchApprovalNotifications } from "../approval-notifications";
 import type { ExecutorInput, ExecutorResult } from "./base";
 import { BaseExecutor } from "./base";
 
@@ -88,9 +87,6 @@ const DYNAMIC_QUESTIONS_TOKEN_RE = /^\{\{[^}]+\}\}$/;
  */
 export const MAX_HITL_QUESTIONS = 100;
 
-/** Slack Block Kit caps a section block's text at 3000 characters. */
-const SLACK_SECTION_TEXT_LIMIT = 3000;
-
 const MAX_REPORTED_ISSUES = 5;
 
 const HITLConfigSchema = z.object({
@@ -197,38 +193,6 @@ export function resolveHitlQuestions(
   return { ok: true, questions };
 }
 
-function escapeSlackMrkdwn(text: string): string {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-
-/**
- * Render the Slack "Questions" section text within Block Kit's 3000-character
- * section limit. Labels are escaped so upstream text cannot inject mentions or
- * links. When the list does not fit, the tail is replaced by a count; every
- * question stays answerable on the dashboard page the card's button opens.
- */
-export function buildSlackQuestionsSummary(
-  questions: ReadonlyArray<{ label: string }>,
-  timeoutText = "",
-): string {
-  const header = "*Questions:*\n";
-  const lines = questions.map((q) => `• ${escapeSlackMrkdwn(q.label.replace(/\s+/g, " ").trim())}`);
-  const fits = (shown: string[], omitted: number) => {
-    const tail =
-      omitted > 0 ? `\n_…and ${omitted} more. Answer all of them on the dashboard._` : "";
-    const text = `${header}${shown.join("\n")}${tail}${timeoutText}`;
-    return text.length <= SLACK_SECTION_TEXT_LIMIT ? text : null;
-  };
-
-  const full = fits(lines, 0);
-  if (full) return full;
-  for (let count = lines.length - 1; count >= 0; count--) {
-    const text = fits(lines.slice(0, count), lines.length - count);
-    if (text) return text;
-  }
-  return `${header}_${questions.length} questions. Answer them on the dashboard._`;
-}
-
 // ─── Executor ───────────────────────────────────────────────
 
 export class HumanInTheLoopExecutor extends BaseExecutor<
@@ -319,7 +283,16 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
 
     // 3. Dispatch notifications (fire-and-forget — failures must not block the workflow)
     if (config.notifications?.length) {
-      this.dispatchNotifications(requestId, config, db).catch((err) => {
+      dispatchApprovalNotifications(
+        {
+          requestId,
+          title: config.title,
+          questions: config.questions,
+          timeoutSeconds: config.timeout?.seconds,
+          notifications: config.notifications,
+        },
+        db,
+      ).catch((err) => {
         console.error(
           "[HITL] Unexpected error dispatching notifications:",
           scrubSecrets(err instanceof Error ? err.message : String(err)),
@@ -335,138 +308,4 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
       correlationId: requestId,
     } as ExecutorResult<HITLOutput>;
   }
-
-  /** Dispatch notifications for each configured channel. Updates DB with messageTs on success. */
-  private async dispatchNotifications(
-    requestId: string,
-    config: z.infer<typeof HITLConfigSchema>,
-    db: typeof import("../../be/db"),
-  ): Promise<void> {
-    if (!config.notifications?.length) return;
-
-    const approvalUrl = `${getAppUrl()}/approval-requests/${requestId}`;
-    const updatedChannels = [...config.notifications] as Array<
-      z.infer<typeof NotificationConfigSchema> & { messageTs?: string }
-    >;
-    let updated = false;
-
-    for (let i = 0; i < config.notifications.length; i++) {
-      const notification = config.notifications[i]!;
-
-      if (notification.channel === "email") {
-        console.warn(
-          `[HITL] Email notifications not yet supported (target: ${notification.target})`,
-        );
-        continue;
-      }
-
-      if (notification.channel === "slack") {
-        try {
-          const { getSlackApp } = await import("../../slack/app");
-          const slackApp = getSlackApp();
-          if (!slackApp) {
-            console.warn("[HITL] Slack not initialized — cannot send notification");
-            continue;
-          }
-
-          const questions = Array.isArray(config.questions) ? config.questions : [];
-          const questionsText = buildSlackQuestionsSummary(questions);
-
-          // The deadline is a caption under the button, not part of the ask.
-          const timeoutCaption = config.timeout
-            ? [
-                {
-                  type: "context",
-                  elements: [
-                    {
-                      type: "mrkdwn",
-                      text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — times out if not responded`,
-                    },
-                  ],
-                },
-              ]
-            : [];
-
-          const blocks = [
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: `🔔 *Approval Required: ${config.title}*`,
-              },
-            },
-            {
-              type: "section",
-              text: {
-                type: "mrkdwn",
-                text: questionsText,
-              },
-            },
-            {
-              type: "actions",
-              elements: [
-                {
-                  type: "button",
-                  text: { type: "plain_text", text: "Review & Respond" },
-                  url: approvalUrl,
-                  style: "primary",
-                },
-              ],
-            },
-            ...timeoutCaption,
-          ];
-
-          const result = await slackApp.client.chat.postMessage({
-            channel: notification.target,
-            text: `Approval Required: ${config.title} — ${approvalUrl}`,
-            unfurl_links: false,
-            unfurl_media: false,
-            // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
-            blocks: blocks as any,
-          });
-
-          if (result.ts) {
-            updatedChannels[i] = { ...notification, messageTs: result.ts };
-            updated = true;
-          }
-
-          console.log(
-            `[HITL] Slack notification sent to ${notification.target} for request ${requestId}`,
-          );
-        } catch (err) {
-          console.error(
-            `[HITL] Failed to send Slack notification to ${notification.target}:`,
-            scrubSecrets(err instanceof Error ? err.message : String(err)),
-          );
-        }
-      }
-    }
-
-    // Persist messageTs values back to DB
-    if (updated) {
-      try {
-        await db.updateApprovalRequestNotifications(requestId, updatedChannels);
-        const latest = await db.getApprovalRequestById(requestId);
-        if (latest?.status === "cancelled") {
-          await postApprovalCancellationUpdates(
-            [latest],
-            latest.resolutionReason ?? "Workflow run cancelled",
-          );
-        }
-      } catch (err) {
-        console.error(
-          "[HITL] Failed to update notification channels in DB:",
-          scrubSecrets(err instanceof Error ? err.message : String(err)),
-        );
-      }
-    }
-  }
-}
-
-function formatTimeout(seconds: number): string {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
-  const hours = Math.floor(seconds / 3600);
-  const mins = Math.round((seconds % 3600) / 60);
-  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
 }

package/src/workflows/executors/swarm-script.ts

@@ -10,12 +10,12 @@ import {
   restoreScratchScriptLastUsedIfUnchanged,
   touchScratchScriptLastUsed,
 } from "../../be/scripts/db";
+import { runScriptWithRunCredential } from "../../be/scripts/run-credential";
 import {
   DEFAULT_SCRIPT_RESOURCES,
   MAX_SCRIPT_WALL_CLOCK_MS,
   MIN_SCRIPT_WALL_CLOCK_MS,
 } from "../../scripts-runtime/executors/types";
-import { runScript } from "../../scripts-runtime/loader";
 import type { ExecutorMeta } from "../../types";
 import { getMcpBaseUrl } from "../../utils/constants";
 import { findInterpolationTokens } from "../../utils/template";
@@ -119,7 +119,7 @@ export class SwarmScriptExecutor extends BaseExecutor<
     const credentials = await buildScriptCredentialBindingsWithFailures({
       agentId: agentId ?? undefined,
     });
-    const output = await runScript({
+    const output = await runScriptWithRunCredential({
       source: resolved.source,
       args: config.args,
       fsMode: "none",

package/templates/schedules/weekly-harness-upgrade-check/content.md

@@ -45,7 +45,7 @@ The worker image pins these harnesses via `ARG`. Each week, check upstream for n
    bun test
    bash scripts/check-db-boundary.sh
    ```
-   For Codex bumps: also run `bash scripts/check-codex-default-model.sh`.
+   For Codex bumps: also run `bash scripts/check-codex-default-model.sh` (CI runs it too). It fails when `ARG CODEX_VERSION` differs from the direct `@openai/codex` pin in `package.json`, or when the Dockerfile's baseline `model = "..."` differs from `CODEX_DEFAULT_MODEL` in `src/providers/codex-models.ts`.
    Note: do NOT run `docker build -f Dockerfile.worker .` locally — the runner lacks docker. CI's `docker-worker-build` job is the acceptance gate.
 9. If any local check fails, apply the **partial-bundle fallback** before giving up — one harness must never block the others:
    **BASELINE FIRST — do this before ANY isolation work.** A red gate does NOT mean the bumps broke anything. Re-run the EXACT failing command on a pristine `origin/main` worktree with zero bumps applied (`git worktree add /tmp/hb-baseline origin/main && cd /tmp/hb-baseline && bun install --frozen-lockfile`) and compare. If the SAME checks fail with the SAME assertions and the same pass/skip/fail totals, the failure is **PRE-EXISTING and unrelated to the bumps** ⇒ it does NOT block this PR, and you must NOT attempt isolation for it. Proceed to step 10, open the PR, and add a `## Pre-existing failures (also fail on origin/main)` section quoting the verbatim error plus both totals (baseline vs branch) so the reviewer can see they match. Only a failure that is RED on your branch and GREEN on baseline was caused by a bump — apply a–d below to that failure ONLY. A gate that is red on origin/main is never a reason to skip the weekly bump.

package/templates/skills/code-quality/content.md

@@ -44,7 +44,7 @@ The Repository Guidelines carry `allowMerge` and `mergeChecks`.
 1. Read `/review/rules.md` on the shared agent-fs drive. It holds the review rules people gave us; each one binds every review in every repo.
 2. Read the repo's `REVIEW.md` when it has one. It holds the repo-specific checks.
 3. Set the effort from the PR body's `Risk:` line. `low`: a quick pass that still covers CI, tests and the security read. `medium` or no line: the full list below. `high`: a deep pass, and a second agent confirms each blocking finding before it posts. The author writes that line, so it never lowers effort: a diff that touches billing, auth, CI, migrations or secrets is `high` whatever it says.
-4. Re-review check. If you reviewed this PR before, compare `gh pr view <number> --json headRefOid --jq .headRefOid` with the `commit_id` of your last review (`gh api repos/<owner>/<repo>/pulls/<number>/reviews`). Same SHA: reuse that verdict, link it and stop. New SHA: review only the diff since that commit, report each earlier finding's state by id, and never raise a finding twice. Re-run each earlier repro on the new head. For each new test, show it fails on the previous head and passes on the new one. Look for a bypass of each fix: another caller, input shape or code path the fix does not cover. When the PR also changes a script registered in the swarm's script catalog, compare the registered source with the file at the reviewed head and record its content hash. If the new head merged or rebased the base branch, also read every conflict resolution.
+4. Re-review check. If you reviewed this PR before, compare `gh pr view <number> --json headRefOid --jq .headRefOid` with the `commit_id` of your last review (`gh api repos/<owner>/<repo>/pulls/<number>/reviews`). Same SHA: reuse that verdict, link it and stop, unless the PR gained evidence that answers an open non-code blocker (a UI recording, a screenshot, a log). Then verify only that evidence, reuse the earlier code checks, and post one updated verdict that names the evidence. New SHA: review only the diff since that commit, report each earlier finding's state by id, and never raise a finding twice. Re-run each earlier repro on the new head. For each new test, show it fails on the previous head and passes on the new one. Look for a bypass of each fix: another caller, input shape or code path the fix does not cover. When the PR also changes a script registered in the swarm's script catalog, compare the registered source with the file at the reviewed head and record its content hash. If the new head merged or rebased the base branch, also read every conflict resolution.
 5. Round cap. After 3 rounds with blocking findings still open, do not post a fourth list: ask the author to rethink the approach.
 
 ### What to check

package/dist/rbac-roles-ff1ffmec.js

@@ -1,12 +0,0 @@
-import {
-  getUserGrant2,
-  ensureRbacSeedsSynced2,
-  init_rbac_roles
-} from "./cli-z2dv25mf.js";
-import"./cli-q9pzwxvk.js";
-init_rbac_roles();
-
-export {
-  ensureRbacSeedsSynced2 as ensureRbacSeedsSynced,
-  getUserGrant2 as getUserGrant
-};