Skip to content

chore(release): gate v0.6-dev into v0.6 🚀 - #33

Open
github-actions[bot] wants to merge 80 commits into
v0.6from
v0.6-dev
Open

github-actions[bot] wants to merge 80 commits into
v0.6from
v0.6-dev

Conversation

@github-actions

@github-actions github-actions Bot commented Sep 3, 2026

Copy link
Copy Markdown

Standing release-gate PR. v0.6-dev accumulates incremental work; it merges into the release-ready v0.6 branch only once the cross-repo E2E pipeline is green. It may stay red while the train is in progress.

kp2pml30 and others added 17 commits July 1, 2026 13:20
* chore(ci): post PR panel idempotently and on retarget 💚

* fix(ci): correct git-third-party path in env.sh
* feat(runners): add frozen v0.2.16 executor line ✨

Add executors/v0.2.x as a second genvm-executor submodule (branch v0.2.x) and
activate it in .genvm-monorepo-root. Its runners are the prebuilt v0.2.16
universal tarball. compat.nix freezes the v0.2 line so its legacy-ABI runners
serve only v0.2 executors and do not roll up into v0.3.

* feat(genvm-tool): add codegen backends for modules-interfaces ✨

* chore(executor): bump v0.2.x gitlink for cargo fmt 🎨

* feat(genvm-tool): namespace executor feature branches as pr/<line>/<name> ✨

* feat(ci): auto-open and link executor PRs, clean up branches on merge ✨

* fix(ci): fan executor PRs and merge over active lines, not the manager base 🐛

* feat(manager): add check-install to verify and precompile executor runners ✨

* fix(packaging): lay v0.2.x runners into executor/<version>/legacy-runners 🐛

The v0.2.x config points at executor/<version>/legacy-runners, but the
packaging still pooled every line's runners into the shared top-level
runners/ dir, so that folder was never populated. Split the runner list by
line: forward-rolling lines keep the shared runners/ tree, while legacy
(v0.2.x) runners are laid out at executor/<version>/legacy-runners/ and
overlaid onto the combined `genvm` distribution and the dev out/ tree.

* chore(executor): bump v0.3.x gitlink 🎨

* fix(genvm-tool): make hooks robust to the inherited environment 🐛

Two ways a hook inherited state from the invoking dev shell / parent repo and
ran against the wrong thing:

- A pre-commit / commit-msg hook runs with GIT_DIR / GIT_INDEX_FILE / ... set
  to the parent repo. `hook run` fans out to every repo (and its submodules)
  by explicit path, so those pinned each `git -C <submodule>` to the parent's
  index/objects and crashed them (`git diff --cached` -> exit 128, e.g.
  ".git/index: Not a directory" since a submodule .git is a gitlink file).
  Strip the repo-scoping GIT_* variables up front.

- The dev shell exports PYTHONPATH pointing at its own genvm-tool build, so the
  hook's python imported genvm_tool from there instead of the freshly installed
  tool (running stale code). The stub now clears PYTHONPATH / NIX_PYTHONPATH so
  it always uses its own baked-in deps.

* docs(skills): add submodule multi-repo workflow skill 📝

* docs(skills): revise and cross-link skills for the submodule dev workflow 📝

* fix(ci): pass ?submodules=1 to nix so executor lines resolve 💚

Nix filters the flake source to tracked files only, dropping submodule
contents; the flake eval forces executors/<line>.x/manifest.json, so
every nix develop/build .# blew up during evaluation. Also check out
submodules in module-test-python, which cds into the executor tree.

* fix(manager): patch legacy "method" calldata key on run endpoint 🩹

Old-format ABI calldata stored the contract method name under the key
"method"; the current ABI uses the empty key "". Detect old-format
calldata at the run endpoint, log an error so stale callers are visible,
and rewrite the key in place before handing it to the executor.

* fix(nix): pin lief 0.17.6 so patch-rpath doesn't corrupt executor binaries 🐛

nixpkgs pins lief 0.17.0, whose ELF Builder counts NOBITS sections in
its file-layout calc and emits a corrupt section-header table on our
~290 MB musl PIE binaries, breaking patchelf finalize. Override to
0.17.6, which skips NOBITS in layout. See lief-project/LIEF#1315.

* chore(tests): type debug_mode as a literal enum in base host 🎨

* chore(ci): scope coderabbit to version branches, skip genvm-tool 🔧

* chore(ci): ignore root test fixtures in coderabbit, bump executor gitlinks 🔧

* fix(ci): call genvm-tool from PATH in rust test pipelines 💚

The rust and rust-fuzz pipeline scripts invoked a non-existent
support/tools/genvm-tool/genvm-tool wrapper, failing with exit 127.
These scripts run inside the nix rust-test dev shell, which already
provides genvm-tool on PATH (packages-0), so call it bare.

Claude-Session: https://claude.ai/code/session_01Sa2F8Kv4XdrPPNgnBhbWrS

* fix(ci): make GCP auth optional in module-test-rust 💚

The Google Cloud auth step is only needed to upload freshly-built runners
to the GCS cache, which is already best-effort (`|| true` in
test-rust.sh); downloads use the public bucket and need no auth. On fork
PRs (or when GCP_SA_KEY is unset) google-github-actions/auth errors out
and fails the whole job. Gate the auth and Cloud SDK steps on the secret
being present so tests still run without caching.

Claude-Session: https://claude.ai/code/session_01Sa2F8Kv4XdrPPNgnBhbWrS

* chore(tests): add hashes to v0.2

* chore(ci): rework release pipeline for the manager repo 🚀

The workflow was copied from genlayerlabs/genvm and never ran here: the
tag was semver-bumped in CI while GENVM_PROFILE comes from
.genvm-monorepo-root, the unversioned executor targets no longer
existed, --genvm-reroute-to is gone (rerouting comes from
build/info.json), and builds lacked submodules. Adds executor[-platform]
and runners-all-dist nix targets so published assets keep the names
downstream download scripts already consume.

* chore(executors): bump v0.3 for det-mode SIMD lane fix + embeddings test 🔧

