agl 43.0.5 → 43.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (216) hide show
  1. package/changelog.md +30 -0
  2. package/dist_serve/bundle.js +5996 -5280
  3. package/dist_serve/bundle.js.map +2 -2
  4. package/dist_serve/bundle.js.third-party-notices.json +30 -30
  5. package/dist_serve/bundle.js.third-party-notices.txt +30 -30
  6. package/dist_serve/third-party-notices.md +1 -1
  7. package/dist_ts/00_commitinfo_data.js +1 -1
  8. package/dist_ts/aglapi/aglapisurface.document.js +805 -10
  9. package/dist_ts/aglapi/interfaces.d.ts +13 -0
  10. package/dist_ts/aglapi/interfaces.js +4 -1
  11. package/dist_ts/classes.authmodels.js +17 -4
  12. package/dist_ts/classes.authstore.js +16 -2
  13. package/dist_ts/classes.claudeharness.d.ts +14 -5
  14. package/dist_ts/classes.claudeharness.js +62 -2
  15. package/dist_ts/classes.cli.d.ts +4 -2
  16. package/dist_ts/classes.cli.js +6 -3
  17. package/dist_ts/classes.codexclientadapter.d.ts +7 -5
  18. package/dist_ts/classes.codexclientadapter.js +38 -3
  19. package/dist_ts/classes.controller.d.ts +19 -2
  20. package/dist_ts/classes.controller.js +234 -27
  21. package/dist_ts/classes.controllermanagement.d.ts +14 -4
  22. package/dist_ts/classes.controllermanagement.js +20 -2
  23. package/dist_ts/classes.gatewayclient.d.ts +115 -0
  24. package/dist_ts/classes.gatewayclient.js +336 -0
  25. package/dist_ts/classes.gatewayclientstore.d.ts +97 -0
  26. package/dist_ts/classes.gatewayclientstore.js +261 -0
  27. package/dist_ts/classes.inferencegateway.d.ts +8 -5
  28. package/dist_ts/classes.inferencegateway.js +62 -19
  29. package/dist_ts/classes.inferencerouter.d.ts +9 -0
  30. package/dist_ts/classes.inferencerouter.js +11 -1
  31. package/dist_ts/classes.inferenceservice.d.ts +9 -0
  32. package/dist_ts/classes.inferenceservice.js +27 -1
  33. package/dist_ts/classes.inferencespend.d.ts +9 -3
  34. package/dist_ts/classes.inferencespend.js +44 -16
  35. package/dist_ts/classes.mcpclient.d.ts +9 -4
  36. package/dist_ts/classes.mcpclient.js +24 -2
  37. package/dist_ts/classes.mcpcontrollerhost.d.ts +3 -1
  38. package/dist_ts/classes.mcpcontrollerhost.js +13 -1
  39. package/dist_ts/classes.mcptools.d.ts +3 -3
  40. package/dist_ts/classes.mcptools.js +42 -4
  41. package/dist_ts/classes.mcpvalidation.js +7 -1
  42. package/dist_ts/classes.opencodeclient.js +3 -1
  43. package/dist_ts/classes.proxycontrol.d.ts +33 -11
  44. package/dist_ts/classes.proxycontrol.js +12 -3
  45. package/dist_ts/classes.proxycontrolclient.d.ts +23 -5
  46. package/dist_ts/classes.proxycontrolclient.js +42 -6
  47. package/dist_ts/classes.proxydaemon.d.ts +8 -6
  48. package/dist_ts/classes.proxydaemon.js +42 -21
  49. package/dist_ts/classes.proxyleaseholder.d.ts +12 -4
  50. package/dist_ts/classes.proxyleaseholder.js +39 -9
  51. package/dist_ts/classes.proxymonitor.d.ts +7 -0
  52. package/dist_ts/classes.proxymonitor.js +13 -1
  53. package/dist_ts/classes.proxystore.d.ts +4 -3
  54. package/dist_ts/classes.proxystore.js +17 -7
  55. package/dist_ts/classes.sessionfeed.d.ts +1 -1
  56. package/dist_ts/classes.trustedproxysecrets.d.ts +2 -0
  57. package/dist_ts/classes.trustedproxysecrets.js +5 -1
  58. package/dist_ts/classes.validation.d.ts +7 -0
  59. package/dist_ts/classes.validation.js +49 -2
  60. package/dist_ts/driver/functions.drivertools.js +2 -2
  61. package/dist_ts/fleet/classes.codexworkers.d.ts +4 -11
  62. package/dist_ts/fleet/classes.codexworkers.js +6 -3
  63. package/dist_ts/fleet/classes.workers.d.ts +25 -13
  64. package/dist_ts/fleet/classes.workers.js +105 -9
  65. package/dist_ts/fleet/functions.workervalidation.d.ts +26 -1
  66. package/dist_ts/fleet/functions.workervalidation.js +40 -11
  67. package/dist_ts/fleet/interfaces.workers.d.ts +17 -11
  68. package/dist_ts/fleet/interfaces.workers.js +10 -1
  69. package/dist_ts/functions.confinedrelay.d.ts +21 -0
  70. package/dist_ts/functions.confinedrelay.js +65 -0
  71. package/dist_ts/functions.controllermanagementsurface.d.ts +4 -0
  72. package/dist_ts/functions.controllermanagementsurface.js +15 -1
  73. package/dist_ts/functions.deviceapi.d.ts +4 -2
  74. package/dist_ts/functions.deviceapi.js +20 -2
  75. package/dist_ts/functions.elicitation.d.ts +49 -0
  76. package/dist_ts/functions.elicitation.js +418 -0
  77. package/dist_ts/functions.gatewaycli.d.ts +24 -0
  78. package/dist_ts/functions.gatewaycli.js +395 -0
  79. package/dist_ts/functions.gatewayroute.d.ts +135 -0
  80. package/dist_ts/functions.gatewayroute.js +366 -0
  81. package/dist_ts/functions.inferencecli.d.ts +3 -3
  82. package/dist_ts/functions.inferencecli.js +62 -10
  83. package/dist_ts/functions.inferencecliarguments.d.ts +9 -2
  84. package/dist_ts/functions.inferencecliarguments.js +59 -10
  85. package/dist_ts/functions.inferencelaunch.d.ts +35 -7
  86. package/dist_ts/functions.inferencelaunch.js +143 -16
  87. package/dist_ts/functions.mcpfleetworkertools.d.ts +63 -70
  88. package/dist_ts/functions.mcpfleetworkertools.js +32 -4
  89. package/dist_ts/functions.proxycapacity.d.ts +50 -0
  90. package/dist_ts/functions.proxycapacity.js +142 -0
  91. package/dist_ts/functions.proxycapacitycli.d.ts +30 -0
  92. package/dist_ts/functions.proxycapacitycli.js +65 -0
  93. package/dist_ts/functions.proxycontract.d.ts +21 -4
  94. package/dist_ts/functions.proxycontract.js +12 -5
  95. package/dist_ts/functions.proxyharnessconfig.d.ts +7 -0
  96. package/dist_ts/functions.proxyharnessconfig.js +11 -1
  97. package/dist_ts/functions.remotecli.d.ts +30 -3
  98. package/dist_ts/functions.remotecli.js +44 -18
  99. package/dist_ts/interfaces.auth.d.ts +25 -4
  100. package/dist_ts/interfaces.auth.js +8 -1
  101. package/dist_ts/plugins.d.ts +2 -0
  102. package/dist_ts/plugins.js +4 -1
  103. package/dist_ts_authswitch/authority-placement.js +3 -17
  104. package/dist_ts_authswitch/authority-usagelimit.d.ts +29 -0
  105. package/dist_ts_authswitch/authority-usagelimit.js +66 -2
  106. package/dist_ts_authswitch/authority-usagewindows.d.ts +6 -0
  107. package/dist_ts_authswitch/authority-usagewindows.js +15 -1
  108. package/dist_ts_interfaces/devices.d.ts +133 -3
  109. package/dist_ts_interfaces/devices.js +3 -2
  110. package/dist_ts_interfaces/elicitations.d.ts +125 -0
  111. package/dist_ts_interfaces/elicitations.js +7 -0
  112. package/dist_ts_interfaces/fleetworkers.d.ts +119 -5
  113. package/dist_ts_interfaces/fleetworkers.js +14 -2
  114. package/dist_ts_interfaces/gateway.d.ts +151 -0
  115. package/dist_ts_interfaces/gateway.js +66 -0
  116. package/dist_ts_interfaces/index.d.ts +3 -0
  117. package/dist_ts_interfaces/index.js +4 -1
  118. package/dist_ts_interfaces/interfaces.d.ts +3 -1
  119. package/dist_ts_interfaces/interfaces.js +2 -2
  120. package/dist_ts_interfaces/management.d.ts +4 -4
  121. package/dist_ts_interfaces/management.js +3 -2
  122. package/dist_ts_interfaces/mcprequests.d.ts +18 -2
  123. package/dist_ts_interfaces/mcprequests.js +3 -1
  124. package/dist_ts_interfaces/nativesessions.d.ts +14 -0
  125. package/dist_ts_interfaces/proxycapacity.d.ts +99 -0
  126. package/dist_ts_interfaces/proxycapacity.js +74 -0
  127. package/dist_ts_interfaces/requests.d.ts +3 -3
  128. package/dist_ts_interfaces/requests.fleetworkers.js +2 -2
  129. package/dist_ts_interfaces/requests.js +1 -1
  130. package/dist_ts_interfaces/requests.promptreply.d.ts +18 -0
  131. package/dist_ts_interfaces/sessionfeed.d.ts +3 -2
  132. package/dist_ts_interfaces/sessionfeed.js +1 -1
  133. package/package.json +5 -4
  134. package/readme.md +267 -26
  135. package/third-party-notices.md +1 -1
  136. package/ts/00_commitinfo_data.ts +1 -1
  137. package/ts/aglapi/aglapisurface.document.ts +804 -9
  138. package/ts/aglapi/interfaces.ts +3 -0
  139. package/ts/classes.authmodels.ts +22 -3
  140. package/ts/classes.authstore.ts +15 -1
  141. package/ts/classes.claudeharness.ts +80 -9
  142. package/ts/classes.cli.ts +7 -3
  143. package/ts/classes.codexclientadapter.ts +41 -5
  144. package/ts/classes.controller.ts +276 -32
  145. package/ts/classes.controllermanagement.ts +40 -7
  146. package/ts/classes.gatewayclient.ts +401 -0
  147. package/ts/classes.gatewayclientstore.ts +272 -0
  148. package/ts/classes.inferencegateway.ts +69 -23
  149. package/ts/classes.inferencerouter.ts +12 -0
  150. package/ts/classes.inferenceservice.ts +27 -0
  151. package/ts/classes.inferencespend.ts +46 -13
  152. package/ts/classes.mcpclient.ts +26 -4
  153. package/ts/classes.mcpcontrollerhost.ts +17 -0
  154. package/ts/classes.mcptools.ts +47 -5
  155. package/ts/classes.mcpvalidation.ts +5 -0
  156. package/ts/classes.opencodeclient.ts +2 -0
  157. package/ts/classes.proxycontrol.ts +43 -13
  158. package/ts/classes.proxycontrolclient.ts +39 -6
  159. package/ts/classes.proxydaemon.ts +57 -27
  160. package/ts/classes.proxyleaseholder.ts +43 -11
  161. package/ts/classes.proxymonitor.ts +12 -0
  162. package/ts/classes.proxystore.ts +21 -8
  163. package/ts/classes.sessionfeed.ts +1 -1
  164. package/ts/classes.trustedproxysecrets.ts +5 -0
  165. package/ts/classes.validation.ts +52 -0
  166. package/ts/driver/functions.drivertools.ts +1 -1
  167. package/ts/fleet/classes.codexworkers.ts +8 -6
  168. package/ts/fleet/classes.workers.ts +101 -17
  169. package/ts/fleet/functions.workervalidation.ts +35 -9
  170. package/ts/fleet/interfaces.workers.ts +11 -4
  171. package/ts/functions.confinedrelay.ts +65 -0
  172. package/ts/functions.controllermanagementsurface.ts +15 -0
  173. package/ts/functions.deviceapi.ts +24 -1
  174. package/ts/functions.elicitation.ts +443 -0
  175. package/ts/functions.gatewaycli.ts +436 -0
  176. package/ts/functions.gatewayroute.ts +429 -0
  177. package/ts/functions.inferencecli.ts +62 -13
  178. package/ts/functions.inferencecliarguments.ts +56 -9
  179. package/ts/functions.inferencelaunch.ts +143 -16
  180. package/ts/functions.mcpfleetworkertools.ts +34 -4
  181. package/ts/functions.proxycapacity.ts +191 -0
  182. package/ts/functions.proxycapacitycli.ts +104 -0
  183. package/ts/functions.proxycontract.ts +17 -4
  184. package/ts/functions.proxyharnessconfig.ts +11 -0
  185. package/ts/functions.remotecli.ts +56 -20
  186. package/ts/interfaces.auth.ts +29 -4
  187. package/ts/plugins.ts +5 -0
  188. package/ts_authswitch/authority-placement.ts +2 -15
  189. package/ts_authswitch/authority-usagelimit.ts +84 -1
  190. package/ts_authswitch/authority-usagewindows.ts +13 -0
  191. package/ts_interfaces/devices.schema.json +476 -2
  192. package/ts_interfaces/devices.ts +146 -2
  193. package/ts_interfaces/elicitations.ts +148 -0
  194. package/ts_interfaces/fleetworkers.ts +96 -4
  195. package/ts_interfaces/gateway.ts +242 -0
  196. package/ts_interfaces/index.ts +3 -0
  197. package/ts_interfaces/interfaces.ts +3 -1
  198. package/ts_interfaces/management.ts +6 -4
  199. package/ts_interfaces/mcprequests.ts +19 -0
  200. package/ts_interfaces/nativesessions.ts +16 -0
  201. package/ts_interfaces/proxycapacity.ts +162 -0
  202. package/ts_interfaces/requests.fleetworkers.ts +1 -1
  203. package/ts_interfaces/requests.promptreply.ts +22 -0
  204. package/ts_interfaces/requests.ts +4 -0
  205. package/ts_interfaces/sessionfeed.ts +3 -2
  206. package/ts_web/00_commitinfo_data.ts +1 -1
  207. package/ts_web/classes.browserpresentation.ts +13 -5
  208. package/ts_web/classes.elicitationcards.ts +106 -0
  209. package/ts_web/classes.nativesessionstate.ts +38 -1
  210. package/ts_web/elements.accounts.ts +40 -113
  211. package/ts_web/elements.configurationpane.ts +24 -37
  212. package/ts_web/elements.devices.ts +4 -17
  213. package/ts_web/elements.fleetworker.ts +27 -2
  214. package/ts_web/elements.flexlimitstrip.ts +21 -70
  215. package/ts_web/elements.harnesscontrollerapp.ts +159 -186
  216. package/ts_web/functions.sessionchat.ts +5 -0
