@desplega.ai/agent-swarm 1.100.2 → 1.100.4

package/src/tests/slack-channel-join.test.ts

@@ -10,21 +10,70 @@ function makePlatformError(code: string): Error {
   return err;
 }
 
+type ChannelShape = {
+  is_ext_shared?: boolean;
+  is_pending_ext_shared?: boolean;
+};
+
+function makeClient(opts: {
+  channel?: ChannelShape;
+  infoResult?: () => unknown;
+  joinResult?: () => unknown;
+}): {
+  client: WebClient;
+  infoFn: ReturnType<typeof mock>;
+  joinFn: ReturnType<typeof mock>;
+} {
+  const infoFn = mock(
+    opts.infoResult
+      ? opts.infoResult
+      : () => Promise.resolve({ channel: opts.channel ?? { is_ext_shared: false } }),
+  );
+  const joinFn = mock(opts.joinResult ? opts.joinResult : () => Promise.resolve({}));
+  const client = {
+    conversations: { info: infoFn, join: joinFn },
+  } as unknown as WebClient;
+  return { client, infoFn, joinFn };
+}
+
 describe("withAutoJoin", () => {
-  test("success: fn called once, join not called", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("success: fn called once, join and info not called", async () => {
+    const { client, infoFn, joinFn } = makeClient({});
     const fn = mock(() => Promise.resolve("ok"));
 
     const result = await withAutoJoin(client, "C123", fn);
     expect(result).toBe("ok");
     expect(fn).toHaveBeenCalledTimes(1);
+    expect(infoFn).not.toHaveBeenCalled();
     expect(joinFn).not.toHaveBeenCalled();
   });
 
-  test("not_in_channel: calls join then retries fn exactly once", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("not_in_channel on internal channel: fetches info, calls join, retries fn exactly once", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "retried-ok";
+    });
+
+    const result = await withAutoJoin(client, "CPUB", fn);
+    expect(result).toBe("retried-ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
+    expect(infoFn).toHaveBeenCalledWith({ channel: "CPUB" });
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(joinFn).toHaveBeenCalledWith({ channel: "CPUB" });
+  });
+
+  test("info failure falls back to join and retries fn", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      infoResult: () => {
+        throw makePlatformError("channel_not_found");
+      },
+    });
     let callCount = 0;
     const fn = mock(async () => {
       callCount++;
@@ -35,46 +84,131 @@ describe("withAutoJoin", () => {
     const result = await withAutoJoin(client, "CPUB", fn);
     expect(result).toBe("retried-ok");
     expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledWith({ channel: "CPUB" });
   });
 
-  test("private channel: join fails with method_not_supported_for_channel_type → descriptive error", async () => {
-    const joinFn = mock(() => {
-      throw makePlatformError("method_not_supported_for_channel_type");
+  test("private channel: info returns internal, join fails with method_not_supported → descriptive error", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+      joinResult: () => {
+        throw makePlatformError("method_not_supported_for_channel_type");
+      },
     });
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
     const fn = mock(() => {
       throw makePlatformError("not_in_channel");
     });
 
     await expect(withAutoJoin(client, "CPRIV", fn)).rejects.toThrow("invite the bot");
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1);
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
-  test("non-not_in_channel error: rethrown without join", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("info failure preserves private-channel invite error from join", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      infoResult: () => {
+        throw makePlatformError("not_in_channel");
+      },
+      joinResult: () => {
+        throw makePlatformError("method_not_supported_for_channel_type");
+      },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CPRIV", fn)).rejects.toThrow("invite the bot");
+    expect(infoFn).toHaveBeenCalledTimes(1);
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test("non-not_in_channel error: rethrown without info or join", async () => {
+    const { client, infoFn, joinFn } = makeClient({});
     const fn = mock(() => {
       throw makePlatformError("channel_not_found");
     });
 
     await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("channel_not_found");
+    expect(infoFn).not.toHaveBeenCalled();
     expect(joinFn).not.toHaveBeenCalled();
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
   test("retry is bounded: second fn error propagates without another join", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
-    // Every call throws not_in_channel, but we only join once and retry once
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
     const fn = mock(() => {
       throw makePlatformError("not_in_channel");
     });
 
     await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("not_in_channel");
     expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1); // no infinite loop
   });
+
+  // --- External channel guard tests ---
+
+  test("external guard: is_ext_shared=true → throws invite error, join not called", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: true },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CEXT", fn)).rejects.toThrow("invite the bot");
+    expect(joinFn).not.toHaveBeenCalled();
+  });
+
+  test("external guard: is_pending_ext_shared=true → throws invite error, join not called", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false, is_pending_ext_shared: true },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CPENDING", fn)).rejects.toThrow("invite the bot");
+    expect(joinFn).not.toHaveBeenCalled();
+  });
+
+  test("external guard: internal public channel (is_ext_shared:false) → join proceeds", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "joined-ok";
+    });
+
+    const result = await withAutoJoin(client, "CPUB", fn);
+    expect(result).toBe("joined-ok");
+    expect(joinFn).toHaveBeenCalledTimes(1);
+  });
+
+  test("external guard: Enterprise Grid org-shared channel (is_ext_shared:false, multiple teams) → join proceeds, no false-positive", async () => {
+    // An internal org-shared channel on Enterprise Grid legitimately lists multiple
+    // internal team IDs. The guard must rely solely on is_ext_shared/is_pending_ext_shared
+    // — not team-ID comparison — to avoid false-positives here.
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "joined-ok";
+    });
+
+    const result = await withAutoJoin(client, "CGRID", fn);
+    expect(result).toBe("joined-ok");
+    expect(joinFn).toHaveBeenCalledTimes(1);
+  });
 });