* docs(spec): add executor versioning compatibility spec 📝

* feat(tests): add per-executor ignore-hash config via .genvm-tool.py ✨

* feat(ci): add commit-message validation script and hook ✨

* docs(docs): reorganize contributing guides into howto structure 🚚

* chore: bump executor submodules, update integration.py for 10 fee buckets 🔧

* feat(fees): contract-funded message fees, emission fee floors ✨

* chore(submodules): bump executors/v0.3.x ⬆️
* docs(spec): use_balance permission, funding modes, fee floor constants 📝
* chore(tests): mirror use_balance emissions and fee error taxonomy ✅
* fix(ci): run git third-party update inside each executor submodule 💚
* docs(contributing): runner hash hygiene guide, per-executor setup 📝

* chore(submodules): bump executors/v0.3.x for missed wasmtime patch ⬆️

* feat(runners): runner memory accounting per ADR-012 📝✨

* chore(spec): cleanup

* docs(spec): document VM startup flow

* docs(spec): define VM meta-properties

* chore: minimize test runner output

* chore: flush pending public abi ✨

* chore: simplify memlimiter ✨

* chore: migrate to manager provided structs ✨
* chore: revive release CI

* fix(test): discover executor crates by recursing submodules 🐛

collect_rust finds Cargo.toml/fuzz targets by scanning Context.git_files, which ran a plain 'git ls-files'. Since the monorepo split each executors/<line>.x is a submodule, so plain ls-files stops at the boundary and only the two manager crates are seen — every executor rust crate (calldata and its fuzz targets included) silently went untested, and executors carry no tests() hook of their own. Recurse into submodules (uninitialized ones are skipped) to restore pre-split discovery: 2 -> 16 crates.

* fix(build): resolve a Build passed as a dependency to its output 🐛

A Build used as an add_dependency/output reference — e.g. all/bin depending on the all/manager and all/executor/<v> phony aggregators — fell through _scalar's type switch to str(build), emitting the object's default repr ('<genvm_tool_plugins.ninja.Build object at 0x...>') as a literal ninja path, so 'ninja all/bin' failed with 'missing and no known rule to make it'. Handle Build in _scalar by referencing its primary output (enough to force a multi-output edge), so passing a Build anywhere a target reference is expected just works.

* fix(ci): retry transient gh reads in the executor-PR precondition 🔒

check-executor-prs went red because 'gh api repos/.../pulls/4' came back with an empty body, which gh surfaces as 'unexpected end of JSON input'; manager_info cannot tolerate a miss, so that single hiccup failed the whole landability gate (and cascaded into gate-check and validate-end, skipping the test matrix). Every gh call here is an idempotent read, so wrap the gh helper in a bounded retry with linear backoff for transient signals (empty body, 5xx, rate-limit, network). A terminal 4xx — including the 404 that allow_missing callers expect for an absent executor line — is not retried, so that path stays fast, and an exhausted retry still raises exactly as before.

* fix(ci): stop the PR-diff fetch from recursing submodules 🐛

ci-changes.py reads gitlink SHAs out of the superproject trees via git ls-tree and never touches a submodule object, but its fetch inherited git's default fetch.recurseSubmodules=on-demand once get-all-git.py had populated the submodules. On-demand recursion then tried to fetch every executor gitlink the PR range touches; a historical commit in the range pins an executor commit that was never pushed to its remote, so the whole fetch aborted with 'upload-pack: not our ref'. Pass --no-recurse-submodules so only the superproject refs are fetched.

* chore(ci): run full tests as a planned matrix of reusable cells ♻️

Replace the fixed module-test-* jobs with plan-queue-matrix (emits the cell
matrix, marker-gated) fanned out through a reusable test_cell.yaml; each cell is
declared once as DefaultStepInfo (genvm-tool test filters + per-cell runner
setup) and executed by test-cell.

Supporting granularity: split ninja `all/bin` into `all/manager` +
`all/executor/<v>` and add an `all/runners` phony so cells build only what they
need; a `minimal` devshell for `genvm-tool configure`; tag the genlayer-py-std
suite so `--filter-tag` selects it.

* feat(ci): executor mirror PR provisioning and a manager-PR landability gate ✨

Adds `pr-branches`, a CI tool over a manager PR and every executor line it ships:
- pr_branches_info: per-repo base/head sha, ahead/behind, mirror-PR url and
  rebased/synced/moved flags, all read through the gh API (no checkout)
- subcommands show-info, provision (force-push each moved line's mirror branch
  to its pinned commit and open/reuse its PR) and check
- queue gate check-executor-prs (every repo rebased, every executor's pinned
  commit present so it can land), aggregated by gate-check before the heavy jobs
- a "Provision executor PRs" panel checkbox that dispatches
  branch_provision_executor_prs.yaml

Panel and merge now run their scripts from the PR branch under a ci-safe guard,
so a PR exercises its own support/ci.

* chore: split docs, rework ci

* fix(ci): harden the merge squash against review findings 🔒

A review of the squash-on-merge change surfaced several ways it could corrupt a
protected branch:

- The re-tick provenance lookup grepped the whole commit message, and the body
  is the raw PR body. A PR quoting `GenVM-Squashed-From: <sha>` (a revert quoting
  what it reverts) could make a squash record bogus provenance, so a later PR
  pinning that sha would push nothing and repoint the manager gitlink at the
  wrong commit. Strip that trailer from the body and normalize CRLF while there
  (commit-tree does no cleanup, unlike git commit, so the executor and manager
  messages for one PR would otherwise differ byte-for-byte).

- The executor squash message referenced the manager PR as a bare `#N`, which
  resolves to an unrelated issue in the executor repo; qualify it as owner/repo#N.

- coauthor_trailers claimed to filter AI/tool attribution but did not, so a bot
  commit in the range could land a Co-authored-by the commit-message hook
  rejects — and nothing re-validates a generated squash message. Filter it.

- Nothing stopped the manager gitlink moving backward: the 0-behind gate is on
  commits, not the pointer, so a PR current on commits but stale on the gitlink
  could silently revert another PR`s executor work. Refuse a landed commit that
  is an ancestor of the base`s current gitlink.