package/readme.md CHANGED
@@ -334,6 +334,7 @@ agl proxy service install [--port 4100]
334
334
  agl proxy service enable
335
335
  agl proxy service start
336
336
  agl proxy status [--json]
337
+ agl proxy capacity --provider anthropic --wait --max-seconds 3600 # wait until the Claude pool has room for new work
337
338
  agl proxy credential opencode --delivery file # the proxy keeps it in <AGL home>/proxy/credentials/opencode
338
339
  agl proxy credential mytool --write ~/.config/mytool/agl-proxy.key
339
340
  agl proxy credential codex --rotate
@@ -344,6 +345,8 @@ agl proxy run claude --provider openai --model <catalog-model> --
344
345
  agl proxy run opencode --model <catalog-model> -- run 'Explain this repository'
345
346
  agl proxy confined run -- docker run --rm --user "$(id -u):$(id -g)" -i <image> claude -p # Claude Code in a container
346
347
  agl proxy confined run --provider openai -- docker run --rm --user "$(id -u):$(id -g)" -i <image> claude -p
348
+ agl proxy confined run --harness codex -- docker run --rm --user "$(id -u):$(id -g)" <image> \
349
+ node /run/agl-proxy-relay/agl-relay.mjs -- codex exec … # Codex in a container
347
350
  agl proxy confined end <run id>
