All said:

the processor has too many cores which is not allowed by Community edition license

So get an official distribution and an official/evaluation license: 
https://wrc.intersystems.com/wrc/coDistEvaluation.csp

set claim=##class(Claim).%OpenId(claimnum)  ; or similar
set line=##class(ClaimLine).%OpenId(linenum) ; or similar
do claim.ClaimLineRel.Insert(line)

now your query should work

This is intentional behavior.
If the routine you changed calls some subroutine it is kept "on the stack"
This is a requirement to have a save return and continuation after the call.

The new version only becomes active after you have left the previous one by QUIT or RETURN.
simpler: if it is gone from the return path. 

You may have only 1 command: in each build
the 2nd overwrites the first

  iris:
    image: intersystemsdc/iris-community:latest
    command: --check-caps false
    container_name: tls-ssl-iris
    networks:
      app_net:
        ipv4_address: 172.16.238.20
    volumes:
      - ./iris-config-files:/opt/config-files
      # Mount certificates files.
      - ./certificates/CA_Server.cer:/usr/irissys/mgr/CA_Server.cer
      - ./certificates/iris_server.cer:/usr/irissys/mgr/iris_server.cer
      - ./certificates/iris_server.key:/usr/irissys/mgr/iris_server.key
    hostname: iris
    # Load the IRIS configuration file ./iris-config-files/iris-config.json
    command: ["-a","sh /opt/config-files/configureIris.sh"] 

this worked as multi-line 

command: 
    - -a
    - sh /opt/config-files/configureIris.sh 
      - --check-caps false

BUT  
         command: ["-a","sh /opt/config-files/configureIris.sh","--check-caps false"]

works as well 
 

in my package GlobalToJSON-ePython-pure
I developed this workaround: 

#; simulate $data() for existence and content
def Ddata(gref):
	val = None
	_d = 11
#; check for subscripts	
	o=gref.order([])
	if o == None:
		_d -= 10
	try:
		val=gref.get([])
	except KeyError:
		#; no value @ top node
		_d -= 1
	return [_d,val]		

I use and just verifiied 

iris.cls(__name__).SetupGame()

The actual GTY is containers.intersystems.com/intersystems/webgateway:2022.1.0.209.0

And there is no :latest defined
 

You may use input redirection as you find it in almost all Dockerfile installations:
 

RUN iris start IRIS \
    && iris session IRIS < iris.script \
    && iris stop IRIS quietly 

and iris.script (as example)

zn "%SYS"
Do ##class(Security.Users).UnExpireUserPasswords("*")
zn "USER"
 

I miss this in your Trigger code:
%ok: A variable used only in trigger code.
If trigger code succeeds, it sets %ok=1.
If trigger code fails, it sets %ok=0.  

see  %ok, %msg, and %oper System Variables

Class Reference of %SYSTEM.Status says:
classMethode IsError(statuscode As %Status) as %Boolean

Returns 1 if the statuscode contains errors. Otherwise, it returns 0.

 So if you get  [res] as  (0,....)  it is an ERROR!  
and therefore the result of IsError should be 1.  It is an Error.

%BI classes date back to Miner (DeepSee-1) and just were left in Caché over a decade at least
while its functionality was replaced by %DeepSee classes more than 10 years ago.

Of course, you can map all %BI.*  classes to some DB where you have R/W access and import it from Caché.
that's about 300 Classes.
BUT:  no one can tell you if they compile correctly
AND: you have to take care of the hidden %bi*.obj (~430) and other deployed code which you can't compile, but import and pray they work.

SO: this doesn't look like a  promising approach.

Therefore I'd suggest migrating from %BI to %DeepSee in Caché first and to IRIS next

just to make your valuable entry visible in browser and email
http://<server-ip>:<smp-port>/api/atelier/
and you get back this nice JSON object:

SOAP is quite specific and critical to data format and structure.
You might extend it, but then Edge Server is the active part and you depend on its regular "broadcast".
If Doc Server should be the active partner I'd rather suggest to use JDBC in Linux.
Your actual $get might be embedded as a Method projected as SQL Procedure that you call.
There exist examples to even execute COS commands by that approach:
see: ObjectScript over ODBC

%SYS.NLS.Locale  is the class to achieve this.
though it's not so funny
seems to be wrapper around ^%NLS and ^%SYS.NLS

Your keywords >90% COS + SAMPLES indicate your background.
if you don't intend to win a prize in a contest adapting some CSP Samples will be fastest. Forget any ZEN.
And just call the CSP class. never the .CSP itself.
what I mean:
NOT http://localhost:56773/csp/samples/form.csp
BUT http://localhost:56773/csp/samples/csp.form.CLS

It's my quick and dirty approach

from:
https://docs.jsonata.org/date-time#:~:text=JSON%20does%20not%20have%20a,%3A45%3A00.000Z%22%20%7D

for ISO 8301 
#1)  your source has to be a %TimeStamp aka. ODBC format
#2) it requires a LogicalToXSD() transformation.

>
write ##class(%Library.TimeStamp).LogicalToXSD($ZDT($Now(),3,,4))
2022-08-27T22:54:48.8953Z

But there is no defined Standard.

if it is a straight 8bit DB  you have the challenge to find out
how characters beyond the primitive 7bit ASCII are stored  e.g. ÀöÜß € ¡¿ è & é ç
is it ISO Latin 1 , 2 ,3 4, 5 ... or any of the horrible Win encondings

2 mistakes: 
#1^$get(node) delivers the content of variable node
but you would expect the result of $get(@node)  using node as global reference

#2) the better way is to use the implicit GET
Set node = $Query(^FromExtraMed(""),1,value)
write value  

it is basically using CPIPE out of a CSP page.
Article Execute Server Commands from Caché / Ensemble / IRIS

for DOCKER:
docker exec -it [-u root] <container-name or -id>  bash
details