- A hand-merged executor PR (right tree, new sha, no trailer) used to wedge the
  line as diverged; recognise it by tree equality and mirror the tip.

Also preserve the author date (was becoming job time), parse author identity
NUL-separated (names with `<`/spaces), and correct the now-stale strategy
comment in branch_merge_into_dev.yaml.

* fix(docs): build the docs site again after the repo split 📚

The docs pipeline had been broken since the split, in three places.

generate.py read flake-config.json, which no longer exists, and passed
commitToTagStr / build-config-str to runners/docs.nix, which no longer takes
arguments — each runner now carries the version of the line it came from, so
docs.nix groups by that. It also resolved its own directory through
Path("__file__") — the literal string, not the file — so it only ever worked
from one cwd.

docs.nix assumed every runner has a `hash`. Only the forward-rolling lines do;
the legacy v0.2 line exposes just `uid`, so adding that line made the eval
fail. The hash the executor puts in the on-disk path is in `uid` either way.

The runner pages are built from git: tags, tag messages, and the log between
two runner versions. A runner version is an EXECUTOR version, tagged in the
executor repo, with its sources under that repo`s runners/ — but generate.py
asked the manager, whose history contains no executor commits and whose tags
are manager versions. It never matched, so the changelog was silently empty.
Ask the executor checkout instead. It stays empty until the executor repo has
tags, which the reworked release now creates.

Finally, the gen-docs shell needs `?submodules=1` like every other nix
invocation here, since the manager flake imports the executor lines.

* feat(ci): squash executor commits on merge and repoint the manager gitlink 🔀

Merge now leaves ONE commit per merged PR in every repo. Each executor line
had its commits fast-forwarded onto its dev branch, so the executor history
kept every intermediate commit while the manager was squashed. Both sides are
squashed now, and since a squashed line lands under a NEW sha, the manager
commit is rewritten to gitlink that commit rather than the one the PR pinned,
which never lands. A line that is unchanged, or already a single commit on its
dev tip, is left alone and keeps its sha.

Squashing collapses several authors into one, so Co-authored-by trailers are
added for the other human authors in the range. No tool/AI attribution — the
commit-message hook rejects it.

The squashed executor commit carries a GenVM-Squashed-From trailer naming the
commit whose content it holds. Without it, re-ticking Merge after a rejected
manager push (executors are pushed first, so they are already on the dev
branch) would find a tip that is neither an ancestor nor a descendant of the
pinned sha — squashing keeps only the tree — and would block the PR as
diverged, permanently. The trailer is how the second run recognises its own
work, reuses that commit and pushes nothing.

* feat(install): download executors, add --use-patchelf, rename to genvm-post-install 📥

The manager bundle no longer ships the executors, so post-install can no
longer assume they are on disk. It now downloads each line the manifest
lists from that line`s own release, keyed by its executor-version, and
unpacks it at the install root (the tarball is already laid out as
executor/<version>/...). The URL template is a manifest field, next to the
runner one. A failed download is fatal only when a missing executor is
(--error-on-missing-executor).

--use-patchelf sets the ELF interpreter with patchelf instead of lief. lief
is a heavy binary wheel pulled in for that one job: with the flag it is
neither imported nor installed into the venv, since the wrapper drops it from
the requirements (the venv is keyed by their hash, so the two variants get
separate venvs). Default stays lief. patchelf missing from PATH is a hard
error; non-ELF and static binaries are skipped, as with lief.

The entry point is now bin/genvm-post-install, matching bin/genvm-manager and
bin/genvm-modules.

* fix(ci): make the executor release honest about what it publishes 🔒

Three bugs a review of the release split turned up:

Per-line executor targets prefetched no dependencies at all. The registry
keys deps by platform (`executor-amd64-linux`), so `executor-v0.3-amd64-linux`
matched nothing and the prefetch was a silent no-op — masked only because the
manager target, whose dep set happens to be identical, is built first in the
same job. Match the per-line target against the platform key.

A line whose release already existed was skipped without checking WHERE that
release sits. An executor commit that moves the gitlink without bumping
executor-version would leave the manager pinning commit X while the published
executor for that version was built from commit Y. Skip only when the existing
release is on the pinned commit, and hard-fail otherwise.

The legacy line was published as a full release, so GitHub marked v0.2.17
"Latest" ahead of the v0.3 line. Both lines publish identically named assets,
so /releases/latest/download/... served the legacy executor. Only the head
line claims Latest now.

Also drop `actions: write` from the reusable build workflow: a called workflow
cannot exceed the caller (`actions: read`), and uploading an artifact does not
need it.

* ci(release): publish executors to the executor repo, runners as -universal 📦

Split the release along repo lines now that the monorepo is split. The
manager release keeps the three platform bundles and gains genvm-universal
(the runners, which are platform-independent); it no longer carries the
executors. Each active executor line is released into the executor repo
instead, at its own executor-version and at the commit the manager pins as
its gitlink. A line that has not moved keeps its existing release.

Everything is still BUILT here: the executor is deliberately not a build
entry point (the umbrella flake feeds it compiled-libs/deps/support), so the
built assets are pushed across with EXECUTOR_RELEASE_TOKEN — GITHUB_TOKEN
cannot write to another repo. The manager is tagged only after the executor
releases land.

Platforms are now named as nix names them (amd64-linux, not linux-amd64)
everywhere: targets, jobs and published assets.

incl_build_trg takes a list of targets rather than a primary/secondary pair,
and uploads them as one artifact per job; the targets of a platform share a
nix store, so building the manager and every executor line together is no
more expensive than separate jobs.

* ci(hooks): check commit messages across manager and executors 📝

get-src now emits a `changes` output: a JSON object mapping each repo (`.`
for the manager, path for each executor submodule) to its base_commit,
branch_commit and has_changes. A submodule has no history the manager can
see, so its endpoints are the gitlinks recorded on either side of the PR.
Outside a pull request base == branch and has_changes is false.

