Repository navigation
v1.16.0
A security and correctness release over 1.15.0 (GHSA-gmvj-rj2h-7528), from the open findings of the review behind
1.15.0 and from reviews of this release's own changes. The model no longer receives an isolated session's noVNC
password: the full takeover link now comes from a route that also demands a takeover token, which agents are not
given. Codex behind the host bridge no longer gets the whole environment of the bridge's shell; Playwright's driver,
Tesseract and the controller's other helper processes get an allowlisted environment too (a Docker credential helper,
when one is configured, is a known limit); and on Linux the controller and the bridge make themselves non-dumpable, so
a process of the same user cannot read their environment through /proc. The Python client, the LangChain tools, the
MCP bridges and the repo's scripts no longer send their tokens through an environment proxy to a controller on the
same machine. Read the upgrade notes first: a person opens an isolated session's takeover link from the dashboard or
scripts/takeover_link.sh with the takeover token, an approval webhook on a private name or address needs
APPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETS=true, a Codex setup behind the bridge that needs another variable passes it
with --pass-env, and a controller rolled back to 1.15.0 cannot read the harness runs this version saved. The
controller image and the client and LangChain packages change, and the MCP bridge package now requires this client;
the browser-node image changes only in version.
Upgrade notes
- An isolated session's full takeover link now needs the new takeover token. An agent that handed a person the
takeover link of an isolated (docker_ephemeral) session now hands over a link without the noVNC password. The
person opens the full link from the dashboard ("Open noVNC") or prints it with
scripts/takeover_link.sh <session_id>; a link opened without the password makes noVNC ask for it. Both need the
new takeover token (TAKEOVER_TOKEN, else the token the controller generates inTAKEOVER_TOKEN_FILE,
./data/takeover-tokenwith the shipped compose): the dashboard asks for it on the first "Open noVNC" of an
isolated session in a tab, before it opens the window (Chrome and Edge show no prompt in a tab that is not in
front), and again on the click after a refusal, andscripts/takeover_link.shreads it fromTAKEOVER_TOKEN(the
shell or.env) ordata/takeover-token. A script or integration that took the password fromPOST /sessions,
GET /sessions/{id},GET /remote-accessor the takeover result now calls
GET /sessions/{session_id}/takeover-linkwith theX-Takeover-Tokenheader. - An approval webhook on a private name or address now needs
APPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETS=true. An
approval webhook whose host is a private name (a service on the compose network, a LAN host) was reachable by name
before and is now refused, as is one at a shared address (100.64.0.0/10, such as a Tailscale node): every address
that is not global is. Set the newAPPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETS=trueto allow it. The flag lifts the
name and address checks, so loopback (localhost,127.0.0.1) and every private range are allowed too; cloud
metadata stays refused whatever it says:169.254.0.0/16,100.100.100.200,fe80::/10,fd00:ec2::254,
fd20:ce::254(GCP),fd00:c1::a9fe:a9fe(OCI) and the namesmetadataandmetadata.google.internal, and an
IPv6 address that spells a metadata address: mapped, translated, compatible, NAT64's well-known64:ff9b::/96, the
local-use64:ff9b:1::/48read at every RFC 6052 position (/32to/96), 6to4, Teredo (the client's address) or
an ISATAP interface id (0:5efeor200:5efe, then the IPv4 address) after any prefix. Without the flag such an
address is refused, too, when the IPv4 address it spells is not global. A network-specific NAT64 prefix (one an
operator chose elsewhere) cannot be recognised. Behind a proxy (HTTPS_PROXYand the like) the controller must
still be able to resolve the webhook host itself: it checks the addresses before it posts by name through the proxy,
and a name it cannot resolve is not posted to. - Codex behind the host bridge gets only allowlisted variables; pass any other it needs with
--pass-env. The
Codex host bridge now gives Codex only an allowlisted environment: a Codex setup that needs another variable from
the bridge's shell passes it with--pass-env NAME(repeatable), which hands that value to Codex and to every
command Codex runs.docs/deployment.mdlists every name that already passes. Two setups that need it: a sign-in
kept in the desktop keyring (DBUS_SESSION_BUS_ADDRESSorXDG_RUNTIME_DIR, where the bus is not at its default
path) and a node version manager with a non-default home (VOLTA_HOME,ASDF_DATA_DIR,MISE_DATA_DIR). - The
HARNESS_UV_COMMANDverifier now gets a fixed environment. AHARNESS_UV_COMMANDthat needs a variable
outside the provider CLIs' base names (CLI_BASE_ENV_NAMESandLC_*, listed in docs/deployment.md), such as its
own key or setting, names it in the newHARNESS_UV_ENV_PASSTHROUGH(comma-separated). - An empty
ISOLATED_TUNNEL_REMOTE_BIND_ADDRESSnow stops startup. For a controller that reads
ISOLATED_TUNNEL_REMOTE_BIND_ADDRESSitself (outside compose:docker-compose.isolation.ymlpasses
${ISOLATED_TUNNEL_REMOTE_BIND_ADDRESS:-127.0.0.1}, so there an empty value reached the controller as127.0.0.1),
an empty value, which underISOLATED_TUNNEL_ACCESS_MODE=unsafe-publicasked the bastion to bind the tunnel on
every interface, now stops startup. Set*for every interface (IPv4 and IPv6) or0.0.0.0for IPv4 only; both
needunsafe-public, and the bastion'sGatewayPortsstill decides. - Model names are now checked against a pattern. A
provider_modeloutside the model-name pattern (below) is
refused with a 422, and an agent job saved before the upgrade with such a model fails when it runs and cannot be
resumed. - After a rollback to 1.15.0, the harness runs this version saved cannot be read. A controller rolled back to
1.15.0 cannot read a harness run this version has saved (each run now records thegenerationof the process that
created it, and each attempt atrace_hash, fields 1.15.0 rejects), including an older run this version's startup
rewrote: one an earlier process leftrunning(nowinterrupted) orconvergedwith no candidate (nowfailed,
or, for a run this version recorded, given the candidate it had staged). Such runs drop out ofharness.list_runs,
andharness.get_statusfails on them.
Security
- The model no longer receives an isolated session's noVNC password.
create_session,get_session,
get_remote_accessandrequest_human_takeover(REST and MCP) carried it in the takeover URL's fragment, which
over MCP reached the calling model, and with a session tunnel up the URL was the public one. No MCP tool result, and
no response of a route the agent-facing packages (the Python client, the MCP package, the LangChain integration)
call, carries it now; an isolated session'sremote_accessblock and takeover result carry a fixedtakeover_note
instead. The full link comes from the newGET /sessions/{session_id}/takeover-link, which no MCP tool and no
agent-facing package calls and the dashboard and the newscripts/takeover_link.shread. Beside the bearer token,
which agents hold, it demands a second secret agents are not given: the takeover token, in theX-Takeover-Token
header, compared in constant time and required in every scope,API_ALLOW_TOKENLESS_LOOPBACKincluded. A malformed
session id is a 400; then, on a controller that loaded no takeover token, every request is a 503; otherwise a
missing or wrong token is a 403, checked before the session lookup (so before a 404 for an unknown, closed or, under
API_BEARER_TOKENS, another operator's session: the route is exempt from the app-wide session check) and audited as
takeover_link_refusedwithout a token or the URL; a read isCache-Control: no-storeand audited as
takeover_link_viewedwithout the URL or the password. The token isTAKEOVER_TOKENwhen set; else the controller
reads it fromTAKEOVER_TOKEN_FILE(default/data/takeover-token, whichdocker-compose.ymlpins, as it pins
API_TOKEN_FILE, and passes aTAKEOVER_TOKENfrom the shell or.env) or generates one there (mode 0600) on
first start, and logs only a sha256 fingerprint. ATAKEOVER_TOKENshorter than 32 characters, outside printable
ASCII or containing a space (the token file's rule, so the variable and the file accept the same tokens and every
client sends one unchanged: curl sends a UTF-8.envvalue that Starlette reads as latin-1) or equal to an API
credential refuses startup, and so, whileTAKEOVER_TOKENis unset, does aTAKEOVER_TOKEN_FILEin one of eight
directories:ARTIFACT_ROOT(served under/artifacts),UPLOAD_ROOT(uploadable into a page) andAUTH_ROOT
(its profiles exported as archives), all three swept by maintenance, and the five mounted into a container:
browser-profileanddownloadsin browser-node andtunnelsandsshin reverse-ssh, which compose mounts, and
browser-sessions, whose<id>/profileand<id>/downloadsdirectories the controller binds into each isolated
session. The check looks for those five under the parent ofARTIFACT_ROOT, which is where compose's./datalands
in the image (/data); withARTIFACT_ROOTmoved elsewhere, compose's mounts stay under./dataand the check no
longer covers them, so keepTAKEOVER_TOKEN_FILEout of them. The other data roots are read by names the controller
builds (a fixed name, or an id or profile name with a fixed suffix), so no route hands a token there to an agent
(thecliproviders can still read it, as they candata/takeover-token, below), and one of them set to/data
itself (MESH_IDENTITY_DIR, say) leaves the default/data/takeover-tokenusable. Spaces and tabs around the
presented header are not part of the token. A token file that cannot be read or written, holds an unusable token, or
stays readable beyond its owner because its mode cannot be tightened (a root-owned 0444 mount), or cannot be opened
or read for that mode check, before or after its chmod (it vanished or turned unreadable since the read, or an I/O
error), logs a warning naming that cause and the endpoint answers 503. A token file (either one) on a filesystem
that accepts a chmod and keeps the mode (a repository on a Windows drive under Docker Desktop, some FUSE or SMB
mounts) is used with a warning that the mode did not hold, instead of a log line saying it was changed to 0600, and
one the controller has just generated there gets that warning on the same start, not only the next; the line
announcing a generated token file says "mode 0600" only when the mode found is exactly 0600, else the mode found
(another owner-only mode, such as 0400, without a warning), or that its mode could not be checked after the write,
which also gets a warning naming the setting and path, the token still used. A symlinked token file (a Kubernetes
secret mount, 0644 by default), whetherTAKEOVER_TOKEN_FILEorAPI_TOKEN_FILE, is used as it is, its target's
mode untouched, with one warning naming the path and mode when that target is readable beyond its owner, or that its
mode could not be checked when the target cannot be opened for that check (it vanished or turned unreadable since
the read). The takeover token stops only agents without file access to the controller's host: one running as the
host user that owns./data(a local MCP setup) can readdata/takeover-token, and so can the controller's own
cliproviders, which run as its uid (or anything that reads the session container's own copy of the password).
Open the dashboard and the link in a browser no agent drives: such an agent can read the dashboard's sessionStorage.
Thetakeover_notenames no script. The shared browser-node keeps the operator'sVNC_PASSWORDand a password-free
link. - The Codex host bridge no longer hands Codex the whole environment of the shell that started it. The Codex host
bridge (scripts/codex_host_bridge.py,OPENAI_AUTH_MODE=host_bridge) now starts Codex with an allowlisted
environment instead of the whole environment of the shell it was started from, which Codex, and every command a
prompt-injected Codex ran under-s read-only, received: the names the controller gives its own provider CLIs
(CLI_BASE_ENV_NAMESandLC_*) plusOPENAI_API_KEY,OPENAI_BASE_URL,CODEX_HOME,CODEX_API_KEYand
CODEX_CA_CERTIFICATE(the PEM bundle Codex reads beforeSSL_CERT_FILE, which the controller's owncli-mode
Codex now gets too), and each name given with the new--pass-env NAME(a bad name exits 2 at startup). - The processes the controller starts get only the environment they need, and on Linux cannot read the
controller's. On Linux the controller makes itself non-dumpable at startup (prctl(PR_SET_DUMPABLE, 0), first in
its lifespan), and so does the Codex host bridge: a process of the same uid, such as an unsandboxed child, could
read either's whole environment through/proc/PID/environ, around the allowlisted one it was given. Where the call
fails the process logs one warning and goes on. The Universal Verifier command and autossh now get the provider
CLIs' base names (CLI_BASE_ENV_NAMESandLC_*) instead of the controller's whole environment (the Universal
Verifier command also gets the names in the newHARNESS_UV_ENV_PASSTHROUGH, and autossh keeps its ownAUTOSSH_*
tuning, such asAUTOSSH_POLL), and the regex worker gets onlySYSTEMROOT, on Windows (the base names are listed
in docs/deployment.md). Playwright's node driver, and every browser it launches (shadow browse's headed Chromium
among them), get those base names plus Playwright's ownPW_*andPLAYWRIGHT_*,DEBUG,DEBUG_FILEand the
display and session-bus names (DISPLAY,WAYLAND_DISPLAY,XAUTHORITY,XDG_RUNTIME_DIR,
DBUS_SESSION_BUS_ADDRESS): until now the driver got the controller's whole environment and stayed readable at
/proc/PID/environby any process of its uid. The controller confines it before each Playwright start and fails to
start if the installed Playwright no longer has the function it confines. Tesseract, which screenshot redaction's
OCR starts through pytesseract, gets the same base names plusTESSDATA_PREFIXandOMP_*: until now it too got
the controller's whole environment (the provider keys among it, and the API token when it is set as
API_BEARER_TOKENorAPI_BEARER_TOKENS), readable at/proc/PID/environby any process of its uid while it ran.
The controller confines it at startup, before anything can run OCR, and fails to start if the installed pytesseract
no longer has the module-levelenvironit replaces. Known limit: such a child still runs as the controller's uid
and can read its files (data/api-token,data/takeover-token, the mesh and witness keys); thecliproviders are
such children, the bridge's Codex runs as the host user who started the bridge (who can read those files where it
owns./data), and page content can prompt-inject them. The driver and the browsers it launches, like the provider
CLIs, are ordinary processes of the controller's user: their environment holds none of the controller's own tokens
or keys (a proxy setting that carries credentials excepted), but their memory holds page content and what is typed
into pages, which a command one of them runs could read where the host lets a process ptrace another of the same
user (kernel.yama.ptrace_scope0). A provider CLI's key is readable by the commands it runs and by those another
CLI runs at the same time (/proc/PID/environof a dumpable process of the same user). On macOS and Windows the
controller and the bridge do not change this, and whether a process of the same user can read their environment
depends on the system. A Docker credential helper configured for the controller's user (credsStoreor
credHelpersin its Docker config) is run by the Docker SDK with the controller's whole environment when the
controller pulls a session image the daemon does not have: build or pull that image ahead (compose builds it) and
configure no credential helper for that user. - The repo's scripts keep their tokens out of
bash -xoutput and away from proxies for a local controller. The
scripts'.envloader runs with xtrace off and restores the caller's setting, sobash -xno longer prints every
.envvalue as a script loads them, andbash -x scripts/takeover_link.shprints neitherTAKEOVER_TOKENnor
API_BEARER_TOKEN(a value a script expands after loading still shows in its trace); the isolated smokes pipe the
takeover-link response to Python instead of holding it in a variablebash -xwould print.bearer_curl,
takeover_curlanddoctor.sh's token-carrying API calls pass curl--noproxyforlocalhost,127.0.0.1,::1
and the scripts' base URL host when it is another loopback address or0.0.0.0(127.0.0.2, say;bearer_curland
takeover_curlrefuse, before any token is sent, a base URL whose host is not a plain host name or address: an IPv4
address written another way than four dotted decimals, such as127.2,0x7f.0.0.2,2130706434or0177.0.0.1,
a host holding anything but ASCII letters, digits,.and-(such as%31%32%37.0.0.2) or ending in., and a
bracketed IPv6 host other than[::1]that holds anything but hex digits and:(a zone id, or a dotted tail such
as[64:ff9b::127.0.0.2]) or whose first group is empty or all zeros, which covers every IPv4-mapped form such as
[::ffff:127.0.0.2]; curl normalises a host before it matches--noproxy, so a spelling of another loopback
address missed the list, while a spelling of127.0.0.1itself was normalised to it; the host is read as curl reads
it, a scheme only at the start of the URL and the authority ending at the first/,?or#, and they also
refuse a set base URL that starts with a scheme, a colon and a slash but not with that scheme,//and a host, such
ashttp:///127.0.0.2:8000/orhttp:/127.0.0.2:8000/, which curl reads as127.0.0.2, and one whose host is
empty, such ashttp://:8000/(an empty bracketed host, as inhttp://[]:8000/, passes these checks and is left to
curl); a scheme-lesslocalhost:8000is still accepted), then the environment's ownno_proxy, elseNO_PROXY, as
curl reads them (one that is*is passed alone, so every host still goes direct), the reverse-SSH smoke's bastion
curl passes it for the bastion's own loopback names, andscripts/smoke_download.pysends its controller requests
with no proxy, so a request to a loopback controller no longer hands its tokens to anHTTP_PROXYorALL_PROXY.
scripts/takeover_link.shwarns when it finds no takeover token and says what a 403 means. - A
.curlrcor a proxy set in.envcan no longer redirect the scripts' token-bearing requests.bearer_curl
andtakeover_curl(scripts/load_env.sh),doctor.sh's token-carrying API calls and the reverse-SSH smoke's
bastion curl now runcurl -q, so a.curlrccannot add a proxy or header to a request that carries the token (the
tokenless readiness waits still run plaincurl), and the scripts'.envloader also refusesCURL_HOME,
XDG_CONFIG_HOME,PERL5*,PERLLIB,LANG,LC_*and the proxy variables (HTTP_PROXY,HTTPS_PROXY,
ALL_PROXY,NO_PROXYand their lower-case forms). Before, onlyLC_ALL,LC_CTYPE,PERL5OPTandPERL5LIBof
these were refused. A proxy set in.envfor the scripts must now be exported in your shell instead. - The Python client, the LangChain tools, the MCP bridges and
agent_eval.pyreach a controller atlocalhost, a
loopback address or0.0.0.0directly, never through an environment proxy. The Python senders of the bearer token
no longer send it to an environment proxy when the base URL's host islocalhost(also aslocalhost.), a loopback
IP literal or0.0.0.0or::: the MCP stdio bridges (theauto-browser-mcpconsole script of the
auto-browser-clientpackage and the controller'sapp.mcp_stdio),AutoBrowserClient's sync and async HTTP
clients and its event stream (stream_events), the LangChain package'sAutoBrowserTool(calls andlist_tools)
andAutoBrowserNode, andscripts/agent_eval.py --execute. urllib skips a proxy forlocalhostonly when
no_proxynames it, and httpx followsHTTP_PROXY,http_proxyandALL_PROXYto a loopback host the same way,
so with a proxy set and noNO_PROXYtheAuthorizationheader went to the proxy. One rule now decides for all of
them: a host that, after one trailing dot is stripped from a name, islocalhost, or an address that is loopback or
unspecified (0.0.0.0and::, which a server's startup line prints and which reach this host on Linux and macOS),
an IPv4-mapped IPv6 address such as[::ffff:127.0.0.2]counting as the IPv4 address it maps, is reached directly
(the httpx clients get a transport of their own, which still readsSSL_CERT_FILEandSSL_CERT_DIR). The address
is the IP literal, or what the platform's numeric parser (getaddrinfowithAI_NUMERICHOST, which never queries
DNS) reads the host as, so127.2,2130706434and0x7f000002count as127.0.0.2, as they do for the socket
layer, and a name is compared as the socket layer resolves it, after theidnaencodinggetaddrinfoapplies and
lowercased (local%C2%ADhost, with a soft hyphen, islocalhostto the bridges); the bridges and
scripts/agent_eval.pygo direct when the host http.client connects to is local (an unbracketed::1:8000is
::1, and urllib percent-decodes%31%32%37.0.0.2to127.0.0.2). They refuse the base URL as an invalid
controller URL, before any opener is chosen and with the request sent nowhere, when another reading finds a local
host http.client would not connect to (urllib's decoded host read as an authority, which finds127.0.0.2in
127.0.0.2%23.bad; the host of the URL as written, which urllib sends a proxy for anhttp://URL,127.0.0.1in
x%2f@127.0.0.1; urllib's decoded host after its last@,::1in an unbracketed::1without a port, which
http.client reads as host:, and inuser@::1; or the host http.client reads from that part,::1in
user@::1:8000, whose connect host isuser@::1), when a reading cannot parse the host (x%5b@127.0.0.1), or when
the port http.client reads is not a number from 0 to 65535 (it reads:99999as 99999, which the socket layer can
wrap to another port). Any other host, a*.localhostname included, still goes through the proxy the environment
names.scripts/check_sandbox_gate.py, which only talks to127.0.0.1, never uses a proxy. The bridges refuse a
URL urllib cannot read or that is not anhttp://orhttps://URL with a host (1.15.0 answered adata:or
file:URL from the URL or the file, as if a controller had answered), and they andscripts/agent_eval.pyone
whose path or query holds a space or a control character, as an invalid controller URL with the request sent
nowhere; that answer gives the reason in the bridges' own words and does not name the URL. Their answer that no
controller is reachable names it without its userinfo, query or fragment; the error text their answers show has the
URL's userinfo, password, query and fragment, each whole, as written or percent-decoded, replaced with[redacted]
and any otheruser:password@removed (a server's error detail that quotes one another way, such as a query value
alone, is shown as it came); a 429'sRetry-Afteris shown only as a number of seconds; and the bridges no longer
send a token holding a line break, which http.client's header error quoted whole. 1.15.0's answers echoed them all.
scripts/agent_eval.py --execute,scripts/check_sandbox_gate.pyandscripts/smoke_download.pynow also refuse
redirects, as the bridges do, direct or proxied: urllib's default handler copied theAuthorizationheader onto a
redirect to any origin, and a 3xx is now reported as the HTTP error each script already reports. - On a host shared with other users, keep
./dataclosed to them: mode 0700, or 0750 with a group only the
operators are in. browser-node's endpoint file there (./data/browser-profile/browser-ws-endpoint.txt) holds the
ws://URL that connects to the shared browser, and it cannot be private to one uid, since browser-node writes it
and the controller, another uid, reads it. docs/deployment.md has the details. - The approval webhook can no longer be pointed at an internal address through DNS. The approval webhook target is
now checked after DNS: a host a browser would read as another one is refused whatever address it spells, even with
APPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETSon (an IPv4 address other than four plain dotted decimals, such as
2130706433,0x7f.1,127.1,0177.0.0.1or0x08080808; a percent-encoded name, or a non-ASCII one a browser
(UTS 46) maps beyond case folding and composition, refuses, or reads differently from urllib; a backslash or a
control character, U+0000 to U+001F); the host is then resolved (an IP literal is checked as written) and, unless
APPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETSis on, refused when any answer is not a global address (loopback, private,
link-local, unspecified, multicast, reserved and the shared100.64.0.0/10space among them) or is an IPv6 address
that spells one; the request is then sent to the addresses that were checked, in the resolver's order and moving to
the next only when one cannot be connected to, with the name kept as theHostheader and the TLS server name, so a
second lookup cannot return a different one. A non-ASCII host (bücher.example) is looked up, sent asHostand
named for TLS in its IDNA form (xn--bcher-kva.example), as 1.15.0 did when it posted by name; a lookup that cannot
encode the name counts as one that did not resolve. When a proxy from the environment applies to the URL
(HTTPS_PROXY,HTTP_PROXYorALL_PROXY, lessNO_PROXY), the answers are still checked, but the request goes
by name through the proxy, which then owns resolution: the proxy resolves the name, so its own rules decide which
addresses the request can reach. Logs carry onlyscheme://host, never the path, query or credentials: httpx's own
INFO line for each request, which named the whole URL, is no longer logged (the controller sets thehttpxlogger
to WARNING, or toLOG_LEVELif higher). A name that does not resolve is not posted to. A cloud metadata address
stays refused, even withAPPROVAL_WEBHOOK_ALLOW_PRIVATE_TARGETSon, when an IPv6 answer spells it: mapped,
translated, compatible, NAT64's well-known64:ff9b::/96(its last 32 bits), the local-use64:ff9b:1::/48read at
every RFC 6052 position (/32to/96), 6to4, Teredo (the client address), or an ISATAP interface id (0:5efeor
200:5efe, then the IPv4 address) after any prefix. That check fails closed: a local-use NAT64 target whose address
another RFC 6052 layout than the operator's reads as169.254.x.xis refused even with the opt-in (behind a prefix
such as64:ff9b:1:a9fe::/64, every address). - A CDP URL's credentials no longer reach the logs, the audit or the caller, and an unreachable browser answers
503.browser.cdp_attachnow logs, audits and returns the Chrome it attached to asscheme://host:portonly. A
CDP URL's userinfo, query and/devtools/browser/<id>path can be the credential for that Chrome; the attach itself
still uses the full URL. The startup log line forCDP_CONNECT_URLshows it the same way. Why a connect failed (the
first line of Playwright's error) is in the controller's log and the startup error, with the Chrome shown as
scheme://host:portand any URL in that line cut the same way, never the full URL, which Playwright's error repeats
whole in its call log; the caller of the tool or a route gets the fixed text below, not the reason. A request that
meets a browser that cannot be reached (Chrome over CDP, the shared browser-node, or an isolated session's own
browser) atPOST /sessions, a fork orPOST /crons/{job_id}/triggeranswers 503 with the fixed detail "the
browser could not be reached" instead of a 500 (CDP, or any browser at the cron trigger) or a 409 Conflict (a
browser-node atPOST /sessionsor a fork), and an MCP call (browser.cdp_attach, a session it creates) answers
the same text with the codebrowser_unreachable. ACDP_CONNECT_URLin which a browser could read another host
than that log shows (a backslash or a control character, U+0000 to U+001F, anywhere in it, or a host written in a
form a browser maps to another) now stops startup, as the tool'scdp_urlalready was refused. Whitespace around
CDP_CONNECT_URL(any surrounding whitespace, Unicode spaces too, such as a trailing CR or LF from a quoted.env
value or the process environment) is stripped first, so it does not stop startup, and a value of only whitespace now
counts as unset, as an empty one does. - A model name can no longer be read as a CLI flag.
provider_modelon the agent step and run requests, and the
model the Codex host bridge passes tocodex --model, must now match one pattern (letters, digits,.,_,:,
/,@,-; 1 to 128 characters; starting with a letter or digit; no..), which a Vertex-style id such as
claude-3-5-sonnet@20240620passes. The bridge answers 400 otherwise, so a model can no longer be read as a CLI
flag. The Gemini adapter, and the curator forCURATOR_MODEL, also URL-quote the model they put in the request
path. - A harness run id can no longer name a directory outside the runs root. A harness
run_idmust now look like the
ids the harness generates (1 to 120 letters, digits,.,_or-, starting with a letter or digit), at the tool
boundary and again in the run store, so an id cannot name a directory outside the harness runs root. - The Codex path-compatibility shim now links only under the CLI home or
/home/<user>/.codex. The Codex
path-compatibility shim (which links a.codexhome named in the CLI home'sconfig.tomlto the real one) now
creates a link only under the CLI home or at/home/<user>/.codex, never makes parent directories anywhere else,
logs each path it refuses, leaves a path that already exists (a dangling link included) as it is, and reads the
config and makes its links once per adapter, on the first CLI call that finds aconfig.tomlit can parse, instead
of on every CLI call. It checks where a path is before it looks at it, so a refused one such as/root/.codexis
never read (for a non-root controller on Python 3.11 and 3.12 that read raised and ended the call), and a path it
cannot check or link (a parent it may not create, a NUL byte) is logged and skipped. git addno longer picks up secrets underdata/or in.env.*files..gitignorenow ignores everything
underdata/except the.gitkeepin each directory directly under it (it listed directories one by one and missed
data/memory,data/meshwith the node identity key,data/harness, the proxy and cron stores), and ignores
.env.*except.env.example.- The mesh and witness key and its directory are created private, and tightened when an earlier release left them
open. The mesh and witness private key is now created with mode 0600 from the first byte (O_EXCL, no
write-then-chmod window) in an identity directory created at 0700, and on POSIX a key that is readable by group or
others is changed to 0600 on load, through the descriptor it was opened with and with a warning, as the token files
are (one that cannot be tightened is still loaded, with a warning that it stays readable). An identity directory an
earlier release left open to group or others is tightened to 0700 on load when the controller owns it and it holds
only the identity files, with one warning, and reported with a warning when it holds anything else (a
MESH_IDENTITY_DIRpointed at/data/meshor/data, whose other readers a chmod would lock out), belongs to
another user or keeps its mode after the chmod (a mount that does not keep modes). The witness signer's key
directory goes through the same check. - A logged
Settingsobject no longer carries secrets. Every secretSettingsfield (the auth-state encryption
key, the witness remote key, every provider API key, the approval webhook secret, the default proxy password, the
share-link secret) is now left out ofrepr(), so a loggedSettingsobject no longer carries it. So are the URL
fields that can carry a credential in their userinfo, path or query:APPROVAL_WEBHOOK_URL,REDIS_URL,
CDP_CONNECT_URL,BROWSER_WS_ENDPOINT,DEFAULT_PROXY_SERVER,TAKEOVER_URL,WITNESS_REMOTE_URLand every
provider's*_BASE_URL. - Shadow browse is refused when sessions are isolated.
browser.enable_shadow_browseis now refused under
SESSION_ISOLATION_MODE=docker_ephemeral: its headed Chromium runs in the controller's own process tree, outside
the per-session container isolation. It is still started without theMAX_SESSIONScheck, but an open shadow
session counts toward the limit, so it takes a slot from later creates and forks. - A session tunnel no longer leaves the bastion's details on disk or in session summaries. A session tunnel's
metadata (<session>.json) and autossh log (<session>.log) underISOLATED_TUNNEL_INFO_ROOTare now deleted when
it is released, and when its provision gives up (autossh did not start, exited early, was cancelled, or no port was
left; also when a metadata write (the first, or the one that marks the tunnel active) or the log open fails, or the
error-status write does, which is then logged while the original error is raised: on an early exit autossh's own
message, or its exit code when it printed nothing); the metadata named the bastion and its user, and the log (whose
tail the metadata'serroralso carried) holds autossh's and ssh's own messages, which can name the key path. The
tunnel block inremote_access.session_tunnel(a session'sremote_accessin its summary) no longer carries
ssh_host,ssh_port,ssh_user,info_pathorlog_path(a session the controller no longer holds is answered
from its stored record, so one recorded before the upgrade still shows them), and itserroris a short code
(autossh_exited,autossh_start_failed,provision_cancelled,provision_failed) instead of autossh's stderr,
which is logged by the controller. - The takeover URL no longer goes into a session's action log.
browser.request_human_takeoverno longer writes
the takeover URL and the remote-access block to the session'sactions.jsonl(served under/artifactsto the
session's users): the line keeps the reason and the session, withouttakeover_urlorremote_access. The tool's
own result still carries them, as before. - The remote-access report passes on only the tunnel fields it validated. The
tunnelblock of the remote-access
report (GET /remote-access, a session'sremote_access.tunnel, orremote_access.shared_tunnelfor an isolated
session) now carries onlystatus,updated_at,public_takeover_url,public_api_urlandstale_after_seconds
from the reverse-ssh sidecar file, not the whole file (the bastion, its port and user, the access mode, the bind
address and the remote ports); a session the controller no longer holds is answered from its stored record, so one
recorded before the upgrade still shows the whole file's fields. A file that is not a JSON object is reported as
unreadable, astale_after_secondsthat does not read as a positive finite number (a numeric string such as"90"
reads as one, a boolean does not; one too large for a float included) falls back to
REMOTE_ACCESS_STALE_AFTER_SECONDS(1.15.0 raised on a non-numeric string, a list or object, or an integer too
large for a float, tooktrueas one second, and used NaN, an infinity or a negative number as read), an
updated_atthat cannot be read or converted to UTC (0001-01-01T00:00:00+01:00) falls back to the file's
modification time, and a public URL that is not a string is ignored. Thetunnelblock passes the file's fields
only as validated: thestale_after_secondsin use,updated_atonly when it reads as a timestamp (then in UTC),
andstatusand a public URL only when they are a non-empty string, so astatusorupdated_atthat is NaN, a
list or an object is now left out of the block (before,GET /remote-accessandbrowser.get_remote_accesspassed
a list or object on as it was and wrote a NaN asnull; neither answered a 500). - The unauthenticated mesh endpoint caps the body it reads.
POST /mesh/receive, which takes no bearer token, now
reads at mostMESH_MAX_BODY_BYTES(new, default 1 MiB): a body with noContent-Length(however small: a peer
must send one, and the413says so), a larger one, or one that streams past the cap gets413before anything is
parsed, and an uninitialised mesh answers503before the body is read. A malformed envelope is422as before.
Fixed
- Closing a session finishes its teardown even when the caller goes away, and says which steps failed.
close_session(DELETE /sessions/{id}) now runs its whole teardown as one task that a cancelled caller does not
stop, from the wait for a busy session's lock (which can close its browser context) to the last record (a shutdown,
or a cancel of the task that awaited the close, used to leave the audit event, the witness receipt and the stored
record unwritten), and says when a step failed: the answer'sclosedstays true (the session is unregistered either
way, so itsMAX_SESSIONSslot is free), the newteardownispartial(completewhen every step succeeded),
failed_stepsnames the steps that failed (trace stop, tunnel release, browser context, isolated browser, isolated
runtime), and thesession_closedaudit event and witness receipt carry statuspartialand those names instead of
ok. - A closed session can no longer be recorded as active again. A late background write of a session's record can no
longer put a closed session back to active: the active write is skipped when the session is no longer registered
(checked before and after the summary is built), and the session store refuses to overwrite a storedclosedrecord
with any other status (aninterruptedwrite replaced it and lost itsclose_reason), a guard that reads the file
copy, which every write updates first; a stored record it cannot parse (a corrupt file) is replaced by the next
write, unless Redis is the primary store and holds a readableclosedcopy (then the write is refused, and a Redis
read that fails otherwise, such as a lost connection, skips it), and one it cannot read (an I/O error, which could
hide a closed record) skips that non-closed write for the next one to retry, each logged with the session id;
neither fails the action whose state the write mirrors, the check never refuses aclosedwrite, and a close (or a
failed create's rollback) writes itsclosedrecord over one it cannot parse. The store makes one write at a time
per session, from that check through the file and Redis copies, and a cancelled write finishes before the next one
for that session starts, so the guard holds within one controller process; two processes sharing a store are not
covered. Writes for different sessions do not wait for each other. - A failed session create cleans up after itself. A
create_sessionthat fails no longer leaves its artifact,
auth and upload directories behind or anactiverecord in the session store: the directories are made only after
the checks that need no browser (the arguments, the start URL, the session cap, the proxy persona, the auth profile
or state and the memory profile), removed again by the rollback (in a worker thread, so a large tree does not stall
other requests, and each on its own: one whose removal or check fails is logged with its error, the rest of its tree
is still removed, and the rest of the rollback goes on), and a record the create had already written is marked
closed(reasoncreate_failed). The whole rollback (the tunnel and isolated runtime releases, the context and
browser closes, the directories and the record) runs to completion when the task awaiting it is cancelled during it,
then the cancel is raised. The create-failed hook, the tunnel release, the context close, the isolated browser's
close and the runtime release are each bounded asclose_session's teardown steps are (30 seconds, then logged and
passed), so a context close or runtime release that never returns no longer holds the rest of the rollback or its
caller; the directory removal and the record close are not bounded. When the controller itself stops, every task
left is cancelled, the rollback's own included, and the next start marks such a recordinterrupted. - A session tunnel's release no longer hangs on an autossh that never exits. Releasing an isolated session's
tunnel (a close, or a failed create's rollback) now waits at most 5 seconds for autossh to exit afterSIGKILL, as
it already did after the terminate, then logs a warning naming the session and the process id and finishes the
teardown: an autossh that never exited (stuck in uninterruptible I/O) held the close or the rollback for ever. An
autossh already gone when it is terminated or killed (it exited while the first wait timed out, sokill()raised
ProcessLookupError) no longer stops the teardown before it frees the remote port, forgets the tunnel, closes its
log and removes its files, and a log close that fails (a flush on a full disk) is logged with the session id while
both files are still removed. - A failed or cancelled shadow browse cleans up after itself. A shadow browse that fails or is cancelled after its
Chromium started no longer leaves that browser running, the shadow's artifact, auth and upload directories on disk,
or anactiverecord in the session store (a record already written is markedclosedwith reasoncreate_failed,
as a failedcreate_session's is): the rollback now also runs on a cancel, and runs to completion when the caller
is cancelled during it, ascreate_session's does, and the directories are made only once the browser is up. MAX_SESSIONSnow holds when two creates race. Two session creates that both passed theMAX_SESSIONScheck
while one was still reading its storage state or memory profile no longer both start: the limit is checked again
right before a create reserves its slot, with no await in between.- A session on a blank,
data:or browser error page can be forked. Forking a session that sits onabout:blank
or adata:page no longer fails with a 403, nor one on Chrome's error page (chrome-error://chromewebdata/) with
a 400 asking forstart_url: with nostart_urlnamed, the fork starts on a blank page with the source's cookies,
and the audit records no start URL. Such a page is still judged first when nostart_urlis named: one the page
checks refuse (a refused page, or one that could not be judged) answers the 403, a refused about:blank page
included. - A fork keeps its source's proxy persona, User-Agent, protection mode and TOTP settings. A forked session now
keeps the source's proxy persona, User-Agent, protection mode and TOTP secret and hosts, ascreate_sessionwould
have set them (the fork used the deployment defaults before).POST /sessions/{id}/forkandbrowser.fork_session
take optionalproxy_persona,user_agentandprotection_mode; a value named there wins. A source created with a
raw request proxy (proxy_server) stored no proxy to carry, so its fork gets the default. The User-Agent carried is
the one the source's context was built with, so underSTEALTH_ENABLED=truea source created without one gives its
fork the same pool entry it drew instead of a second random draw. A fork whose proxy persona file cannot be read
answers 503 with the fixed text, asPOST /sessionsdoes (it answered 409 Conflict). - An auth state that cannot be decrypted answers 422 with a fixed text.
POST /sessionswith an auth profile or
storage_state_paththat cannot be decrypted (wrong or missingAUTH_STATE_ENCRYPTION_KEY, or a corrupt file) now
answers 422 "wrong or missing AUTH_STATE_ENCRYPTION_KEY, or the file is corrupt" instead of a 409 Conflict (no key),
a 500 (a wrong key, a damaged ciphertext, or JSON of another shape), or a 400 or 404 (a file that is not JSON, or
JSON with no ciphertext).POST /sessions/{session_id}/forkanswers the same 422 when the fork's own stored state
cannot be read back, where 1.15.0 answered asPOST /sessionsdid (409 Conflict with no key, otherwise a 500, 400
or 404). - The cron trigger answers the session cap with 409 and an unreadable auth state with 422, not 500.
POST /crons/{job_id}/triggeranswers a run whose session meets the session cap with 409 and an unreadable
encrypted auth state with 422, asPOST /sessionsdoes; both were a bare 500 there (an auth state file that is not
JSON, or JSON with no ciphertext, was a 400 or a 404). The 422 carries the same detail; the 409's is a fixed text
that names no session, since the cap's own text (the onePOST /sessionsanswers with) would name the job owner's
live session ids, and the trigger checks only the job's webhook key, which another operator may hold. - Encrypting auth state no longer leaves the plaintext copy behind. An encrypted auth-state save now removes the
plaintext state file it replaces (best-effort: one that cannot be removed, a directory or a Windows lock, logs a
warning naming it and the save still succeeds), and loading a plaintext state whileAUTH_STATE_ENCRYPTION_KEYis
set logs a warning. - Closing the active tab no longer moves the session to a refused tab. When the active tab closes, the session no
longer moves to a tab thatALLOWED_HOSTSrefuses while an allowed one is left:browser.close_tabtakes the
allowed tab nearest the closed one (the earlier of two equally near), a page that closes itself leaves the session
on the last allowed tab, and only when every remaining tab is refused does the old choice stand. - A
nanor infinite float setting now stops startup. Ananor infinite value in any float setting
(ARTIFACT_RETENTION_HOURS=nanswept every artifact outside a live session's directories, however new, on the next
cleanup) now stops startup with an error naming the setting. Zero and negative retention still mean "keep forever". - An isolated session's files are kept when its container may still be running. Releasing an isolated session no
longer takes an unreachable Docker daemon (or any Docker error other than "not found") for a gone container, and no
longer goes on as if released after a container removal that failed (any error but "not found", which means gone):
after a failed removal it still releases the session network (force-disconnecting that container from it); either
way it then fails:close_sessionreports it infailed_steps(the audit event and receipt say partial), and the
session's profile and downloads directories are kept instead of being deleted under a container that may still be
running (after a failed removal, with a warning naming the directory that holds them). A provision that fails before
it returns (the container did not start, the session network could not be joined) does the same: when its rollback
cannot remove the container, or cannot look it up (an unreachable daemon: whether one was created is then unknown),
the directories stay, with a warning that says which, instead of being emptied; both failures are now warnings with
the daemon's reason (1.15.0 logged a failed lookup not at all, reading it as no container, and a failed removal only
at DEBUG). A rollback that releases after a failed provision or connect logs a failed release and raises the
original error. - The sandbox refusal no longer claims the container was removed. The
BROWSER_SANDBOX=onrefusal of an isolated
session no longer ends "Its container was removed.": it was written before the rollback ran, so it was wrong when
that removal failed and underISOLATED_BROWSER_KEEP_CONTAINERS, which only stops the container. - Isolated sessions created at once check the Docker API version once. Two isolated sessions created at once now
read the Docker daemon's API version once and log the "GwPriority is not honoured" warning once; both were
unsynchronised across the provisioning threads. - Local-only takeover URLs are recognised everywhere, and the tunnel's bind address is checked strictly. One
helper (is_local_only_host, next tois_loopback_host) now decides whether a takeover URL names only this
machine, for both the per-session remote-access report and the production "TAKEOVER_URL is still local-only"
warning. Before, each kept its own literal list that missed127.0.0.2,*.localhostand[::ffff:127.0.0.1], so
a session on such a URL was not offered an isolated tunnel and the startup warning was skipped. The isolated
tunnel's remote bind address (ISOLATED_TUNNEL_REMOTE_BIND_ADDRESS) has its own strict check: a bare host or IP
only,localhostor any address that reads as loopback (another loopback address such as127.0.0.2included);
0.0.0.0stays refused there withoutunsafe-public. A value with a port or surrounding spaces (localhost:22,
[::1]:22,127.0.0.1) went into the-Rspec as it was, which ssh then refused or read as another bind, and an
empty one binds every interface: each now stops startup with a clear error. An IPv6 literal, bare (::1) or in
ssh's brackets without a port ([::1]), is accepted and goes into the spec in brackets, as ssh needs
([::1]:16181:127.0.0.1:6080; the bare::1:16181:...is a spec ssh refuses). Any other bare host in brackets
([127.0.0.1],[localhost],[203.0.113.5], which ssh parses too) is unbracketed and judged as its bare
spelling. - A session tunnel that cannot start now fails at once instead of trying every port. An isolated session tunnel
whose autossh exits early for a reason other than a taken remote port (a refused key, an unreachable bastion) now
fails the provision at once with that message instead of retrying every port in
ISOLATED_TUNNEL_REMOTE_PORT_START..END, each after a fullISOLATED_TUNNEL_STARTUP_GRACE_SECONDS; "remote port
forwarding failed" and "address already in use" still move on to the next port. - noVNC now accepts the takeover URL an isolated session hands out through its tunnel. With
ISOLATED_TUNNEL_ENABLED=true, an isolated session's noVNC now also admits the tunnel's public host
(ISOLATED_TUNNEL_PUBLIC_HOST, elseISOLATED_TUNNEL_HOST) as a page host: itsNOVNC_ALLOWED_HOSTSheld only
ISOLATED_TAKEOVER_HOST, so the takeover URL a session hands out through its tunnel was refused by noVNC's own
Origin/Host guard. - A run with
max_attemptsbelow the contract's budget can now converge. A convergence run started with
max_attemptsbelow the contract's budget now needs that many consecutive passes at most: the threshold followed
the contract's budget, somax_attempts=1on a budget of 5 could never converge. - A timeout inside an attempt no longer reads as a spent wall-clock budget. A convergence run is
over_budget
only whenmax_wall_secondsactually ran out: aTimeoutErrorraised inside an attempt or the verifier (an
orchestrator or verifier-command timeout) with budget left now ends the run asfailed(the note reads "Harness
attempt failed: TimeoutError" and the decision reason "attempt failed"), instead of claiming the wall-clock
budget was spent. - Real harness attempts are no longer marked simulated. A harness attempt driven by a real orchestrator session no
longer records itsmodel_decisionevent assimulated: true; only the mock attempt does. - Cancelled, crashed and interrupted harness runs no longer stay
running. A convergence run that is cancelled
(or crashes) is no longer leftrunningforever: it is saved ascancelled(orfailed) with a note. At startup,
before requests are served, every run an earlier process leftrunningis markedinterrupted, told apart by a
generation id each process writes on the runs it creates (not by a start time, which a clock stepped back across the
restart defeated); a run the current process is driving is never touched, and a record that cannot be rewritten is
logged and left as it is rather than stopping the harness from starting.harness.list_runsaccepts both states as
itsstatusfilter. - Staging a skill candidate is atomic, and a kill mid-stage is settled at the next start. Staging a harness skill
candidate now builds and signs it in a.tmp-*directory beside the final one and renames it into place, so a
signer failure no longer leaves unsignedSKILL.md,helper.pyandtest_skill.pyfiles behind, and the run is
saved asfailedwith the reason instead of stayingconvergedwith no candidate. Re-staging over an earlier
candidate takes two renames (the old one aside, the new one in); a kill between them, or during a build, is settled
at the next start, before the prune: the earlier candidate is renamed back when nothing replaced it, unplaced builds
are removed, and a run leftconvergedwith no candidate gets the candidate staged for its contract and last
attempt's trace (a kill after the build was in place, before the run was saved), or is markedfailedwhen none
matches. An aside a kill left half removed (itscandidate.jsongone), which cannot be restored, is removed when
itsenvelope.json(a signed one's payload included) orprovenance.jsonnames a candidate that is in place, or
when it holds nothing but a staged candidate's files (empty included), instead of being warned about at every start;
one holding anything else is still left, with a warning. - A contract can no longer change the
SKILL.mda reviewer reads. A staged skill'sSKILL.mdrenders the
contract's goal, precondition and postcondition values and the verifier notes as single-line code spans (with a
fence longer than any backtick run inside), so a goal holding a heading, HTML, a link or a code fence can no longer
change the document a reviewer reads before promotion. - A pathological
url_matchespattern is refused as invalid. Aurl_matchescondition whose pattern is nested
too deeply or repeats too many times (RecursionErrororOverflowErrorfromre.compile) is now refused as an
invalid regex like any other, instead of escaping the contract validator as an unhandled error. - An attempt trace edited on disk is refused.
harness.get_tracenow refuses a stored attempt trace whose
observation, network entries or extracted data were edited on disk (TraceIntegrityError): each attempt records the
trace's hash when it is written, and the read compares it. The hash chain alone covered only the events. A run
recorded before this release has no hash and is read as before. - The harness's disk use can now be bounded. The convergence harness can now be bounded:
HARNESS_RETENTION_DAYS
removes run directories and staged candidates not touched for that long, at startup and in each maintenance sweep
(never a run the process is driving, and never a candidate re-staged between the age check and the removal: the two
hold one lock against staging's rename, taken for staged entries only, so removing a run directory does not hold up
a stage; listing runs skips one removed while it sorts, and one it cannot stat, with a warning naming it; the prune,
too, warns about an entry it cannot read, its type included, and goes on to the rest). The default,0, keeps
everything, so an upgrade deletes nothing (staging holds a candidate's only copy); 30 suits a shared or long-running
controller.HARNESS_MAX_RUNS_PER_OPERATOR(default0, no cap; set it when several operators share one
controller) refuses a new run once the verified operator has that many stored or starting (admissions run one at a
time; the stored runs are read in a worker thread holding no lock, so neither the event loop nor a run ending waits
for the scan, and a start cancelled during it holds no place); runs with no verified operator share one count. - The harness's forbidden-state checks look at where the browser is and match whole words. The harness's
login_redirectforbidden state now looks at where the browser is, not what the page says: a URL path segment, in
any case, oflogin,log-in,log_in,logon,signin,sign-in,sign_in,auth,authorize,wp-login
(WordPress),ServiceLogin(Google),login-actions(Keycloak) orsignin-oidc(ASP.NET Core) (path parameters
such as;jsessionid=...aside, and an app's hash route such as#/loginread as a path;payment_screenreads
paths the same way), a host whose first label is one of those orsso(login.microsoftonline.com,
sso.example.com), a 401 or 403 in an observation'sstatus_code,http_statusorstatus(the controller's own
observations carry none, so in a live run a 401 or 403 page counts only by its URL), or the caller's value inside
the URL. A marketing page that offers "sign in" or mentions "authenticate" no longer fails a run.payment_screen
andcaptcha_screenmatch their built-in words and phrases whole (credit card,card number,payment method,
...; the bare wordpaymentno longer counts, a/paymentpath does), so "accredit cards" or "captchaless" are not
hits; a-ends a word for both, and forcaptcha_screena_or a camelCase hump does too, so names in page code
such ascaptcha_image,captchaTokenorreCaptchacount, as do the widgets'grecaptchaandhcaptcha. The
caller's ownvaluestill matches as a case-insensitive substring, as before, so a path such as/billingdoes.
These are heuristics with known false hits: a page-code flag such ascaptcha_enabled, and an API path such as
/payments/1/authorize(read as a login page). - The uv verifier's output is capped, and a kill reaches the processes it started. The harness's
HARNESS_UV_COMMANDverifier reads its stdout with a 1 MiB cap (it used to buffer all of it): a command that writes
more is killed and the verification isunverified. Its stderr keeps the first 4 KiB, even when one read crosses
that, so a failure's notes still carry the start of the command's own message. On POSIX the command now runs in its
own process group, and a kill (past the cap, at its timeout, or when the caller gives up) reaches the processes it
started, not only the command itself (on Windows only the command itself is killed); its pipes are then drained,
discarding, for at most 5 seconds instead of read to their end with no cap or timeout, which a descendant holding
one could hang. A descendant that callssetsidleaves the group and is not killed. The docs now say that during a
run the command receives the full contract and the attempt's trace on stdin, its final observation as the page gave
it (only secret-named keys, and atextortext_previewbeside a truthysensitiveortext_redactedflag,
redacted; not the PII and URL-token scrubbing of what is stored), and that a drift check (harness.check_drift,
harness.check_all_drifts) sends it the candidate's stored trace, which is scrubbed, with the contract's expected
text scrubbed to match. - A failing scrubber can no longer make a drift check pass. A drift check whose expected-text scrubber fails keeps
aurl_containsexpectation as written: a failing URL scrubber hands back the value up to its first?or#, the
empty string for aurl_containsvalue that starts with?or#and/for one that starts with/?or/#,
and every URL contains the first, everyhttp://orhttps://URL the second. A scrubber that raises is reported
unverifiedwith the exception type instead of failing the call. A URL inside atext_containsordom_contains
expectation whose query or fragment a failing scrub dropped is kept as written too, instead of shrinking to its
path; one inside anetwork_response_shapeorextracted_data_schemavalue still shrinks to its path. - The harness trace no longer hides a site's own data. The harness trace no longer blanks the
value,labeland
usernameof a dict in page data (an observation or extracted data) just because the site's own data carries a
sensitiveortext_redactedkey: that hiding applies to an action's own event payload only, and stops at the page
data the action event carries (itsobservationand the execution'sbeforeandafter), so a row there keeps
what the same row keeps infinal_observation. A sensitiveselect_option's executiontargetstill hides its
valueandlabel; itsindex, like the decision's, is kept. Atextortext_previewbeside such a key is
still hidden everywhere. - Scrubbing a quoted URL keeps the closing quote. A URL the harness trace scrubs out of quoted text now ends
before the closing quote when.,!or?and then a space or the end follow it
(see 'https://site/a?token=...'.lost its quote and full stop); an apostrophe inside a URL (?q=o'neil) is still
part of it. - The most specific mesh grant wins. A mesh peer's most specific matching grant now applies, not the first one in
peers.json: an exact capability beats a wildcard, a longer wildcard prefix beats a shorter one, and ties go to the
entry listed first. A broadtool:*listed early no longer shadows a stricter grant for one tool listed later.
docs/mesh.mdalso states thaturl_allowlistcovers the request's URL arguments only, not redirects or later
navigation. - Mesh replay protection no longer forgets a nonce early, after a restart or when its cache is full. Mesh replay
protection no longer depends on a size-evicted, memory-only nonce cache alone: a nonce now expires once the highest
wall time seen is more thanMESH_TIMESTAMP_WINDOWpast its envelope's timestamp (a clock stepped back does not
free it), and/mesh/receiverefuses an envelope stamped before the controller started or within one window after
it, since the last process accepted envelopes stamped up to one window ahead (so one it could have run cannot be
replayed after a restart, unless the clock stepped back across it: by more than a window, those the last process ran
stamped later than the step minus one window before the restart (all of them once the step reaches how long it ran,
or, after an upgrade from 1.15.0, which refused nothing at startup, how long it ran plus two windows); by less,
those it accepted stamped more than the window minus the step after the restart; the high-water mark below is kept
in memory only). After loweringMESH_TIMESTAMP_WINDOW, a restart is safe once the old window has passed since the
last envelope was accepted (or restart first with the old value and lower it after that long): the check assumes the
last process ran with no larger window. The cost is about one window, 30 s by default, of403refusals after each
start, which a sender's retry with a new envelope passes once that window is over. The timestamp window is checked
against that same high-water mark, not the raw clock, so an envelope whose nonce has expired cannot come back inside
the window when the clock steps back; a peer's reply to this node's own delegation request is checked the same way,
and a reply whose request id is not the request's is refused. The cost: after a large backward step of the clock,
fresh envelopes are refused until it catches up (for about the step minus the window). The 10,000-nonce cap no
longer evicts a nonce still inside its window (an envelope accepted, then 10,000 others inside its window, and it
ran again): at the cap every expired nonce goes, and if none has, the new envelope is refused with503("mesh
replay cache is full; retry later") and not recorded, so the cap bounds how many nonces are remembered at once, and
nothing remembered is dropped before it expires; a reply that finds the cache full fails the delegation. The limit:
a nonce is recorded once the envelope's signature checks out, before the request is decoded or granted, so
registered peers that get 10,000 signed envelopes through inside a window fill the cache, and every peer is refused
(503) until they expire (/mesh/receivetakes no bearer token, so the request rate limit, on by default at 120
requests a minute, counts it per client address; since a nonce is kept for up to two windows, one address can hold
about four times as many nonces as the window has seconds (120 at the default 30-secondMESH_TIMESTAMP_WINDOW), so
alone it cannot fill the cache unless that limit is raised or off or the window is about 2,500 seconds or more; when
the controller serves without a token (API_ALLOW_TOKENLESS_LOOPBACK), the limit counts eachAuthorizationor
X-Operator-Idvalue apart, so a sender that varies one is not limited). - The Codex host bridge can no longer be tied up by slow clients or runaway Codex runs. The Codex host bridge
reads a request body within 60 seconds in total (a client trickling a byte every 29 s used to hold a handler thread
indefinitely; it now gets 408) and the request line and headers within 30 seconds in total (past that it closes the
connection; a request line cut off that way no longer ends in a broken-pipe traceback), runs at most two Codex
decisions at once (a third waits 2 s, then gets 503), serves at most 32 connections at once (one more is answered
503 and closed at once; each held a thread, with no limit), and on a Codex timeout kills Codex's whole process
group, not only the direct child, then drains its pipes for at most 3 s and waits at most 3 s more (a descendant
that left the group withsetsidand kept stdout open used to hold the request, and its decision slot, for as long
as it ran; the reply stays 504). Stopping the bridge (Ctrl+C or SIGTERM) kills the Codex runs still in flight the
same way, skipping only a run the handler has already reaped (a Codex that exited while its children hold its pipes
is still signalled, so they are killed too). Codex now runs in its own session, so the terminal's Ctrl+C no longer
reaches it and the shutdown sweep kills it instead (in 1.15.0 a SIGTERM to the bridge left it running, orphaned). - The Codex host bridge answers errors with fixed texts and logs the detail itself. The Codex host bridge answers
a request body that is not UTF-8 with 400 and a fixed message instead of a 500 carrying the exception text, answers
any other unexpected error with a fixedinternal errorand logs the detail on the bridge side, and no longer
returns Codex's stderr to the controller on success (it logs it instead; the controller never read that field). A
Codex run that exits nonzero is answered 502 with the fixed messagecodex exited with <code>; see the bridge log
instead of up to 4,000 characters of Codex's stderr or stdout (host paths, possibly a token); the bridge logs that
output (stderr, or stdout when stderr is empty), or the exit code when Codex printed nothing. - The Codex host bridge no longer deletes what it finds at its socket path. The Codex host bridge now removes only
a stale socket at--socket-path: a regular file, directory or symlink there stops it with a message instead of
being deleted, as does a socket another bridge is listening on (it connects first, and removes the socket only when
the connection is refused; any other connect failure but a timeout or a full backlog, such as another uid's 0600
socket, stops it with "cannot tell whether a bridge is listening on "), a path too long for a unix socket is
refused with its length, and the socket is set to 0600 explicitly after binding. On POSIX each bridge holds an
exclusive lock on<socket-path>.lock(created 0600, left in place) for its whole life, taken before that check, so
a second bridge on the same path stops at startup with "another bridge is running on " instead of racing the
first one's probe, a lock file it cannot open (a symlink, or another uid's) or cannot lock (ENOLCK, or a
filesystem without locks) stops it with a message naming that file, and at shutdown a bridge checks, just before
removing the socket, that the path still names the one it bound, which keeps it from removing a socket a later
bridge bound there, but not one a process that ignores the lock puts there between the check and the removal. - Loading a large multi-line
.envvalue is no longer quadratic. The scripts'.envloader no longer re-parses a
whole multi-line quoted value for every added line: only a line that holds the opening quote character can close it,
so a PEM-sized value is no longer re-parsed on every line. .envno longer overrides a variable a script declared. The scripts'.envloader no longer overwrites a
variable the calling script declared without a value (local x,declare x): it read such a name as unset and let
.envset it.bootstrap_cli_auth.shrefuses aCLI_HOMEthat climbs out with...scripts/bootstrap_cli_auth.shnow
refuses aCLI_HOMEwith a..component (/data/../etcmatched/data/*).agent_eval.pytakes its token from the environment, not the command line.scripts/agent_eval.py --execute
reads the controller token fromAUTO_BROWSER_TOKEN;--bearer-tokenstill works but is deprecated, warns, and is
documented as visible to every local user in the process list.
Changed
- Mesh and curator settings are read like every other setting, and a bad value stops startup.
MESH_ENABLED,
MESH_IDENTITY_DIR,MESH_PEERS_PATH,MESH_TIMESTAMP_WINDOW,CURATOR_PROVIDERandCURATOR_MODELare now
Settingsfields, read from the controller's settings rather than fromos.environat startup. The names and
defaults are unchanged;MESH_ENABLEDnow takes any boolean spelling pydantic accepts (not onlytrue), and an
unparseableMESH_ENABLEDorMESH_TIMESTAMP_WINDOW, an empty one included (MESH_ENABLED=), stops startup
(before, anyMESH_ENABLEDother thantrue, in any letter case, meant off). The harness settings lost their
redundant environment fallbacks. - Logs no longer carry the full URL of every outgoing request. httpx's per-request
HTTP Request:INFO lines are
no longer logged, at anyLOG_LEVELand for every client (the approval webhook, the providers, the curator): each
named its URL whole, userinfo, path and query included. httpx's warnings and errors still are. - The GwPriority warning comes once, at the first isolated provision, and says what goes wrong. The GwPriority
warning, now starting "GwPriority is not honoured", is logged once at the first isolated provision on a daemon
without GwPriority support (not at startup), whatever the network names: its check compares names only, and the
gateway and the published port can move anyway. When the session network's name sorts before the controller's, it
also names that order problem. It also covers a client that speaks an API version below 1.48. - The drift tools say what they check.
harness.check_driftandharness.check_all_driftsnow say what they do:
they re-verify a staged candidate's stored contract and trace and cannot detect a site change.
docs/convergence-harness.mdsays the same. node_meta.jsonis a consistency check, not a tamper check. The mesh identity'snode_meta.jsoncheck no
longer claims to detect tampering: the file sits beside the key, so anyone who can replace the key can replace it.
It stays as a consistency check, and a mismatch now says "stored node_id does not match the key (corrupt or mixed
identity directory)".- Mesh
require_approvalis deprecated. No approval handler is wired, so a grant that sets it always answered
approval_requiredand its capability could never run. Loading such a grant now logs amesh.peers:warning saying
so, the field is still parsed (an existing peers file stays valid), and the docs example no longer shows it. TYPING_DELAY_MSis gone; nothing read it.TYPING_DELAY_MSis removed from the settings,.env.exampleand
docker-compose.yml: no release ever read it (typing pacing isHUMAN_TYPING_MIN_DELAY_MSand
HUMAN_TYPING_MAX_DELAY_MS). An old env file that still sets it is ignored.- Known limit: a
takeoverstep the agent loop guard adds shows the page before the last action. Thetakeover
step the agent loop guard appends to an agent run carries the previous step's observation (the page as it was before
that step's action), not a fresh one; the harness trace ignores it when it picks the run's final observation. - The controller pins pydantic 2.14.2 and typing-inspection 0.4.4.
pydanticis pinned to 2.14.2 (which pins
pydantic-core2.50.2),typing-inspectionto 0.4.4 andclick, which uvicorn needs, to 8.5.0. Their newer
releases (pydantic 2.14.3, pydantic-core 2.50.4 and typing-inspection 0.4.5, which the 1.15.0 image carried, and
click 8.5.1) were uploaded on November 4, 5 and 6, under 72 hours before this release was built; pydantic 2.14.2 is
outside the affected range of every pydantic advisory, and OSV lists none for click 8.5.0.