Dialplan redundantly looping through contexts

Asterisk Asterisk Support
1

As the title indicates, I have a situation where a few channels traverse two contexts and one macro. At the (seemingly) logical end of this traversal, Asterisk starts it over from the top. This action and resulting entry point into the dialplan is initiated and specified by an AMI request.

EDIT: I use Dial in call-target where I could have just used Originate, and specified Playback as the application to run on pickup. I tried it this way and it does work, well in fact. The problem is that CALLERID(all/num/name) don’t work with Originate, and even setting a value to the CallerID header in the AMI request does not work, hence me trying to do this with Dial instead of Originate. If I could just get CalllerID working with Originate my problem would also be solved.

AMI request:

Action: Originate
Channel: Local/s@broadcast/n
Exten: s
Priority: 1
Variable: batchid=44,targetcount=1,targets_resolved=SIP/Some_Phone_000@my.voip.host,targets_unresolved=100,filename=4zzskrlqn2p.wav

And the dialplan code:

[broadcast]
;***
; NOTES
;   This receives a tilde delimited list of broadcast targets and 
;   the path of a sound file.  Each target is then called and
;   Playback is used to convey the message.
;***
  exten => s, 1, NoOp(=-=-=- ${EXTEN}@${CONTEXT} -=-=-=)

  ;Make some of the AMI supplied channel variables
  ; multiply inheritable:
  exten => s, n, Set(__batchid=${batchid})
  exten => s, n, Set(__filename=${CUT(filename,".",1)})

  ;Construct dial string and array of targets to call:
  exten => s, n, Set(i=0)
  exten => s, n, While($[${i} < ${targetcount}])
  exten => s, n, Set(i=$[${i}+1])
  exten => s, n, Set(target_resolved=${CUT(targets_resolved,"~",${i})})
  exten => s, n, Set(target_unresolved=${CUT(targets_unresolved,"~",${i})})
  ;Construct the target_array_resolved that the worker threads will acces, basically
  ; the next two lines just put commas before every array element except the first:
  exten => s, n, ExecIf($["${i}" = "1"]?Set(__target_array_resolved=${target_resolved}))
  exten => s, n, ExecIf($["${i}" != "1"]?Set(__target_array_resolved=${target_array_resolved},${target_resolved}))
  ;Put commas before each array element except the first:
  exten => s, n, ExecIf($["${i}" = "1"]?Set(__target_array_unresolved=${target_unresolved}))
  exten => s, n, ExecIf($["${i}" != "1"]?Set(__target_array_unresolved=${target_array_unresolved},${target_unresolved}))
  ;Put "&Local/" before every call target except the first one:
  exten => s, n, ExecIf($["${i}" = "1"]?Set(dialstring=Local/${i}@call-target))
  exten => s, n, ExecIf($["${i}" != "1"]?Set(dialstring=${dialstring}&Local/${i}@call-target))
  exten => s, n, EndWhile
  
  ;Separate the calling of individual targets
  ; into their own threads:
  exten => s, n, Dial(${dialstring},,)
  exten => s, n, Hangup()

[call-target]
;***
; NOTES
;   This context represents a worker thread, that can fire
;   off broadcast calls to a specific target.  The id of
;   the call target is the same as the rank of the worker
;   thread.  The only way to pass the worker rank in is
;   via the extension.  This rank is used to access just
;   the portion of the target_array relavant to the worker
;   (clearly it's different for each worker).
;***
  ;Here the extension is used to identify the array
  ; index of the call target.  Currently we can handle
  ; handle up to 999 targets per batch:
  exten => _Z, 1, Set(targetindex=${EXTEN})
  exten => _Z, n, Goto(call-target,s,1)
  exten => _Z, n, Hangup()
  exten => _ZX, 1, Set(targetindex=${EXTEN})
  exten => _ZX, n, Goto(call-target,s,1)
  exten => _ZX, n, Hangup()
  exten => _ZXX, 1, Set(targetindex=${EXTEN})
  exten => _ZXX, n, Goto(call-target,s,1)
  exten => _ZXX, n, Hangup()

  exten => s, 1, NoOp(=-=-=- ${EXTEN}@${CONTEXT} -=-=-=)
  exten => s, n, Set(_target_resolved=${CUT(target_array_resolved,",",${targetindex})})
  exten => s, n, Set(_target_unresolved=${CUT(target_array_unresolved,",",${targetindex})})
  exten => s, n, Set(CALLERID(num)=2025551234)
  exten => s, n, Set(CALLERID(name)=CID)
  exten => s, n, Dial(${target_resolved},,M(onAnswer)) ; target_resolved looks like "SIP/Some_phone_000@my.voip.host"

  exten => s, n, Hangup()

[macro-onAnswer]
;***
; NOTES
;   This macro executes when the remote end picks
;   up the call.  When they do, use Playback to
;   convey the message to them.  Once complete
;   we're done.
;***
  exten => s, 1, NoOp(=-=-=- ${EXTEN}@${CONTEXT} -=-=-=)
  exten => s, n, Playback(${filename})
  exten => s, n, Answer()
  exten => s, n, MacroExit()

When the above contexts/macro execute, I watch the output in the CLI. I except things to end at the console output

However, the entire series of context is started over again:

As you can see, after the MacroExit, we’re back at s@broadcast:1 and on through the whole thing 1 more time, causing phones to ring twice. Why is this occurring?