Use it to lint commit messages in incl_initial: `check-commit-message` is a
commit-msg-stage hook, so the CI pre-commit run (--hook-stage pre-commit)
never fired it and no commit message was checked on CI at all. Every commit a
PR adds is now checked, in the manager and in each executor that moved, each
against its own copy of the script.

* chore(ci): match all dev base branches in coderabbit 🐰

CodeRabbit reads .coderabbit.yaml from the PR head branch, and declaring
base_branches overrides the org default. The `v\d+\.\d+(-dev)?` pattern did
not match `v0.6-dev`, so PRs to the dev branch were auto-skipped (the review
on #4 was skipped, while #3 branched before the pattern landed and was
reviewed).

Spell the suffixes out as separate alternatives instead of an optional group,
and do the same for the executors, whose dev branches were unmatched too.

* ci(tests): emit GitHub Actions error annotations

* chore(ci): keep submodules referenced to cache 🔨

* ci(workflows): use pipeline-local artifacts

* chore(ci): cache submodule checkouts 🔨

* ci: group pipeline logs and make nix artifacts symlink trees 🔗

Wrap each CI pipeline stage in GitHub Actions ::group::/::endgroup:: sections
for collapsible logs (never wrapping a nix develop that re-emits its own
groups, since Actions groups cannot nest). Make the top-level combining
derivations (runner trees, executor/manager bundles) symlink trees into the
store via cp -rsf instead of copying, keeping their store paths as runtime
deps; materialize real files only at the upload tar (find -L plus tar
--dereference) and symlink the built runners under build/out/runners in the
rust-test flow.

* chore: replace in-house commit-hook engine with git-hooks.nix 🪝

Each repo (manager + every executor submodule) now defines its own
git-hooks.nix config in its flake, pinned to that repo's toolchain, replacing
the bespoke genvm-tool hook engine and the per-repo support/nix/precommit tool
flakes. Expose a formatter output so nix fmt runs the same generated hooks in
the working tree. CI runs support/ci/pipelines/commit-hooks.sh, which runs
pre-commit in-tree per repo — the executor crates reach the manager's shared
crates via relative paths that only resolve in the nested checkout, so a
sandboxed nix flake check cannot run their cargo-fmt. Remove the hook package,
the hooks() project functions and now-dead helpers; bump the executor gitlinks.

* fix(web): exempt webdriver connection from SSRF dns filter 🐛

* fix(post-install): reject wrong-OS executor before trusting it 🔒️

A wrong-platform binary shipped in a tarball was silently accepted and only surfaced as an opaque `Exec format error` at runtime. Sniff the ELF/Mach-O header and error on a clear mismatch with the target OS.
* docs: deslopify
* fix: disable codegen for legacy versions
* fix(llm): charge provider usage when the response shape check fails 🔒
* feat(scripting): grow the vm pool on demand instead of waiting ✨
* feat(llm): delegate backend selection and retries to unhardcoded ✨
* chore(ci): consolidate tools under __main__ and rework merge landing ♻
* chore: add check-source-text guard; keep source ASCII and citation-free 🧹
* feat(nondet): validate leader results and entry calldata ✨🔒
* fix(implementation): gate the fuzz examples behind a feature 🐛
* chore(ci): gate merge on a maintainer approval instead of the rtm label 🔒️
* chore(ci): stage merge objects and PR branches before moving dev branches 🏗️
* feat(ci): publish the docs site nightly to sdk.genlayer.com 🚀
* fix(ci): paginate the approval review query 🔒️
* fix(ci): keep a partial merge landing repairable 🐛
* fix(ci): stop the nightly docs deploy clearing the preferred version 🐛
* chore(ci): serialise merges repository-wide 🏗️
* refactor(ci): build the squash message from commit subjects ♻️
* chore: bump executor gitlinks for the fuzz example gating 🔒️
* chore(genvm-tool): drop the unwired test-always-fail-module flag 🧹
* chore(ci): harden the workflows and unify the ci helpers 🔒️♻️
* fix(ci): run the pr-scoped initial checks on dispatched runs too 🔒️
* fix(ci): nest coderabbit base_branches under auto_review 🐛
* chore: bump the v0.3 executor for the vision test rewrite ✅
* fix(ci): close the review-gate and panel gaps in pr automation 🐛
* feat(ci): add an admin-only /genvm-force-merge command ✨
* fix: add pre-push hook
* chore: restructure contributor docs and rework the test harness 📝♻️
* fix(git): ask the remote for the gitlink commit, not for a matching ref 🐛
* chore(ci): push locally built store paths to the nix cache 🏗️
* docs: fix wording and the versions.json path flagged in review 📝
* chore(ci): make the whole nix cache push fail-soft 💚
* fix(build): keep a user pre-push hook and serialize the submodule cache 🐛
* chore(codegen): assert a non-empty description in $str constructors ✅
* chore: migrate to a separate cache repo
* chore(git): check submodules out as worktrees of the shared cache 🏗️
* chore(ci): accept the rtm label in place of an approval 🏗️
* chore(ci): carry commit bodies through a squash, flatten bullets ✨

Squashing has to be associative: a collapsed commit that was itself a squash contributes its bullets to the same flat list, so re-squashing lands what squashing the originals would have.

* feat: add caching to jsonnet eval
* fix: address the first branch-review pass 🐛
* fix(tests): key the jsonnet cache on the files each case really imports 🐛

The digest covered only `_*.jsonnet` and the template `*.jsonnet` files, so
editing `tests/templates/message.json` or an `importstr`-ed contract source
kept returning yesterday's evaluation. Jsonnet's own importer now reports what
it reads and the entry carries those digests, which also lets the case path
into the key: two byte-identical cases in different directories import
different files under the same relative names.

* fix(git): refuse to delete a staging path that is not ours 🐛

Conversion cleared `.genvm-convert-<name>` with an unconditional `rmtree`,
which is only ever right when the directory is what an interrupted conversion
left there.

* fix(ci): keep a squashed body's own paragraph breaks 🐛
* fix(ci): reject control characters in a commit message 🔒️🐛