348
351
  ```
349
352
 
@@ -401,6 +404,52 @@ session of a client that names no credential goes to (`nextPlacement`), the late
401
404
  sessions placed or moved with why (`recentPlacements`), the count of usage reports handed to the account service and
402
405
  of hand-overs that failed, and exits non-zero while the proxy is down.
403
406
 
407
+ #### Pool capacity
408
+
409
+ `agl proxy capacity` answers whether a pool has room for new work, as one answer from the proxy, judged on the same
410
+ readings as `agl proxy status` -- for a script that starts confined runs (`agl proxy confined run`) only while a pool can
411
+ take them. The MCP tool `proxy_capacity` (`agl mcp`) gives the same answer to every caller, through the controller; it
412
+ never waits.
413
+
414
+ ```sh
415
+ agl proxy capacity [--provider anthropic|openai] [--min-headroom 15] [--json]
416
+ agl proxy capacity --provider openai --min-headroom 40 --wait [--max-seconds 1800]
417
+ ```
418
+
419
+ - **Members.** A pool counts its subscription sign-ins that have not lapsed and whose held reading states a counted plan,
420
+ however old the reading; API keys never count:
421
+
422
+ | Pool | Counts |
423
+ | --- | --- |
424
+ | `anthropic` (Claude accounts) | plan `max` only (both Max tiers: Anthropic names them `claude_max`) |
425
+ | `openai` (ChatGPT accounts) | every plan but `free` |
426
+
427
+ - **Headroom.** A member that takes work now adds its headroom: how far its fullest counted window is below its maximum
428
+ usage (100 when unset), the same `headroom` `agl proxy status` shows. A member that takes no work now -- cooling down
429
+ after a provider 429, at its limit or reserve, refused by its provider, or unavailable (a stale reading, a sign-in or
430
+ payment problem) -- adds 0. The pool's `room` is the members' headroom summed.
431
+ - **Binding window and growth.** Each member names the window its headroom is bound by (`binding`) and when that headroom
432
+ next grows (`growsAt`, to `growsTo`): the binding window's reset -- a five-hour window that binds grows long before a
433
+ weekly window that does not -- or the moment the member takes work again (its 429 rest's end, its provider's retry time,
434
+ the reset of the windows its limit is held by). `null` when nothing can grow it or the moment is unknown (a stale
435
+ reading names `recheckAt`, when the account service reads it next; a sign-in or payment problem names none).
436
+ - **Verdict.** `open` when `room` reaches the minimum (`--min-headroom`, any whole percent, 15 unless given) and no provider
437
+ 429 hit a member within five minutes; the proxy keeps that record in memory from its start (`observedSince`), so for
438
+ its first five minutes it cannot say none came. Otherwise `wait` with a `reason` -- `room` (too little), `provider-429`
439
+ (`last429At` within five minutes) or `quiet-unobserved` (the proxy started less than five minutes ago) -- and `until`
440
+ with `seconds`: the first moment the members' readings foresee enough room once the pool is quiet. Usage spent meanwhile
441
+ is not foreseen, so that moment is the earliest the room can be there; with no such moment foreseen (a minimum beyond
442
+ every member's whole headroom, a pool without members), `until` and `seconds` are `null`.
443
+
444
+ The text names each member by the first 12 characters of its account id, never its label or email; `--json` and the MCP
445
+ tool answer `{ at, observedSince, pools: [{ provider, minHeadroom, room, members: [{ accountId, plan, state, headroom,
446
+ binding: { name, durationSeconds, usedPercent, estimated, resetAt }, growsAt, growsTo, recheckAt }], last429At, verdict }]
447
+ }`. It exits 0 when every pool it reports is open, 2 when one waits, and 1 when the proxy is down, runs an older AGL (it
448
+ names the release and the restart onto the installed one, as `agl proxy status` does) or cannot reach its account
449
+ service. `--wait` (with `--provider`) asks again after the pool's `seconds`, at most a minute apart, until the pool is
450
+ open (0) or `--max-seconds` ran out (2), and prints the last answer; without `--max-seconds` it waits as long as it
451
+ takes.
452
+
404
453
  #### Usage reads
405
454
 
406
455
  The accounts service reads each account's usage from the provider once every 10 minutes and no more often, on its
@@ -787,10 +836,11 @@ request on its own side cannot be seen in the request or its answer, so AGL cann
787
836
 
788
837
  #### Confined containers
789
838
 
790
- `agl proxy confined run` runs Claude Code in a Docker container that reaches AGL through one route only: the proxy's
791
- confined listener, a Unix socket alone in a directory of its own (`agl-proxy-confined/proxy.sock` beside the proxy's
792
- control socket; `agl proxy status` names it). Each run is served from one pool, chosen when it starts: the Claude pool,
793
- or with `--provider openai` the ChatGPT pool. The listener serves the three endpoints Claude Code uses --
839
+ `agl proxy confined run` runs Claude Code, or with `--harness codex` Codex (see
840
+ [Codex in a confined container](#codex-in-a-confined-container)), in a Docker container that reaches AGL through one
841
+ route only: the proxy's confined listener, a Unix socket alone in a directory of its own (`agl-proxy-confined/proxy.sock`
842
+ beside the proxy's control socket; `agl proxy status` names it). Each Claude Code run is served from one pool, chosen when
843
+ it starts: the Claude pool, or with `--provider openai` the ChatGPT pool. The listener serves the three endpoints Claude Code uses --
794
844
  `GET /anthropic/v1/models`, `POST /anthropic/v1/messages` and `POST /anthropic/v1/messages/count_tokens` -- exactly as
795
845
  the loopback listener serves Claude Code on the run's pool: on the Claude pool sent on to Anthropic as Claude Code sent
796
846
  them, on the ChatGPT pool translated (see [Claude Code on the ChatGPT pool](#claude-code-on-the-chatgpt-pool), where
@@ -805,7 +855,7 @@ agl proxy confined run -- docker run --rm --user "$(id -u):$(id -g)" -i <image>
805
855
  claude -p --model claude-opus-5-5 --output-format json < prompt.txt
806
856
  agl proxy confined run --provider openai -- docker run --rm --user "$(id -u):$(id -g)" -i <image> \
807
857
  claude -p --output-format json < prompt.txt # on the ChatGPT pool's default model
808
- agl proxy status # names the confined listener and lists the runs by id, with their pools
858
+ agl proxy status # names the confined listener and lists the runs by id, with their harnesses and pools
809
859
  agl proxy confined end <run id> # ends a run's credential at once
810
860
  ```
811
861
 
@@ -861,14 +911,139 @@ with the reason; it does the same when the proxy does not hand the credential ba
861
911
 
862
912
  Downgrade: an earlier proxy refuses to start while its store keeps a confined run's credential its check of the kept
863
913
  leases does not know: any confined run's for a release before confined runs, a ChatGPT-pool run's for one before
