Skip to content

layer 1 microVM: the guest is the host's own PHP, validated; every check before auto commits (#101) - #102

Merged
samifouad merged 11 commits into
mainfrom
claude/host-guest-101
Nov 13, 2026
Merged

samifouad merged 11 commits into
mainfrom
claude/host-guest-101

Conversation

@samifouad

Copy link
Copy Markdown
Member

Closes #101. Unblocks #100 (the auto flip). Part of #53.

Sami decided on 12 Nov that the microVM adapts to the host. The guest is now built from the host's own PHP, and everything captured is validated.

What changed

The guest is the host's PHP (ext/fpm/src/capture.rs, pkgdb.rs, phpconf.rs). Each start captures:

  • php-fpm, every .so in its extension folder, any .so a config names inside PHP's own folders;
  • for each of these, the libraries the host's own loader lists (ld.so --list, glibc or musl);
  • the programs PHP runs when the host has them (/bin/sh, sendmail, convert/magick, gs, and the php CLI that layer 3's helper runs), plus ImageMagick's modules and ghostscript's resources;
  • data: ld.so.cache, passwd/group (never shadow or /etc/ssl/private), the CA certificates and OpenSSL's links;
  • php.ini, the scan folder, php-fpm's config with its includes and pools.

The guest has four disks:

  • rootfs.ext4 is now only the SecureCore base: a static init, the preload, the warm-up script and mount points. It is 37 MiB, was 1110 MiB.
  • A PHP layer and a config layer, each cached by the sha256 of what it holds.
  • The site disk.

Validation. Any failure names the file. microvm then exits 125; auto falls back to gelada.

  • Package checksums: dpkg md5sums, apk SHA-1 or rpm digests must match. A merged /usr is looked up both ways.
  • Ownership: every file is root's and writable by no one else, in root-only folders all the way from /.
  • Links:
    • allowed: top-level and merged-/usr links, package-installed links, alternatives;
    • a link no package installed (ldconfig's sonames, busybox's applets) is allowed only to a file whose package checksum matches;
    • an unpackaged file is never reached through a link.
  • Configs: parsed, and refused if they load native code from outside the captured set, or run auto_prepend_file, auto_append_file or opcache.preload outside the app root.
  • The bytes that boot: the copy placed in the disk is hashed again.

The root-only manifest is <state>/capture-manifest.json (0600). It records path, owner, mode, sha256 and source. Changes since the last capture are logged.

One VM per pool. Each VM:

  • listens at the pool's listen, with its listen.owner/listen.group/listen.mode and $pool replaced (--listen still wins for one pool);
  • runs as the pool's user;
  • carries over pm/pm.*, env[], php_*_value/php_*_flag, clear_env and the rest;
  • drops settings that name host paths, and logs which.

With several pools, the launcher starts a launcher per pool (--pool <name>, state in <state>/pool-<name>/). It tells systemd once all of them serve, forwards signals, and stops them all if one stops.

Every check before auto commits. prepare_all() runs before choose() decides. It covers:

  • host checks, then capture and validation;
  • the pool's user and listen, and the sockets;
  • the vault env sources and the pool's env[];
  • claim_state;
  • space for every new disk plus the snapshot, keeping a twentieth of the filesystem (at least 1 GiB) free;
  • the PHP and config layers, the site disk (copied as the pool user) and the writable disks.

Also: a VM that auto chose and that fails before it serves drops to gelada (layer 1 isolation auto: gelada, because the microVM failed before it served (…)). microvm still exits 125.

A bare 3306 and localhost. A { "port": 3306 } with no socket or address now goes to the host's MySQL socket: PHP's mysqli.default_socket/pdo_mysql.default_socket first, then the standard places. Failing that it goes to 127.0.0.1:3306, and only then is it egress. The guest gets unix sockets at PHP's default sockets, /run/mysqld/mysqld.sock and /tmp/mysql.sock.

A long first start. EXTEND_TIMEOUT_USEC=30000000 is sent every 10 s from preparation until the VM serves, plus STATUS= lines.

A missing program is logged.

  • When a shell PHP started reports "not found", the guest's init logs guest-init: "convert" isn't in the guest: the host had no such program to capture ….
  • The preload also hooks execve/execv/execvp for direct execs.

Smaller pieces:

Measurements ([xps], the ext-microvm stack, PHP 8.3.36)

start to ready
first build (capture 2.7 s, PHP layer 2.0 s, config layer 23 ms, site disk 0.6 s, writable disks, snapshot 1.1 s) 8.3 s
after a real package upgrade (zlib1g from trixie-security: capture, PHP layer 1.8 s, snapshot 1.4 s; the site disk was rebuilt too) 7.3 s
php.ini-only change (config layer 23 ms, snapshot 1.2 s) 4.6 s
normal restore (capture reused, nothing hashed) 0.26–0.28 s

What was captured on the test stack:

  • 1135 files (201 MiB) and 119 links;
  • 1116 of the files checked against dpkg, 19 unpackaged and root-owned;
  • 19 configs and 1 pool.

The PHP layer image is 283 MiB (188 MiB on disk).

Evidence

gate result
docker build --target check (clippy -D warnings + cargo test, whole workspace) on the first commit rc=0 (fpm: 101 tests, including dpkg's real database)
cargo clippy -p securecore-fpm --all-targets --target x86_64-unknown-linux-gnu -- -D warnings clean
test/ext-microvm.sh (run 4, with the new checks) rc=0, all ext-microvm checks passed, 267 ok, 0 FAIL
test/ext-capture.sh (new): Debian trixie, Alpine 3.22, Fedora 42 rc=0, all ext-capture checks passed

Clippy: no warnings.

The new checks in ext-microvm.sh:

  • the start captures the host's PHP, checked against dpkg;
  • the manifest is 0600 root and has its sources;
  • the guest runs /usr/local/sbin/php-fpm with the host's scan folder;
  • the missing-program line;
  • EXTEND_TIMEOUT_USEC arrives before READY=1;
  • a normal restore reuses the capture;
  • a php.ini change rebuilds only the config layer, and the guest sees memory_limit = 201M;
  • three tamper refusals, each naming the file, with microvm exiting 125:
    tampered-lib: naming /usr/lib/x86_64-linux-gnu/libxml2.so.2.9.14  ("don't match what dpkg recorded for libxml2")
    writable-ext: naming …/no-debug-non-zts-20230831/sockets.so          ("everything captured must be root's and writable by no one else")
    outside-so:   naming /usr/local/etc/php/conf.d/zz-sc101-evil.ini:1  ("extension = /opt/sc101/evil.so loads native code from outside the captured set")
    
  • a bare 3306 with DB_HOST=localhost serves WordPress through the host's MySQL socket;
  • two pools: each answers pong at its own socket with its listen.mode, each has its own state, systemd gets one READY=1, SIGTERM stops both.

ext-capture.sh covers each package manager's own distribution PHP. Each one:

  • captures it;
  • refuses a packaged opcache.so that has one byte appended (dpkg, apk and rpm records);
  • refuses one owned by 65534;
  • refuses an extension=/opt/evil/x.so, each naming the file.

The suite also found and fixed:

  • extensions have no PT_INTERP, so php-fpm's loader is used for them;
  • /bin links were missing;
  • php-fpm's -i prints HTML;
  • musl's --list exits 127 on extensions;
  • rpm needs %{=TAG};
  • Fedora's /usr/sbin link and ldconfig's soname links;
  • rpm checksums /etc/passwd.

The status of the remaining gates is in the follow-up comment.

For Sami

  • Unpackaged files can't be checksum-verified. In the official php images, php-fpm and the extensions are compiled and unpackaged. Ownership is all that guards them. A tampered sockets.so that is still root's 0644 passes; only the manifest's change log shows it. A distro PHP (php8.x-fpm from dpkg/apk/rpm) is fully checksum-verified. Pinning the unpackaged files' sha256s at install time, recorded by the installer, would close this. Recommend a follow-up.
  • Links no package installed (ldconfig sonames on rpm distros, busybox applets) are allowed only when they lead to a file whose package checksum matches. A stricter reading of "no links below the trusted roots" would refuse every Fedora and Alpine host.
  • Configs under /etc (passwd, group) are ownership-checked only, as configs are.
  • Multi-pool sites share writable folders. Each pool's VM syncs its own disk with the same host folder. The host still wins conflicts, but nothing coordinates them.
  • musl hosts capture and validate but don't boot. The preload is built against glibc 2.36; a musl preload is needed.

-claude

…ted (#101)

The launcher captures the host's php-fpm, every extension in its extension folder,
their libraries (the loader's own --list), the programs PHP runs and the data they
read, and apart from those php.ini, its scan folder and php-fpm's config with its
pools. Binaries and libraries must match their package manager's checksums (dpkg,
rpm, apk); anything unpackaged must be root's in root-only folders, reached through
no link below the top; configs are parsed and refused when they load native code
from outside the captured set. Any failure names the file. The PHP layer and the
config layer are disks of their own, cached by what they hold; the base
(rootfs.ext4) is only the static init, the preload and the warm-up script.
…e database at a bare 3306 (#101)

- each php-fpm pool gets a microVM listening where the pool says (listen,
  listen.owner/group/mode), running as its user, with env[], php_*_value and pm.*;
- prepare_all does everything a start does before the boot (capture, pool, sockets,
  vault env, claim_state, space with a margin, every disk) before the choice, and auto
  falls back to gelada if the VM fails before it serves;
- a bare 3306 reaches the host's MySQL socket (PHP's default socket first) or
  127.0.0.1:3306, and the guest has PHP's localhost sockets;
- EXTEND_TIMEOUT_USEC while a start prepares; a program the guest lacks is logged;
- the capture handles musl's loader, rpm's queries, ldconfig/busybox links to packaged
  files and /etc configs; test/ext-capture.sh proves dpkg, apk and rpm hosts.
@samifouad

Copy link
Copy Markdown
Member Author

Gate status on the final commit (7e6e328), on [xps], under the build lock, each logged to a file with $? checked.

Passed:

  • docker build --target check (clippy -D warnings + cargo test, whole workspace): rc=0
  • test/ext-microvm.sh: rc=0, 267 ok, 0 FAIL
  • test/ext-capture.sh (dpkg, apk, rpm): rc=0

Failed for the host environment, not the change:

  • test/promote-check.sh: rc=1. Every failure is scripts/package.sh: line 51: zip: command not found on the NixOS host, even under nix shell nixpkgs#zip. It needs a rerun on a host with zip.

Not run yet:

  • the 8 ext-* suites on both targets;
  • test/release-check.sh, with scripts/ext-build.sh and scripts/guest-build.sh first. The release check's microVM leg captures the release-check container's own PHP (root /), so this is the gate most likely to find something.

Revert proof (only partly done):

  • Done: the tamper checks in ext-microvm.sh and ext-capture.sh failed on earlier builds that lacked each fix. Two examples: the mode-0666 config was refused before the test learned to write it 0644, and the rpm and musl readers failed before their fixes.
  • Not done: a deliberate revert-and-rerun for each check.

-claude

…M job failures

- a pool's listen.allowed_clients and listen.acl_users/acl_groups are enforced on every
  connection; a bare listen = 9000 binds 127.0.0.1 only;
- a pool's own launcher never falls back by itself; the first launcher's wait has a
  deadline; EXTEND_TIMEOUT_USEC stops once ready, failed or stopping;
- a bare 3306 goes where wp-config's DB_HOST says, only to a socket root or the database's
  user owns in folders only they may write; no /tmp/mysql.sock, no guessed 127.0.0.1:3306;
- only this site's pools run as VMs (chdir, doc_root, prefix); another site's refuses the
  config, so auto falls back once;
- data files only when world-readable; values with two quoted strings refused, escapes read
  as PHP does, pool values passed byte for byte, ffi.preload checked, captured_ro files only;
- dpkg diversions followed; rpm SHA-224/SHA-384 checked, unknown algorithms refused; rpm
  validated before and after it runs;
- the installer records the unpackaged files' sha256s (trust on first use) and every capture
  checks them;
- capture.rs unit tests for folders, links, NEVER, the re-hash, setuid, code-loading settings
  and the record;
- CI: the privs probe walks the guest in PHP (no find in the guest), the installer's
  free-space fixture is half the base image, /etc/hostname and /etc/hosts are captured, and
  the suites put config files into the php container root-owned.
…he pool sockets as other users

- /etc/hostname and the like differ per host: the install's record of unpackaged files
  covers code only (release-check: the installer's container and the server's differed);
- the MySQL-socket test scratches below / (the system temp folder is 1777);
- the ACL checks run the ping as uid 33 and 65534 from a folder they can reach;
- ext-microvm.sh counts only this site's Firecracker, not another launcher's.
@samifouad

Copy link
Copy Markdown
Member Author

The review findings and CI's failures are fixed in 2963be0 and 15fadb9, both pushed onto this branch with no history rewritten.

CI run 43182460946: diagnosis

The new validation surfaced all four failures. Each was a test's assumption about the old guest image.

release-check:

  • setid_files was empty. The privs probe ran find | wc through the shell. The guest now has only the host's PHP plus /bin/sh, so there is no find. The probe now walks the guest in PHP, covering the base and the captured layer. The capture strips setuid and setgid bits (mode & 0755 at the copy, unit-tested).
  • The free-space check never tripped. The base image is now 38 MiB, so the fixture's 64 MiB tmpfs had room. The fixture is now half the unpacked image.

microVM job:

  • ext-enforce read /etc/hostname, which the guest lacked. /etc/hostname and /etc/hosts are now captured.
  • ext-vault's cleanup ran docker cp on securecore.ini, which kept the runner's uid as owner. The capture rightly refused a config not owned by root, so php-fpm "did not come back". The suites now use php_put, which copies the file and then makes it root's, 0644.

Running the full gates on [xps] then surfaced one more, in release-check: the install's record of unpackaged files covered /etc/hostname, which differs between the installer's container and the server's. The record now covers code only; /etc is held to the ownership rules, as configs are.

Findings and fixes

# finding fix test that fails with the fix reverted
1 allowed_clients/ACLs dropped; a bare port bound 0.0.0.0 Admit is checked on every accepted connection: peer IP against listen.allowed_clients, SO_PEERCRED against listen.acl_users/acl_groups (socket 0666, root always admitted). A bare listen = 9000 binds 127.0.0.1. vm::a_pool_takes_connections_only_from_whom_it_lists, phpconf::listen_forms; ext-microvm: uid 33 answered, uid 65534 refused, a TCP pool refuses 127.0.0.1 not in its list
2 several pools under auto could hang a pool's own launcher never falls back (exits 125); the parent waits at most 300 s and then stops every pool and falls back once; EXTEND_TIMEOUT_USEC stops on ready, failure or stop ext-microvm's pool runs (READY=1 once; SIGTERM stops both); no unit test
3 a bare 3306 trusted any socket goes where wp-config.php's DB_HOST says (a literal, or getenv_docker from the launcher's environment). The socket must be root's or --db-user's, in folders only they may write. /tmp/mysql.sock and the guessed 127.0.0.1 forward are gone. vm::a_mysql_socket_is_trusted_only_from_root_or_the_database, vm::a_bare_3306_reaches_the_hosts_database; ext-microvm: the socket chowned to 1234 refuses, naming it
4 other sites' pools got this site's tree only pools whose chdir/doc_root/prefix is this root run here (php-fpm's only pool may name none); any other refuses the config (pool [X] serves another site (…)), so auto falls back once; documented that one site's pools share writable folders and so must be of one trust level vm::only_this_sites_pools_run_here; ext-microvm's other-site refusal
5 /etc/ssl/certs captured whole data files only when world-readable (a 0600 key is left out); NEVER covers links into /etc/ssl/private capture::secrets_are_never_captured_and_data_is_what_anyone_may_read
6 the parse didn't match PHP's a value with two quoted strings, or text after a quoted one, is refused with file:line; \" and \\ are decoded; pool values pass through byte for byte; ffi.preload is checked; captured_ro accepts files only phpconf::values_are_read_as_php_reads_them_or_refused, phpconf::ffi_preload_must_be_captured_files, capture::code_loading_settings_are_refused_with_the_file_and_line
7 package databases dpkg diversions are followed (the diverter's file at the path, the original at its new path, : meaning unpackaged); rpm algorithms 9 (SHA-384) and 11 (SHA-224) are checked, and an unknown algorithm refuses the file; rpm passes the ownership rules before it runs and its own package checksum after pkgdb::dpkg_diversions_pick_the_package_whose_file_is_there, pkgdb::rpm_sha384_and_sha224_are_checked_and_unknown_algorithms_refused; ext-capture.sh on Fedora
8 capture.rs untested unit tests (run as root in the check target): folder ownership, the link rules, NEVER, the re-hash at copy time with setuid stripped, refusals of php_admin_value/auto_prepend_file, the install record each is in the revert table below
— Sami: trust on first use the installer runs securecore-fpm --check-capture --write-record /var/lib/securecore/unpackaged.json (root's, 0600); every capture checks unpackaged code against it; a missing record is written on first use capture::unpackaged_files_must_match_the_install_record; ext-microvm: sockets.so with a byte appended (still root's 0644) refuses ("recorded at install")

Revert proofs

Each patch removes one check, and then cargo test -p securecore-fpm fails.

On [xps] (as root, in the toolchain image; the control run without a patch passes 115/115). Every test named below is the only one that failed:

01 allowed_clients always true  -> vm::a_pool_takes_connections_only_from_whom_it_lists
02 socket owner check removed   -> vm::a_mysql_socket_is_trusted_only_from_root_or_the_database
03 other-site pools accepted    -> vm::only_this_sites_pools_run_here
04 0600 data captured           -> capture::secrets_are_never_captured_and_data_is_what_anyone_may_read
05 dir_ok always true           -> capture::a_folder_anyone_else_may_write_is_refused
06 NEVER removed                -> capture::secrets_are_never_captured_and_data_is_what_anyone_may_read
07 copy not re-hashed           -> capture::the_copy_is_hashed_again_and_loses_setuid
08 pool php_*_value unchecked   -> capture::code_loading_settings_are_refused_with_the_file_and_line
09 record not checked           -> capture::unpackaged_files_must_match_the_install_record
10 untrusted socket ignored     -> vm::a_bare_3306_reaches_the_hosts_database

On the iMac (the portable checks):

check removed test that fails
bare port to 0.0.0.0 listen_forms
two-string values accepted values_are_read…
pool values re-serialized values_are_read… ("passed through byte for byte")
ffi.preload unchecked ffi_preload…
diversions ignored dpkg_diversions…
rpm algorithm 9 unknown rpm_sha384…

The first [xps] proof run was void: git apply, run inside the checkout, silently skips paths outside its folder, so nothing was reverted. The proofs above come from a scratch copy that is a repository of its own.

Full gates ([xps], under the build lock, each logged with $? checked)

gate result
docker build --target check (clippy -D warnings, the whole workspace's tests) rc=0, fpm 115 passed
test/ext-microvm.sh rc=0, 281 ok, 0 FAIL
eight suites, docker target (config, attribution, layer3, layer1, hosts, enforce, db, vault) 8/8 rc=0; enforce passed on its rerun after config (the first time it ran it found the stack down)
eight suites, microVM target 8/8 rc=0
scripts/ext-build.sh 8.3 nts, scripts/guest-build.sh rc=0 (guest image 1.9 MB gzipped, 38 MiB unpacked)
test/release-check.sh 8.3 nts (with the microVM leg) rc=0, 104 ok, 0 FAIL
test/promote-check.sh (zip checked on PATH inside the sudo env) rc=0, 14 ok
test/ext-capture.sh (Debian dpkg, Alpine apk, Fedora rpm) rc=0, 24 ok

Clippy: no warnings.

The first gate run surfaced two test bugs, now fixed:

  • the socket-trust test scratched under the system temp folder (1777);
  • the ACL pings ran from a folder other users can't read.

Its ext-microvm also failed on a clock-skew check (3 s against the 2 s allowed, a busy box), and it passed on the rerun.

The microVM-target suites ran before 15fadb9, which changes only the record's /etc rule and the tests.

Edits were made with Edit/Write only, with no sed -i and no heredoc edits on repo files.

-claude

…' wait always ends (#102 verification)

- a bare 3306: TCP only to MySQL's loopback ports (3306, 33060) or exactly --db-address,
  connected as the pool user; a unix socket only the database user's, or exactly
  --db-socket; anything else gives the guest no database and says why; a socket directly in
  /run, /tmp and the like is bind-mounted alone, never the folder;
- wp_db_host skips PHP comments, and two defines that disagree are no answer;
- the pools' launchers: SIGTERM, 10 s, SIGKILL, reaped; a stop during the readiness wait
  is taken at once; --pools-ready-within; a 60 s timeout on every Firecracker API call;
- --listen keeps the pool's allowed_clients/ACLs, or refuses when they can't apply;
- no record of the unpackaged files: the start refuses (the installer is the only writer).
…real pool launcher

The check stopped the command-substitution subshell of the background job (its
$(php_root)), not a pool's launcher, so the launcher never started and the test waited
forever. The PHP root is now resolved before the job starts, the stopped process is one
that runs with --pool, and every wait for a launcher, probe or helper goes through
bounded_wait (SIGKILL and a FAIL past its bound). The missing-program probe runs after
the clock check (its log wait counted as skew).
…ith no egress handshake

release-check found it: connect[].address forwards went through the egress helper,
which answers OK first, and that line broke MySQL's protocol. --egress-connect --raw
connects and pipes without it.
@samifouad

Copy link
Copy Markdown
Member Author

This round is a9ecc80 through e378cb0 on this branch, merges only.

The 19-hour hang

It was the test, not the launcher.

What happened:

  • pools_run backgrounded fpm_env … --php-root "$(php_root)" &.
  • For a moment, the only child of the background job was the command-substitution subshell running docker inspect.
  • pgrep -P $PID returned that subshell, and the test SIGSTOPped it (/proc showed it in state T, with a defunct docker child).
  • The launcher never started, and the test's wait blocked forever.

The fixes:

  • The PHP root is resolved before the job starts.
  • The stopped process must run with --pool.
  • Every wait in ext-microvm.sh (launchers, probes, helpers) goes through bounded_wait, which SIGKILLs past its bound and counts a FAIL.
  • Every gate runs under timeout, and the run is watched with a stall alarm after 20 quiet minutes.
  • The interrupted run had left its pool config in the php container, so the test now clears its own leftovers before it starts.

Findings and fixes

finding fix test that fails with the fix reverted
A DB_HOST reached any loopback port, and any root-owned socket, as root DB_HOST is only a hint among approved targets: TCP only to MySQL's loopback ports (3306, 33060) or exactly --db-address; a socket only if the database user owns it (--db-user; mysql, else mariadb), or exactly --db-socket. Anything else: the guest gets no database, the launcher says why, and the start still serves.
TCP connects as the pool user (--egress-connect --raw).
Mounts: a socket directly in /run, /tmp and similar shared folders is bind-mounted alone, never the folder.
vm::a_bare_3306_reaches_the_hosts_database, vm::a_mysql_socket_is_trusted_only_from_root_or_the_database, vm::a_pool_takes_connections_only_from_whom_it_lists (bind_socket_only)
ext-microvm, hostile DB_HOSTs, each with no database and the reason logged: 127.0.0.1:6379, /run/dbus/system_bus_socket, another user's socket. The database's socket directly in /run serves 200, with only sock-3306/<name> mounted.
A release-check: a forwarded address port broke MySQL the pool-user helper wrote egress's OK\n first; --raw pipes from the first byte egress::a_forwarded_port_has_no_handshake_and_egress_does
D wp_db_host read comments, and took the first define PHP's comments are stripped first. Two defines that disagree (one may sit in an if) give no answer; PHP keeps the first define that runs, which can't be known statically. phpconf::wordpress_db_host_from_wp_config (two separate reverts)
B the pools' wait could last forever stop_all sends SIGTERM, waits up to 10 s, then SIGKILLs and reaps. A stop signal during the readiness wait is taken at once, with no further EXTEND_TIMEOUT_USEC. --pools-ready-within sets the deadline (300 s by default). Every Firecracker API call has a 60 s timeout. ext-microvm: a pool launcher held with SIGSTOP makes the first launcher exit 125 in 31 s (deadline 20 s plus grace 10 s); SIGTERM during the wait exits 0 in 10 s
C --listen dropped the pool's ACLs listen_admit keeps them, or refuses when they can't apply (ACLs on TCP, allowed_clients on a unix socket) vm::a_pool_takes_connections_only_from_whom_it_lists
TOFU a missing record was trusted and written a start without the record refuses ("run the installer to record unpackaged files"), so auto runs gelada and microvm exits 125; the installer (--check-capture --write-record) is the only writer capture::unpackaged_files_must_match_the_install_record; ext-microvm no-record (exit 125, no record written)

Revert proofs ([xps], each patch in its own repository): patches 11–18 each fail exactly the test named above. The control run passes.

Gates ([xps], under the lock, each under timeout, $? checked)

gate result
check target (clippy -D warnings, the whole workspace) rc=0, fpm 116 passed
test/ext-microvm.sh rc=0, 303 ok, 0 FAIL
eight suites, microVM target 8/8 rc=0
eight suites, docker target 8/8 rc=0. ext-enforce reports "stack not up" when it runs right after ext-hosts in this sequence, and passes after ext-config (110 ok). CI doesn't run this docker sequence.
ext-build.sh, guest-build.sh rc=0
test/release-check.sh 8.3 nts rc=0, 104 ok, 0 FAIL
test/promote-check.sh rc=0, 14 ok
test/ext-capture.sh (dpkg, apk, rpm) rc=0, 24 ok (on a9ecc80; the capture hasn't changed since)

CI on e378cb0: my one check found all three jobs still pending (run 43384677045).

-claude

@samifouad
samifouad merged commit 0f0c3d6 into main Nov 13, 2026
3 checks passed
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.

Layer 1 microVM: build the guest from the host's own PHP, validated; fall back before committing

1 participant