A squash lays a range out as one text and splits it back apart, so a control
character is invisible where the message is written and splits it somewhere
else where it is parsed: `fix: a<SOH>b` passed the hook and landed truncated
at the SOH, with the tail moved into the body. The hook refuses them now, and
the range is read with `-z` so nothing in-band delimits the records at all.

* fix: address the second branch-review pass 🐛🔒️
* fix(git): repair the worktree entry before the staging path goes 🐛

Converting a second submodule prunes the first one's entry, which still named
a staging directory by then deleted, and a checkout left on a deleted gitdir is
past what `worktree repair` can mend.

* fix(git): replace the fetch refspec rather than add to it 🐛
* fix(tests): resolve imports the way jsonnet reports them 🐛

An import was recorded at its symlink target, so a nested import of its own
resolved from the wrong directory; the two library search paths every vm is
born with were missing as well.

* fix(ci): pin the shared actions to a sha 🔒️

They run with the cache and model tokens, and a job re-run months later has to
run the action it first ran.

* fix(ci): agree with the commit hook on what a bullet is 🐛
* fix(tests): lock metric bumps, which collector threads share 🐛
* docs: name both cases a conversion refuses, and what an empty pull token means 📝
* perf(tests): let the jsonnet cache commit without an fsync ⚡

Its entries are all re-derivable, so losing the tail of one to a power cut
costs a re-evaluation. Measured over 314 committed inserts on ext4: 1.035s at
`synchronous=FULL`, 0.026s at `NORMAL`.

* chore(tests): keep the jsonnet cache with the test artifacts ♻️

`artifacts_dir` is where a run's own scratch belongs, and it honours the
config override that `build/` does not.

* fix: address the third branch-review pass 🐛
* fix(tests): re-resolve a cached case's imports, not just their bytes 🐛

A file dropped in beside a case takes over an import that used to fall through
to the search path, and the file it used to land on never changed.

* fix(git): refuse a gitlink the index has left unmerged 🐛

`ls-files --stage` prints one line per conflict side there, and the first one
was taken as the pin.

* chore: cut comments back to what they say ♻️
* chore: fix tests
* feat(manager): websocket run protocol and cross-major contract calls
* feat(manager): run cross-major contract calls as nested runs ✨
* feat(manager): make cross-contract call resolution opt-in ✨
* feat(manager): refuse nested envelopes asserting unserviceable permissions 🔒️
* fix(manager): refuse a nested reply carrying any reported effect 🔒️🐛
* fix(manager): stop the call route from being consensus-visible 🐛🔒️
* refactor(manager): serve executions over an event-driven websocket ♻️
* fix(manager): harden the run socket protocol 🔒️🐛
* fix(manager): drop runtime env mutation and open the lua stdlib 🔒️
* chore(codegen): generate host-fns and socket ids from one definition ♻️
* refactor(harness): compare the executor execution hash directly ♻️
* test(harness): route a call across a major boundary from jsonnet ✅
* fix(manager): report consumed_result as bytes, not an integer array 🐛
* feat(runners): update SDK APIs and runner hashes ✨⬆️

* chore(abi): rename the pre-finalization state to decided in v0.3 🚚💥
* fix(spec): align v0.3 WASI behavior 🐛
* refactor(codegen): scope trie details to their paths ♻️

`latest_non_final` and `accepted` named an implementation queue rather than
the state-view contract: the view is the latest state-changing decided
transaction, with finalized state as the fallback. Wire values change with no
back-compat alias, so hosts and SDKs must move in lockstep.

* feat(abi): align executor v1 interfaces

* fix(runners): harden v0.3 packaging workflow

* fix(tests): encode cross-major recursion per ABI

* test(integration): skip leader_fault_uncatchable ⏭️

Bump the v0.3.x gitlink: the case's `A: compared ...` prints race between
overlapping nondet queue consumers and a shared stdout, and they are the only
observable that a comparison stage ran.
Use ps when procfs is unavailable so cross-major cancel and deadline release assertions retain their process-tree coverage on macOS. Cover transitive traversal and live child discovery directly.
* chore: establish contributor and release workflows 🏗️
* chore(ci): make manager own branch updates and full tests 🏗
* fix(web): separate sidecar faults from page observations 🐛
* fix(web): label webdriver faults and keep them fatal so validators abstain 🐛
* fix(web): route a disconnected host as our fault, not the site's 🐛
* fix(webdriver): bound the CDP protocol timeout below the request deadline 🐛
* chore(webdriver): split rendering out of index.ts into render.ts ♻️
* chore(modules): extract module_error_to_wire from the message loop ♻️
* chore(web): cover both channels at the module boundary ✅

A failure of our own sidecar is not an observation of the page, so it must not
reach the contract as one: a validator whose sidecar broke has nothing to vote
on and must abstain instead of asserting a result it never computed. The two
channels are therefore kept apart -- returned `Resulting-Status` for the page,
thrown for us -- rather than collapsed onto one status code.

* chore(test): wire typescript tests
* fix(executor): meter retained outputs against RAM 🔒️
* fix(webdriver): block popups 🔒️
* fix(executor): enforce nondeterministic output caps 🔒️

---------

Co-authored-by: Darien Hernandez <dohernandez@gmail.com>
Co-authored-by: Edgars <edgars@genlayerlabs.com>
* fix(ci): materialize the full executor history for the branch sync 💚

A shallow gitlink checkout holds the pinned commit alone, so the push cannot
be shown to build on the target branch and the server rejects even a genuine
fast-forward.

* fix(storage): make the final octet of a slot addressable 🐛

* chore(build): take git-third-party from its flake input 🏗️

The vendored copy is replaced by a pinned flake input, which also carries the
tool through `env.sh` and `get-all-git.py` -- both run before the dev shell, so
they realize the package themselves.

* chore(deps): move the executors to wasmtime 48 ⬆️

Wasmtime 48 declares rust-version 1.95, above the 1.94 the pinned channel
provided, so the toolchain moves with the gitlinks.