package/src/tests/workflow-swarm-script.test.ts

@@ -255,6 +255,231 @@ describe("SwarmScriptExecutor", () => {
     expect(scriptStep?.output).toMatchObject({ result: { seen: "mapped-value" } });
   });
 
+  test("exact object token outside swarm-script args is still stringified", async () => {
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "echo",
+          type: "echo",
+          config: { value: "{{trigger.payload}}" },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { payload: { a: 1 } }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const echoStep = steps.find((step) => step.nodeId === "echo");
+
+    expect(run?.status).toBe("completed");
+    expect(echoStep?.status).toBe("completed");
+    expect(echoStep?.output).toEqual({ value: '{"a":1}' });
+  });
+
+  test("{{path}} args: object arg is injected as raw object, not JSON string", async () => {
+    await saveScript(
+      "echo-obj",
+      `export default async (args: { data: Record<string, unknown> }) => ({ isObject: typeof args.data === "object" && !Array.isArray(args.data), keys: Object.keys(args.data ?? {}) });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-obj",
+            args: { data: "{{trigger.payload}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { payload: { a: 1, b: 2 } }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isObject: true, keys: ["a", "b"] } });
+  });
+
+  test("{{path}} args: array arg is injected as raw array, not JSON string", async () => {
+    await saveScript(
+      "echo-arr",
+      `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-arr",
+            args: { items: "{{trigger.list}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { list: ["x", "y", "z"] }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 3 } });
+  });
+
+  test("{{path}} args: empty array is injected as raw empty array with length 0, not '[]' string", async () => {
+    await saveScript(
+      "echo-empty-arr",
+      `export default async (args: { items: string[] }) => ({ isArray: Array.isArray(args.items), length: args.items.length });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-empty-arr",
+            args: { items: "{{trigger.empty}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { empty: [] }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isArray: true, length: 0 } });
+  });
+
+  test("{{path}} args: string scalar arg is injected as the string value", async () => {
+    await saveScript(
+      "echo-str",
+      `export default async (args: { name: string }) => ({ isString: typeof args.name === "string", value: args.name });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-str",
+            args: { name: "{{trigger.ruleName}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(
+      wf,
+      { ruleName: "local-rules/cognitive-complexity" },
+      registry,
+    );
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({
+      result: { isString: true, value: "local-rules/cognitive-complexity" },
+    });
+  });
+
+  test("{{path}} args: number scalar arg is injected as a number, not a string", async () => {
+    await saveScript(
+      "echo-num",
+      `export default async (args: { count: number }) => ({ isNumber: typeof args.count === "number", value: args.count });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-num",
+            args: { count: "{{trigger.maxFiles}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { maxFiles: 3 }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isNumber: true, value: 3 } });
+  });
+
+  test("{{path}} args: boolean scalar arg is injected as a boolean, not a string", async () => {
+    await saveScript(
+      "echo-bool",
+      `export default async (args: { enabled: boolean }) => ({ isBoolean: typeof args.enabled === "boolean", value: args.enabled });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-bool",
+            args: { enabled: "{{trigger.enabled}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { enabled: false }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({ result: { isBoolean: true, value: false } });
+  });
+
+  test("{{path}} args: mixed string template still produces a string via interpolation", async () => {
+    await saveScript(
+      "echo-mixed",
+      `export default async (args: { label: string }) => ({ isString: typeof args.label === "string", value: args.label });`,
+    );
+    const wf = makeWorkflow({
+      nodes: [
+        {
+          id: "script",
+          type: "swarm-script",
+          config: {
+            scriptName: "echo-mixed",
+            args: { label: "rule-{{trigger.ruleName}}" },
+          },
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(wf, { ruleName: "no-explicit-any" }, registry);
+    const run = getWorkflowRun(runId);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const scriptStep = steps.find((step) => step.nodeId === "script");
+
+    expect(run?.status).toBe("completed");
+    expect(scriptStep?.status).toBe("completed");
+    expect(scriptStep?.output).toMatchObject({
+      result: { isString: true, value: "rule-no-explicit-any" },
+    });
+  });
+
   test("fsMode workspace-rw is rejected at config validation with a clear error message", async () => {
     await saveScript("noop", `export default async () => ({ ok: true });`);
     const executor = new SwarmScriptExecutor(deps);

package/src/tests/workflow-template.test.ts

@@ -205,6 +205,23 @@ describe("deepInterpolate", () => {
     expect(unresolved).toEqual([]);
   });
 
+  test("exact object token is stringified by default", () => {
+    const { value, unresolved } = deepInterpolate("{{body}}", { body: { message: "hello" } });
+    expect(value).toBe('{"message":"hello"}');
+    expect(unresolved).toEqual([]);
+  });
+
+  test("exact object token preserves raw value when requested", () => {
+    const body = { message: "hello" };
+    const { value, unresolved } = deepInterpolate(
+      "{{body}}",
+      { body },
+      { preserveRawTokens: true },
+    );
+    expect(value).toBe(body);
+    expect(unresolved).toEqual([]);
+  });
+
   test("mixed array (string + number + boolean)", () => {
     const { value, unresolved } = deepInterpolate(["{{name}}", 42, true, null], {
       name: "Test",

package/src/tools/send-task.ts

@@ -11,10 +11,11 @@ import {
   getTaskById,
   hasCapacity,
 } from "@/be/db";
+import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
-import { AgentTaskSchema, FollowUpConfigSchema } from "@/types";
+import { type AgentTask, AgentTaskSchema, FollowUpConfigSchema } from "@/types";
 import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 
 export const sendTaskInputSchema = z.object({
@@ -103,6 +104,40 @@ export const sendTaskOutputSchema = z.object({
 
 type SendTaskArgs = z.infer<typeof sendTaskInputSchema>;
 
+const TRACKER_OWNERSHIP_TRANSFER_PARENT_STATUSES = new Set([
+  "superseded",
+  "completed",
+  "failed",
+  "cancelled",
+]);
+
+/**
+ * When `send-task` creates a `resume` task whose parent is in a terminal state,
+ * move the parent's `tracker_sync` rows (Linear / Jira / GitHub outbound link)
+ * onto the new resume child so the re-delegated work keeps its external-tracker
+ * completion link. General-correct for any Lead re-delegation of a resume;
+ * specifically it completes the DES-523 tracker chain on the gone-agent path:
+ * original → R1 (pin) → R1 → original (reaper) → original → R2 (here). No-op for
+ * non-resume tasks or when the parent has no tracker_sync rows.
+ */
+function transferTrackerSyncToResumeChild(args: {
+  parentTaskId?: string;
+  taskType?: string;
+  child: AgentTask;
+}): void {
+  if (args.taskType !== "resume" || !args.parentTaskId) return;
+
+  const parent = getTaskById(args.parentTaskId);
+  if (!parent || !TRACKER_OWNERSHIP_TRANSFER_PARENT_STATUSES.has(parent.status)) return;
+
+  const repointed = repointTrackerSyncBySwarmId(parent.id, args.child.id);
+  if (repointed > 0) {
+    console.log(
+      `[send-task] Repointed ${repointed} tracker_sync row(s) from terminal parent ${parent.id.slice(0, 8)} to resume child ${args.child.id.slice(0, 8)}`,
+    );
+  }
+}
+
 export async function sendTaskHandler(
   ctx: ToolCtx,
   {
@@ -278,6 +313,11 @@ export async function sendTaskHandler(
         slackUserId,
         followUpConfig,
       });
+      transferTrackerSyncToResumeChild({
+        parentTaskId: effectiveParentTaskId,
+        taskType,
+        child: newTask,
+      });
 
       return {
         success: true,
@@ -332,6 +372,11 @@ export async function sendTaskHandler(
         slackUserId,
         followUpConfig,
       });
+      transferTrackerSyncToResumeChild({
+        parentTaskId: effectiveParentTaskId,
+        taskType,
+        child: newTask,
+      });
 
       return {
         success: true,
@@ -360,6 +405,11 @@ export async function sendTaskHandler(
       slackUserId,
       followUpConfig,
     });
+    transferTrackerSyncToResumeChild({
+      parentTaskId: effectiveParentTaskId,
+      taskType,
+      child: newTask,
+    });
 
     return {
       success: true,

package/src/tools/templates.ts

@@ -160,3 +160,64 @@ Use \`get-task-details\` with taskId "{{task_id}}" for full details.`,
   ],
   category: "task_lifecycle",
 });
+
+// ============================================================================
+// Reroute-decision follow-up (Lead-routed crash-recovery, DES-523)
+//
+// Created by the heartbeat's stale-resume reaper when a crash-recovery resume
+// was pinned to its original agent but never reclaimed within the grace window
+// (the agent that looked recoverable never returned). Hands the Lead a DECISION
+// task — not the raw work — telling it to re-delegate via `send-task` with an
+// EXPLICIT agentId. The crashed agent's identity is provided as routing context
+// only; the Lead picks who takes over. This work never falls back to the pool.
+// ============================================================================
+
+registerTemplate({
+  eventType: "task.reroute.decision",
+  header: "",
+  defaultBody: `Reroute decision: a crashed worker's task needs a new owner.
+
+Crashed agent: {{original_agent_name}}
+Identity / specialization: {{original_agent_identity}}
+Original task ID: {{original_task_id}}
+Trigger: {{reason}}
+Task: "{{task_desc}}"
+
+Resume generation: {{generation_next}} of {{max_generations}} (max).{{artifacts_block}}
+
+## Your job
+
+The worker that was handling this task crashed and did not come back within the grace window, so its pinned resume was never reclaimed. Pick an agent to take this work over and RE-DELEGATE it — do NOT execute it yourself, and do NOT leave routing to the default.
+
+Use the crashed agent's identity above as context for who was on it and what kind of work it is. You may re-delegate to the same kind of agent, a peer, or whoever you judge appropriate — the choice is yours, but you MUST choose explicitly.
+
+Dispatch via \`send-task\` with ALL of:
+- an explicit \`agentId\` (the chosen worker) — REQUIRED. If you omit it, \`send-task\` auto-routes to the original task's agent, which is the dead worker, and the work re-strands.
+- \`taskType: "resume"\`
+- the tag \`resume-generation:{{generation_next}}\`
+- \`parentTaskId: {{original_task_id}}\`
+- do NOT inherit the original task's \`model\` (the new worker runs on its own).
+
+This work will NOT fall back to the unassigned pool — you are the only re-delegation path.`,
+  variables: [
+    { name: "original_agent_name", description: "Name or ID prefix of the crashed agent" },
+    {
+      name: "original_agent_identity",
+      description:
+        "Identity/specialization slice of the crashed agent (from identityMd), or a placeholder when none is recorded",
+    },
+    { name: "original_task_id", description: "ID of the superseded original task" },
+    { name: "reason", description: "Reroute trigger reason (e.g. crash_recovery)" },
+    { name: "task_desc", description: "Original task description (truncated to 200 chars)" },
+    {
+      name: "generation_next",
+      description: "Next resume generation number (must be set on the dispatched resume)",
+    },
+    { name: "max_generations", description: "Maximum resume generations before budget exhaustion" },
+    {
+      name: "artifacts_block",
+      description: "Formatted attachment list from the original task, or empty string",
+    },
+  ],
+  category: "task_lifecycle",
+});

package/src/workflows/engine.ts

@@ -494,7 +494,7 @@ async function executeStep(
   }
 
   // 4. Deep-interpolate config using local context (not global ctx)
-  const { value: interpolatedValue, unresolved } = deepInterpolate(node.config, interpolationCtx);
+  const { value: interpolatedValue, unresolved } = interpolateNodeConfig(node, interpolationCtx);
   const interpolatedConfig = interpolatedValue as Record<string, unknown>;
   const executionCtx: Record<string, unknown> = { ...ctx, ...interpolationCtx };
 
@@ -709,6 +709,27 @@ export function findReadyNodes(
   });
 }
 
+export function interpolateNodeConfig(
+  node: Pick<WorkflowNode, "type" | "config">,
+  interpolationCtx: Record<string, unknown>,
+): { value: unknown; unresolved: string[] } {
+  if (node.type !== "swarm-script" || !Object.hasOwn(node.config, "args")) {
+    return deepInterpolate(node.config, interpolationCtx);
+  }
+
+  const { args, ...configWithoutArgs } = node.config;
+  const configResult = deepInterpolate(configWithoutArgs, interpolationCtx);
+  const argsResult = deepInterpolate(args, interpolationCtx, { preserveRawTokens: true });
+
+  return {
+    value: {
+      ...(configResult.value as Record<string, unknown>),
+      args: argsResult.value,
+    },
+    unresolved: [...configResult.unresolved, ...argsResult.unresolved],
+  };
+}
+
 // ─── Helpers ───────────────────────────────────────────────
 
 function timeoutPromise(ms: number): Promise<never> {

package/src/workflows/retry-poller.ts

@@ -8,9 +8,8 @@ import {
 import type { RetryPolicy } from "../types";
 import { checkpointStep, checkpointStepFailure } from "./checkpoint";
 import { getSuccessors } from "./definition";
-import { walkGraph } from "./engine";
+import { interpolateNodeConfig, walkGraph } from "./engine";
 import type { ExecutorRegistry } from "./executors/registry";
-import { deepInterpolate } from "./template";
 import { runStepValidation } from "./validation";
 
 let pollerTimeout: ReturnType<typeof setTimeout> | null = null;
@@ -62,7 +61,7 @@ export function startRetryPoller(registry: ExecutorRegistry, intervalMs = 5000):
           const ctx = (run.context ?? {}) as Record<string, unknown>;
 
           // Deep-interpolate config
-          const { value: interpolatedValue } = deepInterpolate(node.config, ctx);
+          const { value: interpolatedValue } = interpolateNodeConfig(node, ctx);
           const interpolatedConfig = interpolatedValue as Record<string, unknown>;
 
           // Get executor and re-run