Repository navigation
Description
Status: draft design v2, revised 2026-11-14 after code archaeology and maintainer review; not approved, no code yet. It touches ADR-001 claim 20 (release artifact verification) and claim 3, so the claim owner approves it before implementation. Any session or tool (Claude, Codex, Kimi, Delta) can implement it from this issue alone. Evidence is from origin/main at 96e484cdd9; statements are read from code unless marked INFERENCE or UNKNOWN.
1. Problem (measured)
A one-command signed-release launch verifies the release proof seven times. On an idle GCP VM (n2-standard-4, SSD, load 0.1 to 0.4, signed v0.28.0-rc.2, Firecracker, curl OCI image, five cold launches, stable to 1 percent, spans from #5508): six full verifications at about 641 ms each, about 4.5 s of a 5.6 s launch. Everything else in admission is small (sign_and_verify_plan 0.3 ms, audit_record 4.8 ms). Each verification reads and hashes the roughly 20 MB archive, verifies the checksum and archive signatures, copies the archive to a temp file and parses it. Data and discussion: #5487, #4391. Budgets (cold p99 300 ms, warm p99 50 ms, reference/performance.md) are not changed.
2. Findings from the code (what the earlier draft got wrong or missed)
All seven run in one process. There is no resident admission daemon: mvm-hostd is a library linked into mvmctl, and the supervisor and driver binaries contain no runtime-verification code (they receive the already bound config). So every one of the seven can share one result. The seven, by lap:
| # | lap | caller chain (CLI run) |
class |
|---|---|---|---|
| 1 | attach_overlay.release_proof_lookup |
exec.rs:1322 to runtime_overlay.rs:123 cached_runtime_release_proof |
duplicate: mints the path-only proof every later check pins against |
| 2 | attach_overlay.release_proof_verify |
same function, runtime_overlay.rs:131 |
duplicate of #1 in the same function |
| 3 | attach_initramfs.release_proof_verify |
exec.rs:1339 to universal_initramfs.rs:154 |
duplicate; its own comment calls the digest check a pre-check and names bind the custody point |
| 4 | runtime_evidence.release_proof_verify |
plan_admission.rs:381 verify_runtime to assurance_runtime.rs:136 |
duplicate in the CLI process; an admission refusal gate |
| 5 | same lap | plan_admission.rs:382 to the assurance probe verify_assurance_guest_protocol |
pure duplicate of #6 (result discarded) |
| 6 | same lap | assurance_runtime.rs:131 AssuranceRuntimeBinding::verify |
eager pre-computation for a possible later assurance campaign, runs on every release launch |
| 7 | same lap | runner.rs:342-347 RuntimeLifecycleLease::bind to runtime_evidence.rs:776 |
the custody point: snapshots the selected artifacts from the verified in-memory archive, hashes them against the declaration while copying, and boot then uses the retained generation paths |
Why they exist. Sites 1 to 7 all came in with #4409 ("authenticate release runtime across launch and restore", 62f65b7231): authenticated selection plus a durable lifecycle binding. No commit, PR or issue says any launch-path site closes a time-of-check/time-of-use window, and none was added to fix a standalone security finding. The closest statements of intent: universal_initramfs.rs:226 ("the digest check here is a pre-check; RuntimeLifecycleLease::bind is the custody point") and registry_pack.rs:38 ("recheck the actual selection immediately before dispatch", built registry packs only, with an audit failure entry). Layered artifact re-hashing was previously called out in #4648 and partly mitigated by the process-local digest registry in #4697.
The verify-to-use gap is smaller than the first draft implied. bind already builds the retained generation from the verified archive snapshot and boots from those paths. What stays path-based before bind is the proof (a set of paths plus a digest), which admission, assurance and attach each re-read; the digest pin (evidence.rs, "runtime proof archive digest changed") is what makes those agree and must be kept.
Other facts that change the design:
- Threat model. The existing code and ADR already exclude a same-user attacker ("the host account is trusted not to chmod or replace its private generations";
~/.mvmis mode 0700). A launch-owned snapshot directory is writable by that same user, so it protects only against non-malicious races (interrupted or corrupt writes, a concurrent cache refresh) and a tampered release artifact, not a malicious same-user process. The first draft's wording was wrong and its tests would have asserted more than the design provides. - Claim numbering. ADR-001 row 9 is about published bundles; the runtime release proof is claim 20 (and claim 3 for the root hash). The first draft cited row 9 in error.
- Verification is offline and deterministic.
verify_release_archiveembeds the Sigstore trust root, derives accepted identities from the tag, uses no network, no wall clock and no revocation list. So per-launch re-verification buys no more freshness than verifying once per process, which weakens the case that per-launch is required for Managed admission and mvmd HostInterface implementation (post-demo) #5124, and makes a later cross-process record safer than first assumed (still its own decision, section 7). - The audit chain does not record the runtime today.
plan.admittedlabels carry workload, signer, authorizer, retention andkernel_sha256;plan.launchedcarries workload and backend. The signedExecutionPlanhas no runtime field (environment: Option<EnvironmentRef>holds onlykernel_sha256, and its doc says a runtime overlay can be added there). The runtime binding is recorded inlaunch.jsonandruntime_metabut not chain-signed. - Several launch assemblers, not one. The CLI (
exec.rs::resolve_launch), the library path (hostd/run.rs::attach_guest_runtime), persistent start (persistent.rs), session boot (entrypoint/boot.rs) and the version-pinned fork (checkpoint.rs:1013) each call the attaches.LaunchRequestis not the CLI's type (the CLI uses none of it). - Retained generations are kept on purpose.
bindkeeps a full generation (archive copy, overlay, verity, initramfs) with no automatic deletion, because backends cannot prove stop. A new snapshot must be that generation, never a second copy. - No C ABI exposure of the functions this changes; the ABI exposes data types only (
RuntimeReleaseProof,RuntimeLaunchBinding,runtime_overlay_version).mvmdandmvm-studio(two weeks stale) reference none of them.xtask check-test-home-isolationlistsattach_runtime_overlayandattach_universal_initramfsas prefix anchors and must be updated with any rename.
3. Design
3.1 Principle
Verify the whole runtime set once per launch, per process, as one verification; every consumer in that process uses that one result. Nothing is verified independently by each consumer, and nothing is reused across processes or launches in this change.
3.2 One verification and one typed result
One function verifies together: the release proof (archive bytes, checksum entry, archive and checksum signatures, accepted identity and issuer for the version, version and architecture); the declaration and protocol compatibility; and the selected artifacts against the declaration (overlay and verity digests and root hash, initramfs digest). It returns VerifiedRuntimeSet, which:
- has a private constructor, implements no
Serialize,DeserializeorDefault, and cannot be rebuilt from parts; - carries the verified archive digest, declaration, signer identity, and the verified archive snapshot (the existing
VerifiedRuntimeManifest), and when the launch is bound is the retained generation, not a copy of it; - is held as an explicit
Arcand passed besideVmStartConfig(precedent:PreparedBuiltPackRuntimeis returned as_built_runtimeinResolvedLaunch); it is never insideVmStartConfig(that type is cloned and constructed in about 195 files), never thread-local, never process-global.
The existing VerifiedLaunchRuntime enum (release, source, legacy) is extended, not duplicated: the release variant becomes the set.
3.3 Who mints it and who consumes it
- Minted once at the front of each assembler (
exec.rs::resolve_launch,hostd/run.rs,persistent.rs,entrypoint/boot.rs,checkpoint.rs:1013) through the one verifier. - Consumed by: overlay attach and initramfs attach (laps 1 to 3 disappear), admission (laps 4 to 6 become uses of the set), and
bind, which uses the set's archive snapshot instead of verifying again.bindkeeps its artifact snapshot and hashing against the declaration; that is the custody and does not repeat the signature work. - Unchanged: the digest pin between admission and
bind; the built registry pack's dispatch-time recheck (registry_pack.rs:38) stays as a stated requirement and still emits its audit failure entry; wasm and non-kernel backends still return early with no verification.
3.4 Assurance binding (decision needed)
Laps 5 and 6 (and an uncached sha256_file of every selected file) run for every release launch for the sake of a future assurance campaign. Threading the set alone still leaves that eager hashing. Decide: make the assurance binding lazy (computed only when a campaign is requested), or keep it and have it share the set. Recommendation: lazy, because an ordinary launch should not pay for it; the "cannot later be promoted into a campaign" property is then enforced when a campaign is requested.
3.5 Retained verification (continuity, restore, fork, warm claim)
These verify a different runtime: the one a checkpoint or standby parent was made with, possibly another CLI version. They cannot take the launch's set. They go through the same verifier via a second entry, verify_retained(binding), once per operation. Open and to be specified before code: how a warm claim (which has no bind; today verify_checkpoint_runtime plus verify_runtime_for_claim, an INFERENCE of 9 or more verifications) verifies the parent's retained generation once, and where the proof is stored.
3.6 Audit evidence (mandatory)
Signed, chain-linked audit records are a core property. Add a serializable RuntimeIdentity (archive digest, version, architecture, declaration digests, signer identity and issuer) to the signed ExecutionPlan (home: EnvironmentRef, #[serde(default, skip_serializing_if = "Option::is_none")], so old fixtures stay byte-identical; no schema-version ceremony per repo policy, no backcompat; update the 46 plan literals) and emit it as labels on plan.admitted, durable before the command is released. Admission checks that the plan's RuntimeIdentity equals the set's (a comparison, not a repeat of the signature work). Tests: tampering with the evidence breaks verify_audit_chain; every launch that used a release runtime has an entry naming the exact set verified. Nothing makes an audit write asynchronous. Update the claim-20 row (and claim 3 where the root hash is named) and its witnesses; check-claim-catalog and check-witness-citations apply.
3.7 Cross-host (#5124)
RuntimeIdentity is plain data that can sit in a launch request, plan or audit record and be compared by a coordinator. VerifiedRuntimeSet is never serialized or sent: each host verifies for itself and checks the result against the identity it was sent. A coordinator cannot hand a host "verified".
3.8 Boundaries and rules
- Measured boundary. The verification stays inside the measured launch window (invocation to guest ready, admission included). It must never be hoisted to bootstrap or any step outside the window to meet a budget.
- Errors are a contract. One typed
RuntimeVerificationErrorwith a variant per failing component (archive digest, checksum, archive signature, checksum signature, release identity, version or architecture, declaration, protocol, selected-artifact mismatch). Existing stable codes and messages are kept; a golden test pins each. - No compatibility shims. No embedder is in flight; public signatures change freely and old functions are deleted after migration.
3.9 Threat model
In scope: a tampered release artifact; a mismatch between what is checked and what is used within one launch; corrupt, interrupted or concurrently refreshed cache writes. Out of scope, as in ADR-001 and runtime_evidence.rs: a malicious or same-user host account. The guest's dm-verity still checks the overlay root hash at boot.
4. Not in this change
- No cross-process or persisted verification record (section 7). No change to accepted identities, versions or architectures, the signature or checksum code, the source-build runtime semantics, the legacy runtimes (
legacy_portable_runtime.rs,legacy_bundle_runtime.rs), builder VM and Stage 0 (they do not use this machinery), or any budget. - The single launch entry point with an enum source (fresh, bundle, restore, fork, warm claim) is a separate follow-up.
LaunchRequestis not the CLI's type and there are at least five assemblers, so unifying them is its own refactor and must not block the launch-time win.
5. Tests (each fails before the change, passes after)
- Count: one verification per process per launch on the CLI path, using a test-only counter (so it does not depend on tracing) and the perf(trace): span the runtime-proof verification, the lifecycle bind and its flushes #5506/perf(hvf): record where driver_boot and attach_overlay spend their time (#4839) #5508 span count as a second witness; the library and persistent paths measured separately.
- Refusals unchanged: tampered archive; wrong version or architecture; wrong identity; checksum mismatch; missing signature; declaration or protocol incompatibility; selected artifact differing from the declaration; each with its golden error.
- Check equals use (non-malicious race): a cache file refreshed after verification does not change what this launch boots (it boots the retained generation); the next launch verifies again. This test does not claim to stop a malicious same-user process.
- No leakage: a set from one launch cannot be used by another; concurrent launches in one process each get their own; a consumer cannot construct one (visibility test); no consumer accepts a runtime path where a set is required.
- Retained verification: restore, fork and warm claim verify the retained runtime once and refuse drift (existing tests stay green).
- Audit: section 3.6 tests; the registry-pack dispatch audit failure still fires.
- wasm and non-kernel backends unchanged.
6. Acceptance
- Release-proof verification count is 1 per process on the CLI path on the idle Firecracker VM and the macOS HVF path, measured with the perf(hvf): record where driver_boot and attach_overlay spend their time (#4839) #5508 spans; counts for the library, persistent and warm-claim paths recorded.
- Launch time drops by about 4 s on a signed release (about 5.6 s to about 1.5 s on the GCP VM), before and after on the same host and command. This is an estimate until measured.
- Claim-20 (and claim-3) rows and witnesses updated; fmt, clippy
-D warnings, full nextest of every touched crate,just check::gated,check-rust-footprint,check-file-size,check-test-home-isolationpass. No budget or verification is loosened.
7. After this change: the 640 ms and a cache
One verification at about 640 ms still misses the 300 ms cold budget. Next: measure what the 640 ms consists of (read and hash, signature verification, temp-file copy, parse; the inner split is being built on #5506) and fix the cheap parts. Only then decide on a cross-process record. Because verification is offline and deterministic, a record keyed on the archive digest, the trust-root version and the accepted-identity set would be as safe as the existing sealed digest sidecar, but it is a cached authorization under AGENTS.md and needs its own decision and a claim-20 note; its key must include the trust-root version, and any revocation epoch introduced by #5124.
8. Plan
- Measure per-process attribution and the other paths: add a process id to the spans, record counts for the library path (
LocalBackend), persistent start and warm claim, and check whethersha256_file_verifiedhits on the first launch after install. - Design review of this issue by the claim-20 owner (decisions: 3.4 lazy assurance, 3.5 warm-claim shape, 3.6 plan field).
- Implement the verifier and
VerifiedRuntimeSet, then migrate the assemblers and consumers one per PR where it stays reviewable, deleting the old functions. - Audit evidence and the claim note in the same series.
- Measure and post before and after here, on HVF on a developer Mac: a launch spends 2 to 4 s in admission, overlay attach, initramfs attach and VMM creation before the guest starts (warm and cold) #5487 and HVF warm claims take ~3.2 s on the macOS CI runner, so every warm launch is refused #4391.
9. Open questions
- The HVF resident-handoff path (
cold_hvf_channel) was not traced. - How a standby parent stores the proof for later claims (3.5).
- Whether lazy assurance binding is acceptable to the assurance owner.
- Per-process attribution of the laps (all appear to be the
mvmctlprocess; not yet tagged).
10. Coordination
- Spans: perf(trace): span the runtime-proof verification, the lifecycle bind and its flushes #5506 (
perf/runtime-proof-spans) and perf(hvf): record where driver_boot and attach_overlay spend their time (#4839) #5508 (4839-hvf-launch-spans) overlap inruntime_overlay.rsandruntime_evidence.rs; the second to land rebases. Land both before implementing so the count test has its witness. - Earlier local, unpushed branches (
perf/runtime-snapshot-single-flush,fix/bootstrap-warms-source-declaration) touch snapshot flushes and the source declaration; reconcile before pushing. - Do not touch
crates/mvm-cli/src/bench/*or the M1 diagnostic workflow (fix(bench): retain refused launch samples for diagnosis #5494).
11. For whoever picks this up
Read AGENTS.md, CLAUDE.md and .agents/skills/secure-execution-review/SKILL.md first. Work in a new git worktree from origin/main. Open pull requests with Refs or See and never a closing keyword. Do not queue or merge a pull request without the maintainer's explicit go-ahead. Do not loosen a check or a budget to pass a gate.
Refs #4839 (the cleanup umbrella; this issue does not close it). See #4391, #5487, #5124.
Activity
auser commentedon Nov 15, 2026
Answer to step 1 (which verifications run where), from the idle GCP VM runs; the mapping is derived from span nesting and phase arithmetic, not traced per process.
Same process or not. All seven
verify_release_archivecalls appear in one span table, the one written by the launchingmvmctlprocess (MVM_SPAN_TIMINGS_OUT), and thephase timingtotals add up inside that process (arithmetic below). A system-call trace (strace -f) of a one-command launch showed only two child processes, both started at the very end of backend start (the VMM and the per-VM endpoint), and no outbound connection. So on a one-commandmvmctl runof a signed release, all seven run in themvmctlprocess: there is no separate admission daemon in that path. What I did not do is tag each lap with its PID, so "same process" is established by absence from any other process's report, not by a PID on each lap. For a launch through the library (mvm-client,mvm-hostlib) or a persistent host daemon the answer may differ and I have not measured it.Which caller each one is (each is about 640 ms; five cold launches agreed to within 1%):
admit_plan_for_run, overlay attachattach_overlay.release_proof_lookup(659 ms), viaverify_selected_runtime(1 call, 640 ms)admit_plan_for_run, overlay attachattach_overlay.release_proof_verify(648 ms),verify_runtime_release_proofacquire_runtime_overlay_for_launch= 1.30 s = #1 + #2admit_plan_for_run, initramfs attachattach_initramfs.release_proof_verify(638 ms)attach_universal_initramfs_if_cached= 648 msadmit_plan_for_runverify_assurance_guest_protocol(2 calls, 1.28 s), each reachingverify_runtime_for_launch_atadmit_plan_for_runverify_runtime_for_launch_at(the 4 calls total 2.56 s)runtime_lifecycle.bind(966 ms) = oneverify_runtime_for_launch_at+ about 320 ms of snapshot copies and syncs (snapshot_filex4,sync_snapshot)The arithmetic that places them: the
admitphase is about 4.2 s but theadmit_plan_for_runspan is 2.25 s, and 2.25 s = overlay 1.30 s + initramfs 0.65 s + about 0.32 s (grants_budget_and_host_interface). The remaining 1.95 s of the admit phase is three verifications (3 x 640 = 1.92 s), which are #4 to #6. The backend-start phase is about 1.3 s =driver_bootabout 0.3 s +runtime_lifecycle.bind0.97 s, which is #7. Counts:verify_release_archive7 =verify_runtime_release_proof6 (overlay 1, initramfs 1,verify_runtime_for_launch_at4) +verify_selected_runtime1. So: 3 insideadmit_plan_for_run, 3 elsewhere in the admit phase, 1 in backend start.Where I am unsure: the split of the four
verify_runtime_for_launch_atcalls between admission and dispatch (I place three in admit and one in the bind; the arithmetic supports it but I did not name each call site), and whether #4 and #5 are two distinct assurance checks or one check called twice. The spans from #5506 nameverify_assurance_guest_protocolandruntime_lifecycle.bindbut not their callers; adding the caller as a span field, and the PID as a field on every lap, would settle both in one run.Inner split of one verification (from #5506's spans):
verify_guest_bins_archiveown time 422 ms (66%),read_and_digest_archive107 ms, the two signature checks 105 ms,write_archive_snapshot8 ms. Full tables are in #5487 and in ADR-112 (PR #5514).auser commentedon Nov 15, 2026
Not started by me; findings from reading the code that should save the implementer time. I looked at the call graph before stopping (Ari redirected me to the demo), and made no code changes.
evidence::verify_release_archive(crates/mvm-build/src/guest_runtime/evidence.rs);verify_runtime_release_proofandcached_runtime_release_proof(guest_runtime.rs) call it.mvm_runtime::runtime_evidence::verify_runtime_for_launch(config, minimum_protocol)(crates/mvm-runtime/src/runtime_evidence.rs): it verifies whateverconfig.runtime_release_proofclaims, and it is called fromcrates/mvm-client/src/launch/{runtime_source,bundle_runtime}.rs,crates/mvm-hostd/src/{run.rs,operator_admitted_trial_booter.rs,plan_admission/assurance_runtime.rs}andcrates/mvm-cli/src/commands/vm/checkpoint/fork_vm_full.rs. The overlay attach (launch/runtime_overlay.rs) and the initramfs attach (mvm-runtime/src/universal_initramfs.rs) verify directly.VmStartConfig, which lives inmvm-core.VerifiedRuntimeManifestlives inmvm-build, which is higher in the graph, so a field onVmStartConfigcannot name it directly (it would need an opaque handle, or the type has to move down).VmStartConfigis cloned widely (config.clone()and..config.clone()in the launch and hostd paths, and it is built in about 195 files), andfork_vm_full.rsverifies an inherited config for a child launch. A result stored in the config and shared by clones could leak into a second launch from the same template, which is exactly what this design forbids. Any cell on the config needs a launch identity, or the launch builder has to create a fresh one at every launch entry point, including forks.VerifiedRuntimeSetpassed from the launch builder) avoids that hazard at the cost of about ten signatures; I would take it.auser commentedon Nov 15, 2026
Design v2 posted (edited into the issue body). What changed from the first draft, from a read-only archaeology of every call site: all seven verifications run in the one mvmctl process (mvm-hostd is a library, not a daemon), so one shared result is feasible; two of the seven are an eager assurance-campaign pre-computation, not launch needs; no call site was added to close a TOCTOU window (the lifecycle bind is the custody point and stays); the threat model excludes a same-user attacker, so the draft's wording and one test were wrong; the claim is 20 (and 3), not row 9; the audit chain does not record the runtime today, so RuntimeIdentity goes into the signed plan; warm claim, restore and fork verify a different runtime and need a second entry; and a snapshot must be the existing retained generation, not a copy.
auser commentedon Nov 15, 2026
The single launch entry point (the follow-up named in the section on the entry point) now has its own design issue: #5520. It is sequenced after this verification series, since both change the same launch assemblers.
auser commentedon Nov 15, 2026
Implementation coordination: an isolated
feat/5515-runtime-setworktree has been prepared fromorigin/mainat4c48ce2a9f3c15970ca93910d255e3e927a66b97. The intended design for owner review is #5515 v2 with these clarifications: (1) a launch-scoped, privately constructed whole-set verification travels explicitly to attach/admission/bind; verified archive bytes are the authority for that launch, bind retains and rehashes the selected generation, and the admission-to-bind digest pin and built-pack dispatch recheck stay; a subsequent launch re-verifies changed cache bytes; (2) restore, fork and warm claim separately verify their own retained generation, with the standby parent's proof owned by its lifecycle binding, never substituted with a fresh child launch's result; (3) ordinary launch checks required protocol compatibility, while assurance-campaign binding is computed only on campaign request; (4)RuntimeIdentityis signed in the plan, compared at admission, and included in durable chain-signed admission evidence before workload authority. ADR-112's Proposed conditions 3 and tests 2–3 that demand re-verification of changed mutable paths within the same launch conflict with snapshot-authoritative #5515 v2 and need explicit reconciliation in the implementation/ADR amendment. This comment records the proposed choices and remaining review, not claim-owner or assurance approval. No security claim is promoted or acceptance measurement asserted here; no VM/HVF benchmarks are authorized.auser commentedon Nov 15, 2026
Design decision update from the maintainer: use an optional, skip-serialized top-level
ExecutionPlan.runtime_identity, not a field ofEnvironmentRef. A checkpoint fork resumes an existing VM with no new kernel path, so its plan must be able to name the verified retained runtime without inventing a kernel pin. The implementation direction remains one launch-scoped whole-set verification passed explicitly to attachment, admission and lifecycle custody; the digest pin and selected-artifact hashing at bind remain; warm claim, restore and fork authenticate their retained generation; campaign-only assurance binding is lazy;plan.admittednames the signed runtime identity and must be durable before workload authority. ADR-112's same-launch mutable-path reverify conditions are reconciled in favor of the immutable verified snapshot, with a later launch verifying its own selection. This records the chosen design, not a shipped claim or a live performance witness. No VM/HVF benchmark has been run; the work is still being validated and is not ready to merge.auser commentedon Nov 15, 2026
Implementation is ready for review in #5557. The branch is rebased on current main; serial workspace tests and touched-crate nextest passed (14,304 passed, 49 skipped), as did workspace check, Clippy, gated build, format and conformance/witness checks. The published signed v0.28.0-rc.2 verifier fixture passed before final rebase. Live Firecracker/HVF launches, span-count and latency measurements have not been run, so the hardware budget remains unverified. Keeping this issue open pending review and those measurements.
auser commentedon Nov 15, 2026
CI (main) went red on the #5557 merge commit (7eb0157): the
Test eBPF telemetry load/attachlane fails one test,plan_admission::assurance_runtime::tests::campaign_binding_checks_selected_bytes_and_vm_before_promotion(crates/mvm-hostd/src/plan_admission/assurance_runtime.rs:222), withverifying assurance guest runtime: bundle verification failed: trust store has no entry for key_id f993bf26…. The same test passes in the other lanes (Test workspace doctests and feature suites, Test workspace aarch64, Test Linux and conformance), so it looks environment-dependent: that lane's hostd test run has a trust store without the fixture key. Run: https://github.com/tinylabscom/mvm/actions/runs/43719832408. Not investigated further from here; theTest (main)aggregate is red because of this one lane, which blocks a clean release candidate.auser commentedon Nov 15, 2026
Live #5515 follow-up on
m1-runner(macOS 27.0.1, Apple Silicon/HVF), 2026-11-15:v0.28.0-rc.5tag points to7fe252a5, before feat(runtime): retain verified release runtime evidence per launch #5557 merged at7eb01574. I compared its published optimized CLI with an optimized--features release-channelbuild of exact merge commit7eb015747545051fb5e26ae2c6d5fa4c86e4de00, ad-hoc signed for macOS execution. The latter used a supervisor built from the same commit and the genuine published signed rc.5 guest-runtime quartet. These are different distribution artifacts, not a claim that the published rc.5 executable includes Verify the signed release runtime once per launch, as one verification of the whole runtime set (design for approval) #5515.MVM_HOME, the samealpine:3.21OCI workload,MVM_RESIDENCY=cold,--hypervisor hvf,--no-detect,/bin/true, a prepared cache, andMVM_SPAN_TIMINGS=json. Two warm-ups preceded 20 successful cold launches per arm. Every measured launch hadimage_pull=false,image_build=false, andmount_materialize=false.verify_release_archivewas 7 calls on every one of 20 launches; total p50 2,291.5 ms, p95 2,401.4 ms. Admission p50 1,537.0 ms; backend-start p50 584.8 ms.verify_release_archivewas 1 call on every one of 20 launches; total p50 722.6 ms, p95 835.8 ms. Admission p50 232.0 ms; backend-start p50 334.2 ms. Median improvement on this runner is 1,568.9 ms (~68%). This does not meet the 300 ms cold-launch gate; this change alone was not expected to do so.mvmctl bootstrap, did boot successfully using the merged release-channel build in a packaged layout. It automatically prepared/acquired artifacts (image_pull=true) but took 7.14 s wall time. Its in-launchtotal_ms=770.3excludes most first-use preparation;startup_ms=5,725.5includes more of it. Do not present the prepared-cache numbers as first-use single-command latency.plan.admittedentries carried archive, version, arch, verified signer identity/issuer, and declared/selected overlay, verity, root-hash, and initramfs labels. This is an observation of the emitted fields, not a separate cryptographic audit-chain verification.mvmctl bench --lane prepared-coldrefused the warm-up: it forbidsartifact_hash, whereas the merged security path hashes 1,341,266 selected-artifact bytes per prepared launch. I did not loosen the gate; the statistics above are computed from 20 direct schema-v4 launch samples and 20 span reports, not an accepted official benchmark report. This lane mismatch needs a separately reviewed measurement definition.actions-runneraccount has no running systemd user bus. No running VM was left by the successful transient M1 launches. Raw samples and span reports remain under/tmp/mvm5515/{tag-baseline,release-measure}onm1-runneruntil that machine clears/tmp.#5515 should remain open for the unmet cold latency target, first-use speed, and any required Linux confirmation; the one-per-launch verification count is now evidenced on a real HVF launch.