864
- ChatGPT-pool runs (41.0.1 and earlier). Let every confined run end before downgrading; if an earlier proxy's start
865
- already failed, start this release once with no confined run going and wait out the 60-second reclaim window, which
866
- ends the kept credential, then downgrade. A launcher older than ChatGPT-pool runs still runs Claude-pool runs on this
867
- proxy; an older proxy refuses this release's `--provider openai`, as it issues no ChatGPT-pool run.
914
+ ChatGPT-pool runs (41.0.1 and earlier), a Codex run's for one before Codex runs (43.0.5 and earlier). Let every confined
915
+ run end before downgrading (`agl proxy status` lists them, `agl proxy confined end <run id>` ends one); if an earlier
916
+ proxy's start already failed, start this release once with no confined run going and wait out the 60-second reclaim
917
+ window, which ends the kept credential, then downgrade. A launcher older than ChatGPT-pool runs still runs Claude-pool
918
+ runs on this proxy; an older proxy refuses this release's `--provider openai`, as it issues no ChatGPT-pool run, and an
919
+ older proxy refuses `--harness codex`, which the launcher reports as a proxy older than Codex runs. An older launcher's
920
+ `agl proxy status` lists a Codex run by its pool alone (`ChatGPT pool`).
921
+
922
+ #### Codex in a confined container
923
+
924
+ `agl proxy confined run --harness codex -- docker run …` runs Codex CLI (`codex exec`) in a container on the same route
925
+ (AGL-1614). A Codex run is of the ChatGPT pool alone (`--provider openai` may name it; `--provider anthropic` is
926
+ refused) and is served by the pool's ChatGPT accounts alone, never by an OpenAI API key: when none of them can take a
927
+ request it is refused as Codex is on the loopback listener (503 without one, the usage limit and its reset when each is at
928
+ its limit) and never sent to a key. Its credential is a lease whose sessions are those of the
929
+ client `confined-codex`, so its requests are placed, moved and counted (token usage under `confined-codex`) like any
930
+ other client's of the pool, and like a Claude Code run's it ends with the container and survives a proxy restart.
931
+ `agl proxy status` names such a run `Codex on the ChatGPT pool (ChatGPT accounts only)`, and its JSON
932
+ `confinedRuns[].harness` is `codex` (`claude` for a Claude Code run).
933
+
934
+ The confined listener serves a Codex run two endpoints, as the loopback listener serves Codex on the ChatGPT pool:
935
+ `GET /openai/v1/models` (with `client_version`, Codex's own catalog of the pool's ChatGPT accounts for that release;
936
+ without it the pool's models in OpenAI's list shape) and `POST /openai/v1/responses`. It refuses every other path and
937
+ method -- every `/anthropic/` path, `/openai/v1/messages`, `/openai/v1/responses/compact`, `/memories/…`,
938
+ `/realtime/…` among them -- and every request that asks to upgrade its connection with 404 before anything is read or
939
+ routed. A Responses request that declares a hosted tool, a tool the provider runs (`web_search`, `file_search`,
940
+ `code_interpreter`, `image_generation`, a remote `mcp` server, a hosted `shell` or `tool_search`; in `tools` or in the
941
+ tools its input adds), or whose `tool_choice` names one (also within `allowed_tools`), is refused with 400
942
+ `hosted_tool_refused` before it is routed; Codex's client tools (functions,
943
+ custom tools such as `apply_patch`, the local shell, `tool_search` with `execution: "client"`) pass. A Codex run's
944
+ refusals take OpenAI's error shape (`{"error": {"type": …, "code": …, "message": …}}`), as does any refusal on the
945
+ listener of an `/openai/` path before its credential is known.
946
+
947
+ Codex has no Unix-socket transport for its model provider, so a Codex run adds AGL's relay. The command writes
948
+ `agl-relay.mjs` (plain Node.js, no dependencies) into a directory of the run's own (0700, in the temporary directory),
949
+ mounts it read-only at `/run/agl-proxy-relay`, and removes it when the container exits. The container's command runs
950
+ Codex through it: `node /run/agl-proxy-relay/agl-relay.mjs -- codex exec …`. The relay listens on `127.0.0.1:4100`
951
+ inside the container (set `AGL_PROXY_RELAY_PORT` for another port), pipes each connection byte for byte to the confined
952
+ socket and to nothing else (a connection the socket does not take is closed), then runs the command, passes it SIGTERM,
953
+ SIGINT and SIGHUP, and exits with its status (128 plus the signal's number for a command a signal ended, 127 for one
954
+ that could not start). The image needs `node`; the container needs no network, and no bridge or host address is used.
955
+ Besides the two mounts the command passes by name `AGL_PROXY_SOCKET` (`/run/agl-proxy/proxy.sock`, which the relay
956
+ connects to) and `MODELPROFILE_PROXY_TOKEN` (the run's credential, for Codex's provider command), and no model variable:
957
+ Codex reads the pool's catalog, and its command names the model. It removes from the environment `docker` runs with
958
+ every variable that would give Codex another login, route or home -- `OPENAI_API_KEY`, `OPENAI_BASE_URL`,
959
+ `OPENAI_ORGANIZATION`, `OPENAI_PROJECT`, `OPENAI_IDENTITY_TOKEN_FILE`, `OPENAI_WORKLOAD_IDENTITY_CONTEXT`,
960
+ `OPENAI_FEDERATION_RULE_ID`, `CODEX_API_KEY`, `CODEX_ACCESS_TOKEN`, `CODEX_AUTH`, `CODEX_REMOTE_AUTH_TOKEN`,
961
+ `CODEX_REMOTE_TOKEN`, `CODEX_HOME`, `CODEX_CA_CERTIFICATE`, `CODEX_OSS_BASE_URL`, `CODEX_OSS_PORT` -- and Claude Code's,
962
+ so a `-e NAME` of one passes nothing; the container names its own `CODEX_HOME` with a value. The socket and the relay are
963
+ the proxy user's, so the container runs as that uid (`--user`), or as root under rootless Docker.
964
+
965
+ A Codex run's container needs a network namespace of its own (`--network none`, or Docker's default when it names none):
966
+ the relay's `127.0.0.1` port is that namespace's loopback. The command refuses `--network host` and `--network
967
+ container:…` in every spelling Docker takes (`--network=…`, `--net …`, `--net=…`, and Docker's long form of
968
+ comma-separated `key=value` fields, such as `name=host,alias=x`), and a long-form value whose network it cannot read
969
+ (no `name` field, a field without `=`, or quotes): on the host's network the relay's
970
+ port would sit on the host's loopback beside the proxy's own `4100`, and with `AGL_PROXY_RELAY_PORT` set it would open
971
+ the confined route to every process of the host over TCP; another container's network would open it to that container.
972
+
973
+ The run's credential is in the container's environment, so every process in the container that runs as the same uid
974
+ can read it, from the relay's or Codex's `/proc/<pid>/environ` as from its own environment. That is the exposure of a
975
+ Claude Code run's `ANTHROPIC_AUTH_TOKEN` as well: the container is the boundary, and the credential serves only the
976
+ confined route and ends with the run.
977
+
978
+ Codex's provider in the container is the one `agl proxy run codex` gives Codex on the host, on the relay's port:
979
+
980
+ ```toml
981
+ model_provider = "agl_proxy" # never "openai", which Codex reserves
982
+
983
+ [model_providers.agl_proxy]
984
+ name = "AGL Proxy"
985
+ base_url = "http://127.0.0.1:4100/openai/v1"
986
+ wire_api = "responses"
987
+ supports_websockets = false
988
+ auth = { command = "printenv", args = ["MODELPROFILE_PROXY_TOKEN"], refresh_interval_ms = 0 }
989
+ ```
990
+
991
+ The kit's side, as `test/e2e/e2e.proxyconfined.node.ts` runs it with Codex CLI 0.164.0 (its standalone static build) in
992
+ `debian:bookworm-slim` with `--network none --read-only --cap-drop ALL --security-opt no-new-privileges`, the host's
993
+ Node mounted:
994
+
995
+ ```sh
996
+ agl proxy confined run --harness codex -- docker run --rm --network none --read-only --cap-drop ALL \
997
+ --security-opt no-new-privileges --user "$(id -u):$(id -g)" --tmpfs /tmp \
998
+ --mount type=bind,source=<codex home>,target=/codex-home --env CODEX_HOME=/codex-home --env HOME=/tmp \
999
+ --mount type=bind,source=<managed_config.toml>,target=/etc/codex/managed_config.toml,readonly <image> \
1000
+ node /run/agl-proxy-relay/agl-relay.mjs -- codex exec --json -o /tmp/last-message.txt --strict-config \
1001
+ --skip-git-repo-check --ignore-user-config --ignore-rules --dangerously-bypass-approvals-and-sandbox \
1002
+ -m <model> -c model_reasoning_effort=<effort> '<prompt>'
1003
+ ```
1004
+
1005
+ ```toml
1006
+ # /etc/codex/managed_config.toml, read-only: the provider block above, and
1007
+ web_search = "disabled"
1008
+ check_for_update_on_startup = false
1009
+
1010
+ [features]
1011
+ image_generation = false
1012
+ apps = false
1013
+ plugins = false
1014
+
1015
+ [analytics]
1016
+ enabled = false
1017
+
1018
+ [feedback]
1019
+ enabled = false
1020
+
1021
+ [shell_environment_policy]
1022
+ exclude = ["MODELPROFILE_PROXY_TOKEN"]
1023
+ ```
1024
+
1025
+ - The model and the reasoning effort go on the command line (`-m`, `-c model_reasoning_effort=…`); everything else
1026
+ comes from `/etc/codex/managed_config.toml`, which Codex 0.164.0 reads on a read-only root beside
1027
+ `--ignore-user-config` (no `$CODEX_HOME/config.toml`) and `--ignore-rules` (no execpolicy `.rules` files);
1028
+ `--strict-config` refuses any key Codex does not know, and every key above passes it.
1029
+ - `CODEX_HOME` is the session's own, on a writable mount: Codex keeps the session's rollout transcript there
1030
+ (`sessions/…/*.jsonl`, with the prompt and the answer), which a provenance audit can collect after the run.
1031
+ - Hosted tools stay off in Codex (`web_search = "disabled"`, `features.image_generation = false`, apps and plugins off);
1032
+ the route refuses a request that declares one with the 400 anyway. How Codex reports that refusal in a turn is not
1033
+ verified here.
1034
+ - `shell_environment_policy.exclude` is Codex's setting for keeping the run's credential out of the commands the model
1035
+ runs; the e2e case runs no command, so that is not verified here.
1036
+ - `codex exec` reads standard input when it is not a terminal and adds it to the prompt; give it `/dev/null` or the
1037
+ prompt there.
1038
+ - Releases: verified with Codex CLI 0.164.0 (2026-10-23 on npm). Upstream 0.163.0 (2026-10-15) and
1039
+ `@tempfix/codex 0.162.0-tempfix.1` are not verified here; that their flags and keys match is unverified, and
1040
+ `--strict-config` names any key a release does not know.
1041
+ - The mount boundary, hooks and what the container may read are the kit's: AGL adds the two read-only mounts and the two
1042
+ variables, nothing else.
868
1043
 
869
1044
  ## Native Codex Harness
870
1045
 