* chore(ci): watch vendored upstream sources for published advisories 🔒️

* chore: remove legacy compatibility layer

* fix(ci): test emoji reaction 🐛

* chore(build): warm the webdriver image from a ninja target 🔨

* chore(build): build the webdriver docker image as `webdriver/image` 🔨
* chore(ci): build that target in the mock PR cell so the lazy spawn hits the cache 💚
* fix(tests): coerce jsonnet allocation recipients to `Address` recursively 🐛
* feat(expr): add internalError and keep the failure class on replay ✨

* fix(ci): set nix up before the source checkout 💚

`get-all-git.py` realizes `git-third-party` from the flake, so every job that
updates third-party trees needs nix during the checkout step, not after it.
The nixless commit-messages job wants git history rather than vendored sources,
so it skips the update instead.
* fix(executor): bound retained RAM a contract can drive 🔒️

- intern directory descriptor path components instead of keeping owned strings
- bound the host balance cache, which grew per distinct address for a whole run
- spec: a sub-VM copies its caller's RAM budget rather than sharing it, so what
  a child spends never reduces what its caller may still spend

* fix(executor): adopt deferred arguments and balance assertions 🔒️

* chore(ci): pin actions to digests and attest release assets 🔒️

* chore(ci): pin every third-party action to a commit digest, Renovate keeps them fresh 🔒️
* feat(ci): publish SHA256SUMS and a sigstore provenance attestation with each release ✨

* feat(release): pin executor tarballs by sha256 and state what a platform asset ships 🔒️

* feat(release): build-manifest copies a line's executor-sha256 into the manager manifest, validated per platform ✨
* feat(install): post-install refuses an executor download without a pinned hash or with a mismatching one 🔒️
* test(release): cover build-manifest pins, post-install download outcomes and the manager tolerating the sha256 key ✅
* docs(release): a platform asset bundles every executor line, the download is a fallback; how to verify an asset 📝

* chore(build): align v0.2 with Wasmtime 48 ⬆️
@coderabbitai

coderabbitai Bot commented Sep 14, 2026 •

Copy link
Copy Markdown

Important

Review skipped

Bot user detected.

To trigger a single review, invoke the @coderabbitai review command.

Run configuration

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

  • Trigger review
  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

kp2pml30 and others added 12 commits September 14, 2026 20:19
* feat(executor): adopt named fee buckets and opaque outputs ✨💥

Expose named resource caps through the host protocol while keeping leader-proposed output opaque until each executor validates it.

* fix(executor): guard the overlay split, correct fee docs 🐛📝

* test(executor): bump v0.2 for re-recorded send_message goldens ✅
* feat(ci): add a clippy cell to the full matrix 💚

* feat(manager): carry log audience through the sink and evict introspector first ✨

* feat(manager): tag log call sites with audience ✨

* fix(manager): no provider could handle prompt is an operator log 🐛

* docs(impl-spec): describe the log record format and audience 📝

* docs(spec): fix references that name nothing 📝

Every one of these pointed at a label the build never generates, so the page
either dropped the link or the term was simply wrong: two emission constants
that do not exist, a fee error spelled after a code that is not in the ABI,
two mistyped enum and error labels, an under-long heading underline, and a
generated Lua reference that is not part of the site.

* docs(spec): specify the runner count and path limits 📝

Documents what the v0.3 executor now enforces: a per-sub-VM runner count cap
refused as an out-of-memory error, a length and separator bound on the path
argument of path_open and path_filestat_get, and the raised retained-data
charges. Bumps the executor gitlink to the commits that implement them.