871
- Choose **New → Chat session** and pick the Codex harness to use Codex inside AGL. Native threads support text and reasoning streaming, tool activity, the Codex model and reasoning-effort catalog, command and file approvals, ordinary user-input questions, interruption, history pagination, rename, archive, and deletion. AGL Ask/Yolo controls apply to the exact pending native approval request; approvals never outlive its server request.
1046
+ Choose **New → Chat session** and pick the Codex harness to use Codex inside AGL. Native threads support text and reasoning streaming, tool activity, the Codex model and reasoning-effort catalog, command and file approvals, ordinary user-input questions, MCP elicitations (see [MCP elicitations](#mcp-elicitations)), interruption, history pagination, rename, archive, and deletion. AGL Ask/Yolo controls apply to the exact pending native approval request; approvals never outlive its server request.
872
1047
 
873
1048
  Install Codex CLI 0.156.0 or newer and sign in using Codex before starting AGL. The local connection uses the existing Codex app-server control socket when present. This is the WebSocket-over-Unix transport described by the [Codex app-server protocol](https://developers.openai.com/codex/app-server), at `CODEX_HOME/app-server-control/app-server-control.sock` (the default home is `~/.codex`). Codex publishes that path as a link to a socket in its private per-user directory, and AGL attaches only to that published link. AGL owns only its connection to that shared server, and accepts it only when the Codex home the server reports in `initialize` is AGL's own. If nothing exists at the path, AGL starts its own `codex app-server --listen stdio://` child, unless Codex's managed daemon serves this home: its state under `CODEX_HOME/app-server-daemon/` (`daemon.lock`, `settings.json`, `daemon.pid` or the older `app-server.pid`) proves it, and AGL then waits for the daemon instead of starting a second writer for the same threads. Codex never removes that state, so start the daemon with `codex app-server daemon start`; AGL rejoins it on its own or on **Reconnect**. Anything else there, including a socket bound directly at the path or a link whose socket is gone after the daemon died, is reported as a connection failure, as is a published socket that does not answer; AGL never starts a private server beside it. Set `AGL_CODEX_EXECUTABLE` to an absolute executable path when Codex is not on the controller's `PATH`; an explicit absolute `CODEX_HOME` is forwarded to the owned child.
874
1049
 
@@ -909,7 +1084,7 @@ Choose **New → Chat session** and pick **Claude Code** to run Claude Code insi
909
1084
  Claude Code runs on the AGL inference proxy's Claude pool, never on a key or login of its own. The controller takes one lease of the pool and starts every Claude Code process with only the lease's endpoint and credential (`ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`). Its requests therefore go through the proxy's account placement, usage reads and limits like all other Claude traffic. A process runs with the controller's own Claude Code configuration folder (its `CLAUDE_CONFIG_DIR`, by default `~/.claude`), where Claude Code stores the transcript. While the proxy cannot give a lease, a send fails with `harness_unavailable`. When the lease ends, the processes on it are closed, and the next message starts one on a new lease.
910
1085
 
911
1086
  - **Models.** The model picker offers the models the proxy's Claude pool lists, which are those every account of the pool offers. The effort picker offers the efforts the catalog states for the selected model, narrowed to those Claude Code lists for it (`supportedModels`) once one of its processes has listed the model. A process lists Claude Code's aliases and the model it started with, so a model no process has listed yet keeps the catalog's efforts. The pool names no default model. A conversation without a choice runs on the default model saved in **Settings** (`settings.defaultModels`) while the pool offers it, else on Claude Code's own default, which AGL does not name (see [Models And Provider Accounts](#models-and-provider-accounts)). If the pool does not offer Claude Code's own default, the turn fails with Claude Code's message. Changing the model or effort applies from the next turn.
912
- - **Ask and Yolo.** Ask runs Claude Code in its default permission mode. Every tool call Claude Code asks about becomes a permission card, answered with **Allow** or **Reject**. Yolo makes AGL answer each card once, automatically; it never switches Claude Code to `bypassPermissions`. `AskUserQuestion` becomes a question card and `ExitPlanMode` a permission card carrying the plan.
1087
+ - **Ask and Yolo.** Ask runs Claude Code in its default permission mode. Every tool call Claude Code asks about becomes a permission card, answered with **Allow** or **Reject**. Yolo makes AGL answer each card once, automatically; it never switches Claude Code to `bypassPermissions`. `AskUserQuestion` becomes a question card and `ExitPlanMode` a permission card carrying the plan. An MCP server's request for input becomes an elicitation card, which Yolo never answers (see [MCP elicitations](#mcp-elicitations)).
913
1088
  - **Transcript.** Thinking, text and tool calls stream into the transcript as Claude Code produces them. A `Task` subagent is shown as its tool card. The transcript is Claude Code's own: AGL reads it from Claude Code's store, so a conversation reopens with its history after a reload, a controller restart or an upgrade. Its next message resumes the same Claude Code conversation.
914
1089
  - **Steer and Queue.** While AGL runs a turn, **Steer** hands the message to Claude Code, which takes it in between tool rounds or, if the turn ends first, runs it as its own turn right after. **Queue** keeps a follow-up in AGL's queue until the conversation is idle (see [Steering and pending messages](#steering-and-pending-messages)). A steer that a stop or a failure cancelled before Claude Code took it is held for the owner, as for Codex.
915
1090
  - **Stop and failures.** **Stop** interrupts the running turn and keeps the partial reply. Where Claude Code supports it (`interrupt_cancel_queued_v1`), it also cancels the messages queued inside Claude Code. A failed turn leaves the conversation in the error state with Claude Code's message until the next turn starts, as a failed Codex turn does. A Claude Code process that ends during a turn fails that turn.
@@ -918,14 +1093,29 @@ Claude Code runs on the AGL inference proxy's Claude pool, never on a key or log
918
1093
 
919
1094
  Claude Code conversations are separate from [Claude chats](#claude-chats), which are terminal resources running the `claude` CLI.
920
1095
 
1096
+ ## MCP elicitations
1097
+
1098
+ An MCP server that a Claude Code conversation or a Codex thread runs can ask the owner for input (MCP `elicitation/create`; Claude Code hands it to AGL through the Agent SDK's `onElicitation`, Codex as `mcpServer/elicitation/request`). AGL holds each request as an elicitation card beside the conversation's permission and question cards, and the conversation needs input until the request is answered or withdrawn. Nothing answers an elicitation on the owner's behalf: auto-accept (Yolo, globally or for the conversation) answers permissions only.
1099
+
1100
+ Each card is one of three kinds, named by its `mode`, and carries the server's name, its message and when it asked:
1101
+
1102
+ - **Form** (`form`). The card shows the form's fields in the server's order: text (optionally an email address, an absolute URI, a date or a date and time, with lengths in characters), a number or a whole number with inclusive bounds, a yes or no, a single choice or several choices among strings, each choice with its value and label. This is MCP's flat primitive subset. **Send** (the accept) sends the values, typed: numbers as numbers, a yes or no as a boolean, several choices as a list, an empty optional field left out. The card checks each value as you type; the controller checks them again against the form before anything reaches the server and refuses a reply that does not fit (`invalid_request`, naming the field and its rule, never the value), so the server keeps waiting. A refusal shows on the card with its reason; the card keeps what you entered and takes an answer again. **Decline** refuses the request; **Cancel** dismisses it without a decision.
1103
+ - **URL** (`url`). The card shows the address as plain text, exactly as the server sent it: no link, and AGL never opens or fetches it. Visit it yourself if you trust it, then **Mark as done** (the accept) to report that you have done it; the answer carries no content. Decline and Cancel work as for a form.
1104
+ - **What AGL cannot collect** (`unsupported`). Another mode (Codex's `openai/form`, `openaiForm`, `openai/userVerification`, any later one), a nested object, a list of anything but string choices, an unknown string format, a malformed form or one larger than a card shows is never a form with a field left out: it is a card with the reason, and only **Decline** or **Cancel** answer it; it has no Accept.
1105
+
1106
+ - **Withdrawn requests.** A request the server or the harness withdraws (Claude Code's cancellation, Codex's `serverRequest/resolved`, a Claude Code process that ends) leaves no card, and a reply to it is refused (`not_found`). A Codex answer goes back on the JSON-RPC id Codex asked with.
1107
+ - **Claude Code's own hooks come first.** Claude Code runs the hooks of the settings it loads for AGL (user, project and local): an `Elicitation` hook can answer a request before AGL sees it, so no card appears, and an `ElicitationResult` hook sees the owner's answer and can change it before it reaches the server. Such hooks are the owner's own configuration; AGL neither adds nor removes them.
1108
+ - **Where it is answered.** Only the owner answers, through the browser (`controller.elicitation.reply`, `controller.nativesession.elicitation.reply`) or a paired device (`device.elicitation.reply`), audited as `elicitation.reply` with the session and request only. Agents have no way to answer an elicitation: no MCP tool, CLI command or fleet operation does. The values the owner enters go to Claude Code or Codex for the MCP server and nowhere else in AGL: no log, audit record, event, transcript entry of AGL's or error text carries them.
1109
+ - **Session reads.** Every session read carries `elicitations` beside `permissions` and `questions`, empty while none is pending and for harnesses that hand AGL none (OpenCode, Flex).
1110
+
921
1111
  ## MCP Server
922
1112
 
923
- The installed `agl` command includes a unified stdio MCP server that combines 84 tools on one connection:
1113
+ The installed `agl` command includes a unified stdio MCP server that combines 97 tools on one connection:
924
1114
 
925
1115
  - Nine CrossHarness tools for explicit OpenCode and Codex harness-server connections.
926
1116
  - Six system inspection and reclaim-planning tools.
927
1117
  - Thirteen durable `tstask` tools.
928
- - Fifty-six AGL controller tools for projects, task discovery, control and messaging, models, scratchpads, resource lifecycle and attachment, managed jobs, driver fleet operations, the shared project ticket board, and challenge-only worker enrollment.
1118
+ - Sixty-nine AGL controller tools for projects, task discovery, control and messaging, models, scratchpads, resource lifecycle and attachment, managed jobs, driver fleet operations, the shared project ticket board, the inference proxy's pool capacity, and challenge-only worker enrollment.
929
1119
 
930
1120
  Configure an MCP host to execute:
931
1121
 
@@ -933,7 +1123,7 @@ Configure an MCP host to execute:
933
1123
  agl mcp --port 4097
934
1124
  ```
935
1125
 
936
- `--port` takes precedence over `AGL_CONTROLLER_PORT`; otherwise the controller port defaults to `4097`. `agl mcp` starts and exposes all 84 tools without a running AGL controller. Only the AGL controller tools require a ready controller on the configured port; the CrossHarness, system, and durable-task tools remain available independently. `agl mcp` requires Linux x64 with Node.js `>=24.12.0 <27`.
1126
+ `--port` takes precedence over `AGL_CONTROLLER_PORT`; otherwise the controller port defaults to `4097`. `agl mcp` starts and exposes all 97 tools without a running AGL controller. Only the AGL controller tools require a ready controller on the configured port; the CrossHarness, system, and durable-task tools remain available independently. `agl mcp` requires Linux x64 with Node.js `>=24.12.0 <27`.
937
1127
 
938
1128
  On supported systems, a ready controller publishes a process- and generation-fenced private loopback endpoint under `$AGL_HOME/runtime/mcp`. The descriptor and bearer token remain owner-only runtime state. They are discovered and verified automatically; do not copy them into MCP configuration. The endpoint accepts only the explicitly registered, bounded AGL methods and is removed before controller shutdown proceeds.
939
1129
 
@@ -955,7 +1145,7 @@ A caller is one of three subjects:
955
1145
  - **Runtime** — a shared harness server. OpenCode runs one server per controller and addresses MCP servers per directory rather than per task, so an OpenCode-launched caller is identified as that runtime, not as one chat: it may act for its own tasks in the project named in each request. This is deliberately coarser than a terminal subject, and narrowing it requires per-task MCP servers upstream in OpenCode.
956
1146
  - **Task** — a chat AGL manages as a task, acting only for that task in that task's project. The subject exists in the model and is enforced everywhere, but **no task credential is issued yet**: AGL cannot stamp a per-task credential into a harness that shares one server across tasks. Until OpenCode can carry a task id into the MCP server it launches, OpenCode chats act through the runtime subject.
957
1147
 
958
- Reading is open to every caller that holds the descriptor token, identified or not: `controller_status`, `projects_list`, `sessions_list`, `context_resolve`, `models_list`, `session_read` and `session_scratchpad_read` behave exactly as before. That keeps the cross-harness workflow intact, where a chat running outside any AGL terminal — and therefore without an AGL identity — inspects AGL-managed tasks. `resources_list` shows the unattached project resources to such a caller.
1148
+ Reading is open to every caller that holds the descriptor token, identified or not: `controller_status`, `projects_list`, `sessions_list`, `context_resolve`, `models_list`, `session_read` and `session_scratchpad_read` behave exactly as before, and `proxy_capacity` answers the inference proxy's pool capacity (see [Pool capacity](#pool-capacity)), naming accounts by id alone. That keeps the cross-harness workflow intact, where a chat running outside any AGL terminal — and therefore without an AGL identity — inspects AGL-managed tasks. `resources_list` shows the unattached project resources to such a caller.
959
1149
 
960
1150
  Writing is not open. Task mutations (`session_send`, `session_scratchpad_update`, `session_model_set`, `session_rename`, `session_archive`, `session_stop`) require the calling chat to be the task itself, or its shared harness runtime; a terminal caller owns no task and an unidentified host owns nothing. Resource mutations, `project_add`, `session_create` and `browser_action` require an AGL identity as well, and so does every job tool: jobs belong to a project, and any identified caller of that project may inspect, wait for or stop them. Every caller must still run as the controller's local OS user; a remote MCP process cannot access this local endpoint without a separate authenticated transport.
961
1151
 
@@ -1530,11 +1720,31 @@ read or fenced. Running a failed refresh again finishes it on the recorded succe
1530
1720
  it asks for the profile that successor runs: the same `--profile`, or none for a successor on the
1531
1721
  recorded profile.
1532
1722
 
1533
- The fourteen MCP tools are `fleet_worker_start`, `fleet_worker_adopt`, `fleet_worker_resolve_lost`, `fleet_worker_reconfirm`, `fleet_worker_steer`,
1723
+ The sixteen MCP tools are `fleet_worker_start`, `fleet_worker_adopt`, `fleet_worker_resolve_lost`, `fleet_worker_reconfirm`, `fleet_worker_steer`,
1534
1724
  `fleet_worker_report`, `fleet_worker_stop`, `fleet_worker_archive`, `fleet_worker_refresh`,
1535
- `fleet_worker_move`, `fleet_worker_list`, `fleet_worker_status`, `fleet_worker_native_message` and `fleet_watch`. They share
1725
+ `fleet_worker_move`, `fleet_worker_list`, `fleet_worker_get`, `fleet_worker_status`, `fleet_worker_job_wait`,
1726
+ `fleet_worker_native_message` and `fleet_watch`. They share
1536
1727
  the local-owner capability boundary. Mutation and report tools return job handles immediately;
1537
- the CLI polls jobs and prints their final outcome. Worker status accepts the job `id`.
1728
+ the CLI polls jobs and prints their final outcome. Worker status accepts the job `id`: a fleet
1729
+ operation job, not a host job (`job_status`). `fleet_worker_job_wait` waits for that job until it
1730
+ succeeds or fails, at most `timeoutMs` (240000); `timedOut` tells which, and neither a timeout nor
1731
+ an abandoned wait cancels the job. Jobs are transient: a job the controller no longer holds (a
1732
+ controller restart, or eviction once 512 are held) is `JOB_UNAVAILABLE`, never failed; read the
1733
+ worker with `fleet_worker_get` then.
1734
+
1735
+ MCP `fleet_worker_list` returns summaries, newest created first, in pages of `limit` (1-100,
1736
+ default 50): id, name, harness, profile id, ticket, state, native id, cwd, `updatedAt`, `observed`
1737
+ (the native status, the newest turn's `outcome` and the `nativeWait` last observed) and `fence`
1738
+ flags (an unresolved dispatch with its action and since, a lost or reconfirmed dispatch, a recorded
1739
+ error), without attribution, proof or error bodies. `total`, `fenced` (unresolved dispatches) and
1740
+ `failed` (recorded errors and failed turn outcomes) count the whole filtered set, so a page never
1741
+ hides a fence. Continue with `nextCursor` and the same filter (`archived`, `ticketKey`, `state`,
1742
+ `harness`); a cursor of another filter is `LIST_CURSOR_MISMATCH` and one after a worker the
1743
+ registry no longer holds as it was `LIST_CURSOR_STALE`, never a silent restart. `view: 'full'`
1744
+ returns every full record unpaged, as `agl fleet worker list` and the private request do by
1745
+ default. `fleet_worker_get` (`name` or `id`) returns one worker's full record, archived ones
1746
+ included, with the native status, turn outcome and start, native wait and excerpt the controller
1747
+ last observed.
1538
1748
  Worker mutations and reports require a ticket key; mismatched associations refuse before
1539
1749
  native effects. Refresh and moves retain the ticket and the associating driver's attribution.
1540
1750
  Existing unassociated bindings remain readable and may be explicitly adopted after proving
@@ -1609,6 +1819,9 @@ the rest counted), and, for a report the fleet runs, its worker's transcript wit
1609
1819
  The transcript is read-only and projected like the worker's harness conversation
1610
1820
  (`controller.fleet.worker.read`); a read returns the newest page of turns, and `earlier` says
1611
1821
  whether older ones exist; while the worker works, the modal reads again every 3 seconds. The
1822
+ worker's own state shows over its transcript, here and wherever a worker opens: a failed last
1823
+ turn as an error with the limit that ended it, an interrupted one and a wait in Claude Code or
1824
+ Codex itself (which AGL cannot answer) as notes; the report's status line stays the report's. The
1612
1825
  steer box messages the report with the owner's own message (`controller.directreport.message`):
1613
1826
  the fleet delivers it through the dispatch fence of the report's `driverTicketKey`, headed
1614
1827
  `[Message from the user via the AGL Driver view; not from your driver]`, and the request
@@ -2670,7 +2883,7 @@ A removal that fails is resumed with backoff, and it resumes across restarts and
2670
2883
 
2671
2884
  ### Conversations
2672
2885
 
2673
- The sidebar is the session list (`controller.sessionfeed.list`, then `sessionfeed` deltas). It holds the sessions of every harness across every registered project: the conversations AGL tracks, the Flex and OpenCode sessions of a project folder that AGL does not track yet, the threads on the shared Codex app-server, Claude terminals, and the Claude Code sessions of the host's home and of the fleet profiles' own homes. A conversation that is tracked, run by a fleet worker and present on the Codex server is one row. A row needs input when AGL holds a question or permission for it, or when the harness signals that it waits in its own client, which AGL cannot answer: a Codex thread waiting on an approval, on user input or on a flag AGL does not know, a Claude Code `requires_action` without a card, or a Claude Code job whose process its inventory lists as waiting without the job having failed (a job listed blocked whose turn ended, status idle, is completed); such a row carries `nativeWait` with its reason (`agl feed list --json`). A fleet worker whose newest turn failed (a failed Codex turn, with its limit kind, or a failed Claude Code job) is failed until a newer turn starts, which moves the row, or until Claude Code lists the job working, blocked or done again; an interrupted turn's row is completed with `interrupted`. Each row shows its harness, its state (working, needing input, completed or failed), its name, the last reply's opening for tracked conversations and workers, the tickets it is linked to, and when it last changed; a newly created session joins at the feed's next pass. Selecting a row opens it: a tracked conversation opens, an untracked one is tracked first, a Claude terminal opens in the Terminals view, a session a fleet worker runs opens that worker, and any other Claude Code session or Codex thread opens where it runs, whatever its directory (see [Sessions outside every project](#sessions-outside-every-project)). Opening a session never registers a project: the project matters only when a new session is started. A row AGL cannot open says why in the sidebar, for example that its project is no longer registered. A ticket chip opens that ticket on the board. Right-click, the ContextMenu key or Shift+F10 opens the row's menu: a conversation's own menu, **Rename** and **Terminate** for a terminal, or **Copy session id**, **Copy directory** and **Make direct report…** (see [Driver session](#driver-session)) for a native session. Conversations archived in AGL leave the list.
2886
+ The sidebar is the session list (`controller.sessionfeed.list`, then `sessionfeed` deltas). It holds the sessions of every harness across every registered project: the conversations AGL tracks, the Flex and OpenCode sessions of a project folder that AGL does not track yet, the threads on the shared Codex app-server, Claude terminals, and the Claude Code sessions of the host's home and of the fleet profiles' own homes. A conversation that is tracked, run by a fleet worker and present on the Codex server is one row. A row needs input when AGL holds a question, permission or MCP elicitation for it, or when the harness signals that it waits in its own client, which AGL cannot answer: a Codex thread waiting on an approval, on user input or on a flag AGL does not know, a Claude Code `requires_action` without a card, or a Claude Code job whose process its inventory lists as waiting without the job having failed (a job listed blocked whose turn ended, status idle, is completed); such a row carries `nativeWait` with its reason (`agl feed list --json`). A fleet worker whose newest turn failed (a failed Codex turn, with its limit kind, or a failed Claude Code job) is failed until a newer turn starts, which moves the row, or until Claude Code lists the job working, blocked or done again; an interrupted turn's row is completed with `interrupted`. Each row shows its harness, its state (working, needing input, completed or failed; a row waiting in its harness's own client says where to answer, such as "Approve in Codex" or "Answer in Claude Code", and a completed row whose last turn was interrupted says "Interrupted"), its name, the last reply's opening for tracked conversations and workers, the tickets it is linked to, and when it last changed; a newly created session joins at the feed's next pass. Selecting a row opens it: a tracked conversation opens, an untracked one is tracked first, a Claude terminal opens in the Terminals view, a session a fleet worker runs opens that worker, and any other Claude Code session or Codex thread opens where it runs, whatever its directory (see [Sessions outside every project](#sessions-outside-every-project)). Opening a session never registers a project: the project matters only when a new session is started. A row AGL cannot open says why in the sidebar, for example that its project is no longer registered. A ticket chip opens that ticket on the board. Right-click, the ContextMenu key or Shift+F10 opens the row's menu: a conversation's own menu, **Rename** and **Terminate** for a terminal, or **Copy session id**, **Copy directory** and **Make direct report…** (see [Driver session](#driver-session)) for a native session. Conversations archived in AGL leave the list.
2674
2887
 
2675
2888
  A failed row of any kind leads its menu with **Acknowledge and remove** (`controller.sessionfeed.acknowledge`). The controller records, for the owner, that row's failure as of the time the row shows, and the row leaves the Failed group until the session moves again: new activity or a new failure brings it back. Nothing else changes: the session and its transcript, a fleet worker's dispatch fence and error, its tickets and the unknown-dispatch record stay as they are, and nothing is sent, resumed or stopped. The acknowledgements are kept in the controller's database and survive a restart; a row that changed since it was listed, is no longer failed or is gone is refused. From the command line the owner does the same with `agl feed` (see [CLI](#cli)); no agent, worker or MCP tool can acknowledge, so a worker never hides its own failure. The composer's open-sessions action shows the sidebar and moves focus into the list. The list header offers three actions.
2676
2889
 
@@ -3117,6 +3330,7 @@ agl feed list [--state failed] [--json] | acknowledge <row-id> --updated-at <ms>
3117
3330
  agl foreground [options]
3118
3331
  agl temp-password [--port 4097] [--ttl-hours 24]
3119
3332
  agl remote set|unset|secret import [--port 4097] [options]
3333
+ agl remote gateway enrol|status|sync|remove [--port 4097] [options]
3120
3334
  agl help
3121
3335
  agl --version
3122
3336
  ```
@@ -3387,7 +3601,7 @@ agl start --port 4097 # prints the setup code for https://agl.example.com
3387
3601
  - A passkey belongs to its RP ID. When the origin or RP ID changes, the passkey is removed and every temporary password revoked, so nothing that signed in to the old origin signs in to the new one. The next `agl start` prints a fresh setup code to its terminal, never to a log: enroll the passkey at the new origin with it. Running `remote set` again with only other gateway sources keeps the passkey.
3388
3602
  - `--gateway-source` names an address the proxy's connections arrive from (IPv4 or IPv6, repeatable, at most 16). Without one only a reverse proxy on this host reaches the controller.
3389
3603
  - A paired device signs the public origin (see Paired Devices), so a changed origin removes every paired device as well; `remote set` says how many. Changing only the gateway sources or the RP ID keeps them.
3390
- - `agl remote unset --port 4097` moves the port back to `http://localhost:4097` (RP ID `localhost`): it removes the passkey and every paired device, revokes every temporary password and forgets the trusted-proxy secret. The next start prints a setup code.
3604
+ - `agl remote unset --port 4097` moves the port back to `http://localhost:4097` (RP ID `localhost`): it removes the passkey and every paired device, revokes every temporary password and forgets the trusted-proxy secret. The next start prints a setup code. It is refused while the controller is enrolled with a gateway (see [AGL's own route on a dcrouter gateway](#agls-own-route-on-a-dcrouter-gateway)): `agl remote gateway remove` comes first. A `remote set` to another hostname is refused while enrolled as well.
3391
3605
  - Both refuse while anything listens on the port, take start admission (no upgrade runs meanwhile), run as the local OS user (the trust `agl temp-password` has) and are audited as `remote.set` or `remote.unset`, attempted and then succeeded or failed, with the OS user and process and the public origin and RP ID the move goes from and to (never a secret).
3392
3606
  - A start never moves a port: one that asks for another `--public-origin`, `--rp-id` or TLS mode is refused and names `agl remote set`. A new port can still start behind a reverse proxy on this host directly: `agl start --public-origin https://agl.example.com --rp-id agl.example.com --behind-tls-proxy`.
3393
3607
 
@@ -3444,9 +3658,35 @@ sudo ufw status verbose # the allow is listed before the deny, and no broader
3444
3658
 
3445
3659
  The gateway source is the address the proxy's connections arrive from on this host. A router that translates addresses between the proxy and this host puts its own address there, and every host behind it then passes the source check: route without translation, or put the proxy on this host's network.
3446
3660
 
3661
+ ### AGL's own route on a dcrouter gateway
3662
+
3663
+ A controller behind a [dcrouter](https://code.foss.global/serve.zone/dcrouter) gateway keeps its own route there, as Onebox and Cloudly keep theirs: it is a gateway client of type `custom` and writes one route for the hostname of its public origin. The route ends TLS at the gateway with the gateway's own certificate, forwards to the controller with the trusted-proxy secret, passes WebSockets, is reachable from private networks only (source profile `LOCAL NETWORK`, directly at the hub and over its VPN, never through RemoteIngress) and gets the gateway's own DNS record, unproxied. Every field is sent on every sync: the gateway fills an omitted one from what it stored or a default.
3664
+
3665
+ Enrol the stopped controller once, with a short-lived gateway admin token (dcrouter Ops UI → API Tokens, scope `tokens:manage`) in a file:
3666
+
3667
+ ```sh
3668
+ agl stop --port 4097
3669
+ agl remote set --port 4097 --public-origin https://agl.example.com --gateway-source 192.0.2.10
3670
+ agl remote gateway enrol --port 4097 \
3671
+ --gateway-url https://gateway.example.com:3000 \
3672
+ --target-host 192.0.2.66 < ~/gateway-admin-token
3673
+ rm ~/gateway-admin-token # and revoke the token in the Ops UI
3674
+ agl start --port 4097
3675
+ ```
3676
+
3677
+ - `enrol` reads the admin token from a pipe or file, never from a terminal, and uses it once to provision the gateway client `agl-<installation>-<port>` (derived from the controller database and the port, so every controller has its own and keeps it) with exactly this route's hostname and target and the capabilities `readRoutes`, `syncRoutes` and `syncDnsRecords`. The gateway issues a credential for that client, which AGL seals with the TPM and stores before it asks the gateway to confirm it; the gateway then revokes the client's older credentials. The admin token is never stored, logged or printed. `--gateway-url` is the gateway's API base URL (requests go to `<url>/typedrequest`): `https`, plain `http` only for a gateway on loopback (`127.0.0.0/8`, `::1`, `localhost`), since every request carries a credential, and no option skips certificate verification; a stored URL is held to the same rule at every sync and `remove` (problem `gateway_url_insecure`). A gateway that answers with a redirect is not followed: the request fails (`unreachable`), so the configured URL is the only one that ever sees a token. `--target-host` is the address the gateway reaches this host by (a loopback address for a gateway on this host; any other needs a `--gateway-source`); both are kept for the next `enrol`.
3678
+ - A confirmation whose answer is lost is asked for again at once; if the gateway still does not answer, `enrol` fails and the next `agl remote gateway enrol --port 4097` finishes it with the stored credential, without a token. Run `enrol` with a new admin token to renew the credential, for example after an admin changed the client's policy. Enrolling with another gateway, or for another hostname a leftover move left behind, first deletes the route of the earlier one.
3679
+ - The running controller syncs the route in the background once it is ready; its start never waits for the gateway. A sync checks the credential, deletes the client's routes for anything the controller no longer serves (an earlier hostname, which only a leftover leaves: an interrupted change or a move an earlier release made after a rollback; the sync then fails with `origin_changed` until `enrol`), writes the route with the trusted-proxy secret as a request header the gateway sets (`requestHeaders`, sent only to a gateway that announces `routes.requestHeaders`, dcrouter 34.5.0 or later; an earlier gateway would refuse the whole route), and reads it back: the route must name the secret header and, when the gateway names the route's source profile, be bound to `LOCAL NETWORK`. A gateway before dcrouter 34.5.0 names no profile, and the status then says the profile is unverified. A failure a later sync can fix (the gateway does not answer, its DNS provider is unavailable) is retried after 30 s, doubling up to 15 min, jittered; a written route is synced again after six hours. A gateway without `routes.requestHeaders` (one before dcrouter 34.5.0, or one downgraded) is waited for (`waiting`, "gateway lacks routes.requestHeaders: waiting"): no route is written, the controller asks again after 30 s doubling up to 15 min, then at every six-hour sync and every `sync`, and writes the route with the header as soon as the gateway announces it. Every sync sends the header, also to a route the gateway already holds, so a route whose stored header a gateway dropped gets it back at the next sync. A failure only the operator can fix stops the syncs until the next start or `sync`: a revoked or stale credential (enrol again), a refused route or one read back without the secret header or bound to another profile, and the DNS outcomes `record-conflict`, `zone-unmanaged` and `target-invalid`. `manual-satisfied` (records the gateway does not own already serve the route) counts as synced and shows as not owned.
3680
+ - `agl remote gateway status [--json]` shows the enrolment, the last sync, the problem and the next sync, from the running controller or, while it is stopped, from its database; `agl status --json` carries the same as `gateway`. Neither the browser nor a paired device sees it.
3681
+ - `agl remote gateway sync [--rotate]` asks the running controller to sync now, over its loopback management endpoint and only for a process of the controller's own OS user, which the controller proves from the kernel. `--rotate` first rotates the trusted-proxy secret: the previous one stays valid until a sync wrote the new one to the route and read it back, and is refused from then on. Nothing rotates the secret on its own.
3682
+ - `agl remote gateway remove` deletes the route and its DNS record on the gateway and forgets the credential (a gateway client cannot revoke its own; an admin deletes the client under Access → Gateway Clients, which revokes it). `agl remote unset` is refused while the controller is enrolled, and so is an `agl remote set` to another hostname (one that keeps the hostname, with another RP ID or gateway sources, is not): run `agl remote gateway remove`, then `agl remote set`, then `agl remote gateway enrol`. When the gateway cannot be reached or refuses the credential, `agl remote gateway remove --abandon` forgets the enrolment without it and prints the route key (`custom:<client>:controller-<port>:<hostname>`) and the client it left for an admin to delete.
3683
+ - `enrol`, `remove` and `--abandon` run against a stopped controller under start admission, like `remote set`; all of them and `sync` are audited as `remote.gateway.enrol`, `remote.gateway.remove`, `remote.gateway.abandon` and `remote.gateway.sync`, with the OS user and process and the route they acted on (never a credential).
3684
+
3685
+ The gateway client keeps its record in `agl_controller_gateway_clients`. An earlier release starts with it in place and leaves it alone, and 41.1.0 and later read the `remote.gateway.*` audit events as types they do not know.
3686
+
3447
3687
  ## Paired Devices
3448
3688
 
3449
- A phone or a desktop app pairs with a controller and then reaches it as a device: it lists the session feed, reads a session's transcript, sends a message to a session and answers its permissions and questions. A device reaches nothing else: no terminals, settings, accounts, tickets, browsers or files. It connects through the controller's public HTTPS origin (Remote Browser Access), so a controller in local mode pairs no device.
3689
+ A phone or a desktop app pairs with a controller and then reaches it as a device: it lists the session feed, reads a session's transcript, sends a message to a session and answers its permissions, questions and MCP elicitations. A device reaches nothing else: no terminals, settings, accounts, tickets, browsers or files. It connects through the controller's public HTTPS origin (Remote Browser Access), so a controller in local mode pairs no device.
3450
3690
 
3451
3691
  ### Pairing a device
3452
3692
 
@@ -3466,9 +3706,9 @@ Settings → Devices lists every paired device with its model, when it paired, w
3466
3706
 
3467
3707
  ### The device protocol
3468
3708
 
3469
- The device API is its own contract, separate from the browser's: `ts_interfaces/devices.ts` in the package, and the same contracts as JSON Schema in `ts_interfaces/devices.schema.json` (each contract's request and response, and every named type they reach). A device asks `device.hello` for the device protocol version (`major` 1, `minor` 0) and speaks one major; within it, changes only add. Apps generate their clients from these files.
3709
+ The device API is its own contract, separate from the browser's: `ts_interfaces/devices.ts` in the package, and the same contracts as JSON Schema in `ts_interfaces/devices.schema.json` (each contract's request and response, and every named type they reach). A device asks `device.hello` for the device protocol version (`major` 1, `minor` 1) and speaks one major; within it, changes only add. Minor 1 added MCP elicitations: `elicitations` in every `device.session.read` (empty while none is pending; each one a `form` with its `fields`, a `url` or an `unsupported` request with its `reason`) and `device.elicitation.reply`. A device does not tell the controller its minor, so a client ignores keys it does not know; the iOS (HarnessKit) and Android clients of minor 0 do. Apps generate their clients from these files.
3470
3710
 
3471
- - Before it is authenticated a connection reaches `device.hello`, `device.pair`, `device.auth.challenge` and `device.auth.prove`, under the controller's limits for unauthenticated requests: per connection, and in total together with the browser's sign-in requests. After that it reaches `device.sessions.list`, `device.session.read`, `device.session.send`, `device.permission.reply` and `device.question.reply`, under the limits of the owner's browser. A device never reaches a method of the browser, and the browser never one of a device. A connection is one or the other for its whole life: a connection signed in as the browser cannot authenticate as a device, and one a device authenticated cannot sign in as the browser.
3711
+ - Before it is authenticated a connection reaches `device.hello`, `device.pair`, `device.auth.challenge` and `device.auth.prove`, under the controller's limits for unauthenticated requests: per connection, and in total together with the browser's sign-in requests. After that it reaches `device.sessions.list`, `device.session.read`, `device.session.send`, `device.permission.reply`, `device.question.reply` and `device.elicitation.reply`, under the limits of the owner's browser. A device never reaches a method of the browser, and the browser never one of a device. A connection is one or the other for its whole life: a connection signed in as the browser cannot authenticate as a device, and one a device authenticated cannot sign in as the browser.
3472
3712
  - The feed is the sidebar's session feed without terminal rows, host directories or tickets. A transcript page reduces a tool call to its name, title and status; its input and output stay on the controller. `device.session.read` without `before` returns the newest page, sized by the controller whatever `limit` says; with `before` it returns the next older page of `limit` messages (1 to 50, default 20). A device names a session only by the feed's row id, and reaches only what the feed lists.
3473
3713
  - A message from a device is a direct message (it queues behind a running turn), never the browser's shared draft. A native session AGL does not write to (another process runs it, a fleet worker owns it) refuses it, as it refuses the browser.
3474
3714
  - The controller pushes a device an allowlist of events in their own shape: feed changes, a session's change, its streaming text (snapshots and exact deltas) and a resynchronization request. Every other event, and every event about a session the feed does not list, stays on the controller. A device that falls behind by 256 events or 4 MiB is resynchronized alone.
@@ -3479,18 +3719,19 @@ The device API is its own contract, separate from the browser's: `ts_interfaces/
3479
3719
  - Local mode binds the controller to loopback only, and so does TLS-proxy mode without a gateway source. With one, a request from off loopback needs a configured gateway source address and the trusted-proxy secret, and only loopback connects without an `Origin`.
3480
3720
  - The trusted-proxy secret is generated and TPM2-sealed in the controller's database; it is never read from the environment, written to a file or logged.
3481
3721
  - Only `agl remote`, run by the local OS user against a stopped controller, changes a port's public origin, RP ID, TLS mode or gateway sources, and a changed origin or RP ID removes the passkey (a changed origin every paired device too).
3482
- - A paired device holds its own key; the controller stores only its public key. A device reaches only the device scope (feed, bounded reads, direct sends, permission and question answers), each connection proves the key over a fresh nonce, and revoking a device closes its connections at once. Pairing codes are single-use, live five minutes in memory only, and pairing is refused in local mode.
3722
+ - A paired device holds its own key; the controller stores only its public key. A device reaches only the device scope (feed, bounded reads, direct sends, permission, question and elicitation answers), each connection proves the key over a fresh nonce, and revoking a device closes its connections at once. Pairing codes are single-use, live five minutes in memory only, and pairing is refused in local mode.
3483
3723
  - The private OpenCode server always remains on loopback and uses a generated per-process password.
3484
3724
  - Application RPC starts only after the exact TypedSocket package-major handshake.
3485
3725
  - The management endpoint (`/management/typedrequest`, used by the CLI and the upgrade worker) answers only an HTTP `POST` of `application/json` from a loopback peer (`127.0.0.1` or `::1`), addressed to `127.0.0.1:<port>`, with no `Origin` and no forwarding header (`Forwarded`, `X-Forwarded-*`, `X-Real-IP`, `X-Harness-Controller-Proxy-Secret`), so a browser or a request a proxy forwards is refused, also in proxy mode. It serves only the status read and the upgrade methods; each upgrade method authorises itself against the upgrade token and its one-time grant, as it does over the socket, and every upgrade request counts against the controller's global unauthenticated preflight limit.
3486
3726
  - Client-managed connection tags are disabled; authentication and routing use server-owned peer state.
3487
3727
  - Setup attempts are globally rate limited before enrollment.
3488
3728
  - Permission auto-accept is an explicit server policy, never an assumption based on an open browser.
3489
- - Questions are never auto-answered.
3729
+ - Questions are never auto-answered, and neither are MCP elicitations.
3490
3730
  - Unknown, malformed, concurrent, or unverifiable lifecycle state fails closed.
3491
3731
  - The inference proxy's confined listener is a Unix socket of the proxy's user alone; it accepts only confined runs'
3492
3732
  credentials and serves them only Claude Code's three endpoints of the run's pool, the Claude pool or, translated, the
3493
- ChatGPT pool's ChatGPT accounts.
3733
+ ChatGPT pool's ChatGPT accounts, or a Codex run Codex's catalog and Responses endpoint of the ChatGPT pool's ChatGPT
3734
+ accounts, without hosted tools.
3494
3735
 
3495
3736
  The global **auto-accept permissions (yolo)** setting replies once to pending permissions across registered projects and writes those replies to the audit log. Each conversation also has a run-local Ask/Yolo switch. For an active managed OpenCode root, that switch covers its currently active direct children under the same exact family authority. For an active managed Flex root, it covers admitted descendants through their exact active parent-run authority chain; a relationship alone grants nothing. Terminal children are never auto-accepted. Disabling either policy seals new automatic replies and drains already admitted replies before returning. Neither mode creates persistent broad provider grants.
3496
3737
 
@@ -50,7 +50,7 @@ inventory.
50
50
  ## Monaco Editor 0.55.2
51
51
 
52
52
  The workspace editor's Monaco files are served unchanged from the installed
53
- `@design.estate/monaco-editor` 0.55.2 package that `@design.estate/dees-catalog` 24.0.2
53
+ `@design.estate/monaco-editor` 0.55.2 package that `@design.estate/dees-catalog` 24.2.0
54
54
  depends on, at `/monaco-editor/min/vs/` on the controller's own origin. AGL does not
55
55
  bundle or modify them. This maintained fork updates the embedded DOMPurify to 3.4.17;
56
56
  its `SECURITY-FORK.json` records the upstream commits and source hashes, and the package
@@ -3,6 +3,6 @@
3
3
  */
4
4
  export const commitinfo = {
5
5
  name: 'agl',
6
- version: '43.0.5',
6
+ version: '43.2.0',
7
7
  description: 'Agent Gateway Layer for OpenCode, FlexHarness, and Codex sessions'
8
8
  }