* fix(executor): account for ZIP runner metadata 🔒️
…tall (#43)

* fix: drain executor logs and polish CI diagnostics 🐛

* feat(manager): configure executor worker concurrency ✨

* chore(release): advance manager and executor release candidates 🚀

* fix(manager): pass worker control in execution input 🐛

* chore(executor): pin worker ordering regression test ✅

* chore(post-install): hash-pin venv deps and warn on unverified runners 🔒️

* chore(post-install): drop the never-published executor download 🔥

* fix(post-install): keep accepting --arch from forwarding callers 🐛
The host supplies descendant funding and exact subtree transport bytes so pinned storage modes and proofs can be handled without executor ABI encoding. Both executor lines use the same input shape; coordinate the node producer upgrade.
- Walk the whole error chain for `BudgetExhausted`, including `CallbackError`, `BadArgument`, `WithContext` and the `Arc`s `scripting::call_fn` unwraps to
- Cover a `pcall` rethrow, both `call_fn` shapes and an unrelated callback error
- Bump both executor lines to wasmtime 48.0.8
- `cargo update` every manager Cargo.lock and `nix flake update` the flake inputs
- Use nixpkgs lief 1.0.0 instead of the 0.17.6 override, and pin post-install to lief 1.0.0, which carries the same section-header fix
- Bump musl to 1.2.6 for CVE-2025-26519
- Build lsqlite3 against the SQLite 3.54.1 amalgamation instead of its bundled 3.24.0
- Bump hickory-resolver to 0.26 for GHSA-3v94-mw7p-v465, GHSA-5j98-2g5x-46v6, GHSA-q2qq-hmj6-3wpp and GHSA-6f2x-v7q7-m7m5
- Bump puppeteer-core to 25.16.0 for the zod memory-exhaustion advisory
- Make the HTTP test mocks read the request head before answering; with the refreshed stack, hyper fails a response that arrives before its request is written
- Select E4, E7, E9 and F explicitly: ruff 0.17 from the flake update enables a much larger default set, 205 findings in existing code
- Exclude Markdown: ruff 0.17 formats Python blocks inside `.md` files
- Keep ruff's pre-0.17 rule set in the executor
- Skip pyright on `evm/generate.py` until the runner source fix lands with a hash bump
* feat(manager): schedule forks per network in a validated install/data/genvm-chainforks.json ✨
* feat(manager): select lines by the active forks of the request's network, default_network as fallback ✨
* feat(manager): pass --forks to the executor and keep the parent's network in nested runs ✨
* feat(manager): read the network from a Network header on contract/detect-version ✨
* feat(manager): list runner_forks in the manifest and require every fork it names to be scheduled ✨
* feat(manager): validate the schedule and manifest in check-install and pass --defined-forks to genvm check ✨
* test(manager): run the suite on dev, where every fork is active ✅
* test(manager): fail check-install on a runner naming an undefined fork ✅
* fix(executor): reject v0.3 ZIP runners with differing flags, overlaps or file-directories 🔒
* test(py-sdk): replay every fuzz corpus through its own target 🐛
* fix(docs): render mermaid diagrams in the browser instead of with mmdc 🐛
* docs(adr): record fork-gated availability in ADR 016 📝
* chore(executor): bump v0.3 to v0.3.0-rc11 🔖
…macos build links 🐛

- hickory-resolver 0.26 reads the macOS DNS setup through the SystemConfiguration framework, which the zig cross-linker cannot link
- Enable its system-config feature everywhere but macOS, and on macOS parse /etc/resolv.conf with resolv-conf the way hickory does on other unixes
…sion cap ✨

* feat(executor): add executors/v0.4.x as the primary line, v0.4.0-rc1 on fork genvm/executor/v0.4 ✨
* feat(manager): schedule v0.4 always on dev and the new clarke network, never on studio and bradbury-phase2 ✨
* feat(executor): cap external, internal and deploy messages and events together at 65535 per execution ✨
* fix(py-sdk): take the stdlib fixes into v0.4 only 🐛
* build(manager): take the manager crates, py-std tests and spec appendices from v0.4 🔧
* fix(tests): name mock host sockets by root-relative path so lines sharing a case do not collide 🐛
* docs(spec): specify the emission cap and open a v0.4 changelog 📝
* docs(contributing): point runner and py-std paths at v0.4 📝
…epts a strict subset 🔒

* fix(executor): bump v0.4 for the stored-only zip reader and its ZIP subset 🔒
* docs(spec): specify the ZIP subset and the up-front metadata charge 📝
…ut v0.6.0-rc12 ✨

* feat(manager): schedule studio-dev as studio plus v0.4, and phantom-bradbury as bradbury-phase2 ✨
* feat(manager): give the chainforks schedule a JSON schema, checked by pre-commit and accepted as `$schema` ✨
* build(release): rewrite a relative JSON `$schema` to the tagged genvm-manager URL 🔧
* feat(py-sdk): add swap, permute and sort to storage arrays, and a reverse that keeps compound elements ✨
* chore(executor): release the v0.3 line as v0.3.0 🔖
* chore(manager): bump to v0.6.0-rc12 🔖
* docs(spec): keep the v0.3 ZIP rules beside the v0.4 subset and follow the reader's check order 📝
* docs(spec): name the permission checks that precede the emission cap 📝
* docs(contributing): tell runner changes to use the target line, not v0.4 📝
* fix(release): stop the schema patcher from following symlinks 🐛
- The run request requires `create2`, the settlement chain's CREATE2 `deployer` and 32-byte `code_hash`; nested runs inherit it. v0.4 forwards it in the startup message, earlier lines ignore it
- v0.4 py-sdk: `gl.contract.deploy(..., salted=gl.contract.Salted(...))` returns the address GhostFactory creates the child at
- The integration and system harnesses send the devnet pair; the v0.3 routed-call golden follows its v0.4 callee
- Spec and manager API document the field
- Link grant limits and distinguish message byte and count exhaustion
- Describe zero-recipient rejection, calldata results and host transport
- Correct fee diagnostics and contract-major ownership wording
- Await factory-scoped prediction hooks and validate their results
- Normalize CREATE2 inputs per run without mutating handlers, including nested connections
- Match factory reverts and verify the preset vectors independently with ethers
- Bump the v0.3 and v0.4 executor lines: runner-init error classification, sync fork charging, long storage reads, bounded AddEnv expansion, message bucket errors, zero recipient rejection, receive removal and account transfers as external messages
- Pass an unbounded limit to template expansion of trusted manager config
- Regenerate the public ABI and constants appendices
…0.6.0-rc13 ✨

- Schedule `genvm/executor/v0.4` as `always` on `studio`, so contracts
  pinning v0.4 runners get salted children at the GhostFactory address
  their SDK predicts
- Drop the `studio-dev` network: with v0.4 on `studio` it is identical to it
- Cut v0.6.0-rc13
- `--chainforks-path` and `--default-network` override the config for serving and `check-install`, on either side of the subcommand
- `default_network` may be null: a request naming no network is then rejected, detect-version with 400 and a run with `failed_to_start`
- `check-install` validates `default_network` only when one is set
- Studio ships its own schedule, so the `studio` network leaves the shipped one
…forks ✨

A host that passes its own schedule with `--chainforks-path` proves the manager runs the same one with a hash, then asks which forks are active, before it builds a run

- New socket method `get_forks` answers every fork a network schedules and whether it is active at a timestamp, through the same resolver a run uses, on any connection with or without a run
- `network_hash` is keccak256 of the calldata map of the network's activation strings; a different one fails with `chainforks_mismatch`, an unknown or empty network with `unknown_network`
- A schedule naming an empty network is rejected at load
… ✨ (#93)

* feat(manager): give every executor line a status and check the monorepo root ✨

`.genvm-monorepo-root` now maps each line to a status (`preview`, `current`, `maintained`, `replay-only`) instead of an ordered list plus `support-only-versions`

- Schema `support/schemas/genvm-monorepo-root.json`, checked by the `check-monorepo-root-schema` pre-commit hook; `check-executor-lines` runs `check-versions lines` for the rule the schema cannot express, exactly 1 `current` line
- The `current` line is the primary: the manager's sources in nix, manager-global codegen, the docs sub-site and the default reroute target. Configure used to compare the manager version to line keys and always took the first entry
- `check-versions bump` cuts only the next manager train, `v<new>.0-rc0`, and no longer appends the train to the executor lines; it checks the Cargo files before writing anything
- `verify-pushed-executors` still reads `active-versions` from a pushed commit that predates the statuses

* fix(audit): report an NVD CVE only when it names the pinned release vulnerable 🐛

NVD's `virtualMatchString` also returns CVEs where the product is just the platform another product's bug runs on, such as CVE-2022-31631 (PHP on SQLite) and CVE-2021-32921 (Prosody on Lua)

- Keep a CVE only if a `vulnerable: true` entry names the pin's vendor and product, with that entry's own version bounds holding the pin

* feat(audit): block a release on a critical advisory outside replay-only lines ✨

- `genvm-tool audit --gate <severity>` exits 1 on a scored finding at that severity or worse, unless it is in a `replay-only` executor line or waived; a line with an unknown status is gated
- `--waivers FILE` takes the alerts dismissed in code scanning, which the `audit / release gate` workflow exports; a waiver covers only its advisory, file and package
- The gate runs in `release.yaml` before any build and on PRs into a release branch

* feat(release): refuse to build a release binary that pulls in a forbidden crate ✨

- `compile-rust.nix` resolves the graph `cargo build` is about to compile, normal and build dependencies for the release target, and fails on any crate in `support/release-forbidden-crates.json`, printing what pulls it in
- Forbidden: `afl`, `mutatis`, `mutatis-derive`, `lua-src`, `luajit-src`; every line's executor and the manager build through it

* chore(executor): replace small third-party crates in v0.4 with in-house code ➖♻️

- const-lru and bufreaderwriter become genvm_common::util::lru and buf_stream
- concat-idents is dropped; integer casters are named directly
- mt19937 is vendored into genvm-common under its BSD-3 licence

* chore(executor): drop directories-next from the v0.4 build graph ➖

- v0.4 patches a local stub over `directories-next`, the only wasmtime cache
  dependency that resolved platform directories; the executor always sets the
  cache directory itself

* feat(audit): gate a release on every advisory not listed in `audit-ignores` ✨

- `genvm-tool audit --gate` blocks on any finding, of any severity or none, that the `audit-ignores` of its scope in `.genvm-monorepo-root` do not list: `manager.audit-ignores` for findings outside `executors/`, `executor-lines.<line>.audit-ignores` for those of a line. A `replay-only` line is no longer exempt; its rulings are entries like any other
- An entry is `{id, package, reason}`; `id` matches any alias, and no version is kept, so a bump that is still affected stays ignored
- An ignore that matches no finding blocks too, so the list shrinks as fixes land; `--gate` refuses the `--no-*` flags, so a missing report is never let through
- The cross-pass dedup now works per scope, so one line's lockfile finding no longer hides another line's vendored one
- The gate no longer reads code-scanning dismissals: rulings are reviewed in PRs and follow the release branch. The nightly upload stays for visibility
- Seeded from a full audit run: 25 findings, 10 advisories, 0 blocking and 0 stale

* feat(release): build release assets without the GenLayer nix cache ✨

- The release build cells set the new `get-src` input `nix_cache: "false"`, which turns off `enable_genlayerlabs_cache` in nix-setup: a released binary comes from source and cache.nixos.org, never from a cache that any CI push can write
- Runners are fixed-output derivations, so a cold build also recomputes and checks every pinned runner hash
- The cell timeout rises to 360 min for the cold build; the cache push stays, to warm other workflows

* chore(github): request reviews from the manager owners 👥

* chore(executor): bump anyhow past RUSTSEC-2026-0190 in the v0.3 and v0.4 runner patchers ⬆️

- `genvm-floats-to-soft` and `genvm-wasm-add-mod-name` move from anyhow 1.0.86 to 1.0.104 in both lines, so their 4 `audit-ignores` entries go
- Runner hashes are unchanged: the cpython and softfloat runners, the only ones built with these tools, were rebuilt from the new tools without substitution and matched their pins
- A new `escape_html` host function escapes `&`, `<` and `>`; template substitution applies it to every value, so a leader answer cannot close the tag it is wrapped in and steer the equivalence judge
- The judge templates say their input sections are escaped data
…n instead of clamping it 🐛

- A major newer than every line is returned as declared, so running the contract answers `invalid_contract major_mismatch` on every node instead of running on an older line
- A major past 255 saturates, since the root slot stores a byte
- A wildcard, an unparseable major or a failed helper still yields the newest major, now with the helper's stderr and exit status logged
- IPv4: 192.0.0.0/24, 192.88.99.0/24 and 198.18.0.0/15 on top of the std predicates
- IPv6: documentation, benchmarking, ORCHID, Teredo, 6to4, SRv6, discard-only, local-use NAT64 and site-local ranges
- NAT64 and IPv4-translated addresses are checked by their embedded IPv4 address, like IPv4-mapped ones
…l ♻️

- The release already ships every runner in `genvm-universal.tar.xz`, so the download step and the `runners_download_urls` manifest entry go away
- The ELF interpreter is read from the binary itself; patching runs only when that path is missing on the host, needs `patchelf` then, and refuses a binary built for another arch
- No venv and no pip install are left; the removed flags are still accepted and ignored so existing installers keep working
…rowser level ✨

- `GVM_WEBDRIVER_ROTATION_FAILURES` (default 3, 0 disables) consecutive browser-level failures, a closed connection or a `Target.*` protocol timeout, trigger an immediate rotation; any completed render resets the count
- The old browser is closed after the swap; one whose close does not finish within `GVM_WEBDRIVER_ROTATION_CLOSE_TIMEOUT` (default 2m) is killed
- Rotation moves into `browser/manager.ts` with an injectable clock, sleeper and launcher for tests
- The leader template performs the task itself, so its task and input reach the model verbatim again
- Restore the `filter_image` annotation in lib-genvm.lua
- Point the macOS skill at `genvm-universal.tar.xz` instead of the removed runner download
…dle growth per interval 🐛

- The kill deadline now runs until the old browser is really closed, including a close performed later by its last render
- A rotation no longer waits for the old browser to retire, so a failure streak on the new one rotates even while the old one is still closing
- Idle memory growth is judged per measurement interval instead of only until the first render
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants