Repository navigation
T60 — Address boxes across two VMs by name without a global flag - #1807
norrietaylor merged 24 commits into
Conversation
The default VM plus every named VM with a state dir, default first and the rest alphabetical; a directory whose name breaks the naming rule is skipped (the provider dir holds non-VM trappings) rather than failing a listing, and the native minimald backend enumerates nothing. This is the set a multi-VM listing lists across (NET-057) and a box-name resolution probes (NET-058).
min ls on a multi-VM host is one listing of all of them: each running VM contributes its boxes and every row carries the VM it came from (NET-057), one VM keeps the single-VM output byte for byte. A named attach target resolves to the VM that owns it from the name alone (NET-058): the selected VM's daemon first, then a probe across every VM's socket — the shared resolution in attach.rs that min net expose reuses once it lands — refusing an ambiguous name rather than guessing, and never overriding an explicit --vm.
The dashboard's provider discovery now walks the VM side per VM: the default VM keeps the vm group label a saved dashboard state records, and every named VM joins under its own name and its own socket, so a two-VM host's sidebar shows both VMs' boxes. A provider's label is a String now — a named VM's is its name, not a fixed vocabulary.
Two VMs on one host used to contend for one host loopback port by construction: the publication of a VM's hostname proxy asked the gvproxy forwarder for the same number the listener bound in-guest, and when the host held it the daemon moved the *bind* — sacrificing the documented port every box-side recipe shares with its VM's daemon — just to fix a host-facing contention (NET-059). The publication now carries its own host port. It proposes the bound port first, so a lone VM still publishes on the documented default, and when the host refuses that one as taken it walks one rung further up (HOST_PUBLISH_PORT_STRIDE) while the listener keeps the port it bound. A pinned port never walks — the operator named it, and the retry with the report stays the remedy — and a transient failure still keeps its port, so a daemon that boots before its host gvproxy does not drift. The RPC discovery field carries the port a client can reach: the published one on a VM whose publication walked, the bound one everywhere else. Each accepted publication is named in the log with both ports — the bundle's answer to which VM owns which host port when two run. two_vms_hostnames_route_concurrently drives two VM-shaped daemons through the walk (the ledger stand-in holding every host port it accepts) and proves both VMs' box names route through their published host ports at the same time, each refusing the other's names, with both listeners still answering the documented default.
…0s ran out the coder's uncommitted work as it stood when its 7200s ran out The coder was stopped at the end of its time with these changes not committed. The runtime committed its working tree as it stood so the work is kept: this commit is a snapshot, not a finished step, and may not build or pass its tests.
…xes-across-two-vms-by-name-without-a-g
|
Important Review skippedBot user detected. To trigger a single review, invoke the ⚙️ Run configurationConfiguration used: Organization UI Review profile: CHILL Plan: Advanced Run ID: You can disable this status message by setting the Use the checkbox below for a quick retry:
Comment |
norrietaylor
left a comment
There was a problem hiding this comment.
Review of round 0 (head 8c2c3655) against T60's plan block (#1670). All eight layer files and four test lines are present; the two ls verbs and the resolver are driven on two real daemons. The items below are what a revise round needs before the draft lifts; I will post the /revise once round 1 (the inventory tests) lands.
- HIGH
crates/minimal/src/cmd/list.rs:325— theexists()pre-check runs beforeClient::connect's retry, andClient::connect's own doc (crates/minimal-client/src/lib.rs:221) says the macOS bridge UDS appears aftervm-up; with a second VM up, the selected VM is skipped,listingsis non-empty so the fallback at list.rs:340 never fires, andmin lssilently renders the other VM as a single-VM listing. Connect the selected VM unconditionally (it was just ensured); only pre-check the others. - MEDIUM
crates/minimald/src/server.rs:1772-1810— the new answerer comment ("keeps the bound port's number on the host side … one answerer serves the host's zone") contradicts the arm beneath it, which still aborts the serve and rebinds on port 0 when the host refuses the publish ("the same release-and-rebind the routing proxies take" — they no longer do). On a two-VM host VM B's answerer moves its in-guest bind to a random UDP port and VM B's names never reach the host resolver; NET-059's "host's hostname surface" is proven for the HTTP proxy only. Make the comment true and state in the PR whether the DNS half is T60's or deferred. - MEDIUM
crates/minimal/src/cmd/list.rs:616-645— with two or more VMs--jsonbecomes an array of per-VM objects instead of the documented single object, sojq '.sessions[]'pipelines break the day a second VM appears; the plan asks for a VM column, i.e. per-row attribution. Prefer a"vm"field on each entry in one flatsessionsarray, or document the array deliberately. - MEDIUM
crates/minimal/src/cmd/list.rs:325,338andcrates/minimal/src/attach.rs:281— a stopped VM'sssh.sockis never unlinked (minvmd only removes it at the next start,crates/minvmd/src/vm.rs:309), soexists()is true andClient::connectburns 20×100 ms before erroring: everymin lsand every cross-VM attach fallback pays +2 s per stopped VM and printswarning: skipping VM …: Connection refusedfor a normal state. Treat ECONNREFUSED on a non-selected VM as "not running" (no retry, no warning), and put a shorttokio::time::timeoutaround the non-selected probes — today a wedged VM holdslsfor up to ~72 s (crates/minimal-client/src/lib.rs:170,181,189). - LOW
crates/minimal/src/tests.rs:64-99— the two inventory tests only need three additive lines:"tests.rs::create_box_on = asserts nothing"(in-process same-build fixture; say so in a comment),"attach.rs::box_record_on = gated", and"cmd/list.rs::list_vm = gated"(comment: gate applied to the selected VM only; the rest are read-only and ungated like the dashboard). The call sites are correctly gated per the scanner's rule; do not change them. - LOW
crates/minimal/src/cmd/session.rs:1089-1110— the attach fall-through (selected daemon errors →resolve_box_vm→session_via_sshon the other VM's socket) is the one new path no test drives;box_name_resolves_vm_without_flagcovers the resolver only. Also squash 687bda9 (fmt/#[expect]fallout only) into 77842f0 if this is not squash-merged.
The named-VM work opened two daemon connections and one CreateSession site, so `every_daemon_connection_is_classified` and `every_create_session_asserts_the_daemon_build` failed on the branch: the inventories are asserted rather than documented, so each new site has to be judged and listed here. `box_record_on` gates the owning VM's daemon on the reply that named the box, and `list_vm` keeps the gate for the selected VM while the other VMs stay listable ungated. The two-VM fixture's create now asserts the build the way every other site does, so no site passes `None` quietly.
|
Round 1 of 10 on a failed check suite, pushed as
Verify Converted to a draft: something above needs a person before review. With two VMs running, Notes from the agent: Revise round on PR #1807; the directive carried only the two failed checks ( |
|
/revise
|
Client::connect retries its socket for ~2 s to absorb the bridge UDS appearing late, which is the right patience for the VM an operator picked and the process just ensured — and the wrong patience for every VM it merely walks past on a host that may hold several. probe makes one connect attempt and classifies the refusal: a stale ssh.sock (ConnectionRefused) or a vanished path (NotFound) is NotRunning, an answer the caller can act on, and anything else is Unreachable, worth a warning. The handshake moves into its own helper so connect, connect_scoped and probe share it. PROBE_TIMEOUT names the leash callers are expected to run a probe under: 4 s, the same window the TUI allows a mid-run reconnect, against the ~72 s the stacked retry, handshake and RPC deadlines would otherwise charge per wedged VM.
A listing or a box-name resolution spans every VM the CLI can see, and until now each VM it passed was charged the full patience of the one the operator picked: a 2 s connect retry for every stopped VM's stale ssh.sock and, for a wedged one, the stacked handshake and RPC deadlines that held the caller for about 72 s per VM. - The listing and the resolution probe those VMs instead (the new Client::probe, one attempt), read "not running" as the answer it is — no retry, no warning — and bound each probe with the short PROBE_TIMEOUT leash. fill_git_info stays outside the leash: it walks git on the host, not the daemon. The selected VM keeps the gated connect it always had. - The selected VM is exempt from the not-running skip: it is up, but on the VM backend its bridge UDS can appear a beat after the vm-up line, which is exactly the race connect's retry window absorbs — skipping it dropped the operator's own boxes and printed another VM's as the whole picture. - min ls --json stays one object on a multi-VM host: the sessions array every consumer parses, each entry carrying its VM, with each VM's own facts under vms. The per-VM array it briefly printed broke that parse for no gain. - cmd_attach's fall-through (selected daemon misses, resolve_box_vm finds the owner) moves into resolve_attach_target_version_gated so the record and socket handed to the SSH attach are testable without a live session shell. The version-gate inventory now scans both verbs the client opens, so a probe path cannot carry its gate decision — or skip it — unrecorded.
drive_answerer_until_serving still released its socket and rebound on port 0 when the host refused its publication, and its comments claimed that matched the routing proxies — which stopped doing that when their publication learned to walk host ports of its own (NET-059). The comments were the bug's last holdout. The answerer now takes the proxies' walk: the socket keeps the documented port it bound, serving its zone from the moment of the bind, and a host port the host refuses is proposed one rung further up until one is accepted; a pinned port has no rung and keeps retrying, and a transient failure never moves. The state's discovery field reports the port the host's resolver can actually reach — the published one, or the bound one when nothing was published — and the log names the relocation and the publication with both ports, beside the bind. two_vms_hostnames_route_concurrently drives both halves of the host's hostname surface now: alongside the routing proxies, each VM's answerer binds the documented default on its own guest loopback, the first publication holds that number on the host, the second walks to a rung, and A queries through each published port answer that VM's own box and say the other VM's is nobody's here — concurrently, each answerer never having left the port it bound.
Both leashes discard the elapsed marker their timeouts produce; it carries nothing the messages lack, so expect clippy::map_err_ignore at the two sites, as session.rs already does for the same shape. The answerer tests' refused_ports helper slices the log tail out by byte index; split_once does it without the panic the string_slice lint guards against.
…xes-across-two-vms-by-name-without-a-g
|
Round 2 of 10 on a /revise note, pushed as The coder ran out of its 7200s before it finished. If it left work uncommitted, its last commit is the runtime's snapshot of that work as it stood — the commit message says so — and not a finished step: it may not build or pass its tests.
Verify Converted to a draft: something above needs a person before review. With two VMs running, ls shows the VM per box, attach finds the VM from the box name alone, and both VMs' box names route through the host at the same time; the expose verb's resolution of the VM is T53's. |
|
/revise
|
Reconcile NET-059's comments with T63's handed ports: a VM boot now reads its node ports off the boot line and binds them as pinned, so each VM's distinct host ports come from minvmd's handed assignment and the publication walk never runs on the VM path. The reselects_when_publish_ refused and drive_answerer_until_serving docs and the walking test's doc now say so, and name the boots the walk still covers: no handed port — an older minvmd, a native run, a host that handed 0. Beside the walking test, drive two daemons the way T63 boots them: distinct pinned proxy and answerer ports per VM. Both publish at exactly the numbers they were handed, neither logs a relocated line, and each routes its own box — proxy request and zone query — through the host concurrently while refusing the other VM's.
The stopped-VM half of the ls leash, under the bound that proves the ask: with no wedged VM in the picture, a stopped VM's stale ssh.sock is ECONNREFUSED on one probe attempt — not running, no 2 s connect retry, no warning — so cmd::ls_listings returns only the running VM in under 1 s. The wedged test's 8 s bound cannot tell a 2 s retry from none; this mirrors the resolution path's own one-second proof, a_stopped_vm_does_not_hold_a_box_name_resolution.
|
Round 3 of 10 on a /revise note, pushed as
Verify On a two-VM host — including two VMs booted the way T63 boots them, each handed its own pinned node ports — the NET-059 comments now match the code (a handed, pinned publication never walks; the walk covers only boots with no handed port), a new test proves both VMs publish at exactly their handed numbers with no relocated line and route their own boxes through the host concurrently while refusing each other's, and Notes from the agent: Directive item 4 (minvmd, untouched): yes, |
|
/revise
Keep every other file as it is. Do not rewrite the PR body; it is maintained by hand. |
|
Reviewed: 1 finding, none blocking at Address the comments on the diff. Clobber: none: |
The listener is no longer the socket TcpListener::bind builds: it is built with TcpSocket, with SO_REUSEADDR explicitly off and mio's backlog kept, so neither reuse option is ever set. tokio sets SO_REUSEADDR on every Unix TCP listener by default, and a reuse option is the licence to share or shadow a port another holder has — one VM's proxy answering for the other VM's names — where the rule this daemon ships is the opposite: two daemons on one host meet on one port number only through the walk the publication takes, and a duplicate handed port fails loudly at bind, as the surfaced error the caller's report carries, instead of binding beside its holder. The test reads both options off a bound socket with getsockopt, because a refused second bind cannot tell a set option from an unset one: the pin is the kernel's own answer for the socket's options, on both platforms this daemon runs on.
The create reply already carried the port this daemon's hostnames route through, and `min ls` already printed it; a session start now prints the same fact beside the routing-down warning it already prints — one line naming the VM on the VM backend, where on a two-VM host it says whose port is whose, and reading word for word as `min ls`'s single-daemon routing line on the native backend. That is the case the line exists for: a boot with no handed port whose proposed host port was held publishes on a host port of its own (NET-059) — a handed one is pinned and keeps proposing the port it was given — and a native daemon whose default was busy asks the OS for a free one (NET-025). Either way the port the recipes assume is not the one in use, so a walked port is never a log line alone: the address a PAC file or an HTTP(S)_PROXY export points at lands on both surfaces the operator reads. Absent while the proxy is still coming up, or from a daemon that predates the field, exactly as in `min ls`.
Two tests the architecture review's conditions asked for: - attach_refuses_a_box_name_two_vms_know: the same box name on two VMs, with the selected VM a third that does not know it, is refused by the fall-through with an error naming both VMs and pointing at `--vm` — never resolved to the first VM that answers, and no record or socket comes back for the ssh hand-off to run over. The refusal the shared resolution carries is the exposed verb's too, once that lands. - walked_proxy_port_reported_at_start_and_in_ls: the walked rung is the port on `min ls`'s routing line for the VM that walked, the session-start line names the same VM and the same port, and the native start line is the single-VM routing line word for word — while the port the recipes assume appears nowhere on the walked VM. The daemon-side half, the rung landing in the reported field these surfaces render, stays pinned by two_vms_hostnames_route_concurrently in minimald.
The connection inventory is what stops a new `Client::connect` from landing ungated, and it scans tests.rs too — the refusal test's connection to the selected daemon is a connection all the same. It drives `resolve_attach_target_version_gated`, the gated path, so the label records what the test asserts; the comment now says the same of both fall-through tests.
|
Round 4 of 10 on a /revise note, pushed as
Verify With two VMs running, Notes from the agent: The three directive conditions, and where each landed: (1) the ambiguous-attach refusal was already in |
|
/revise Round 4's C2 is met: the walked port is printed at session start and in
|
bind_listener binds through TcpListener::bind again: SO_REUSEADDR on Unix, never SO_REUSEPORT. On Linux, SO_REUSEADDR never lets a second socket listen on an address:port an active listener holds — a port another daemon holds is still refused with EADDRINUSE, as the surfaced failure the reports carry — so its one effect is the one the native daemon needs: a restart can rebind over the TIME_WAIT sockets the previous run's accepted connections left, keeping the documented 127.0.0.1:7654 instead of failing the rebind with EADDRINUSE and moving off it (native-daemon-e2e, run 37035644090). The rule that two VMs never shadow one host port is not this bind's to carry: a microVM daemon binds inside its guest's own netns, where the two never meet, and the host-side forwarded port they do share is minvmd's bind (#1814). bind_without_reuse and its hand-built socket are gone, with the doc comments rewritten to say the platform-default rule and where the no-shadow rule lives now. The pinned test keeps the EADDRINUSE refusal and the SO_REUSEPORT-off read off the bound socket, and drops the SO_REUSEADDR-off pin the restored default makes wrong.
The restored platform default is what makes a native daemon restart keep the documented port: the previous run's accepted connections leave their sockets in TIME_WAIT on it, and SO_REUSEADDR is the one licence Linux gives to rebind over those. The test builds that leftover (one accepted connection the listener's side closed first), proves the TIME_WAIT tuple is really held by refusing a no-reuse bind on it — the hand-built socket bind_without_reuse used to make, since both std's and tokio's TcpListener::bind set the option on Unix and cannot serve as the control — then asserts the daemon's bind retakes the same port with SO_REUSEADDR on, the shape the native e2e's restart needs (run 37035644090 failed exactly here behind the no-reuse bind).
…xes-across-two-vms-by-name-without-a-g
|
Round 5 of 10 on a /revise note, pushed as
Verify Review threads the coder judged:
minimald's hostname proxy binds through TcpListener::bind again — SO_REUSEADDR on Unix, SO_REUSEPORT never set — so a native daemon restarted in place rebinds 127.0.0.1:7654 over the TIME_WAIT sockets its previous run's accepted connections left and keeps its documented port, while a port another live listener holds is still refused with EADDRINUSE and surfaced in Notes from the agent: Round 5's one change, in crates/minimald/src/net/proxy.rs only (the daemon layer's file): removed bind_without_reuse and its LISTEN_BACKLOG hand-build, so bind_listener binds through TcpListener::bind again; rewrote the doc comments that justified the no-reuse bind (bind_listener's doc and the refusal test's doc) to state the platform-default rule — SO_REUSEADDR never lets a second socket listen beside an active holder on Linux, its one effect is the restart rebind over TIME_WAIT — and that the two-VM no-shadow rule is minvmd's host-side forwarded-port bind (#1814), not this daemon's. Kept proxy_bind_refuses_a_port_already_held_on_loopback with the directive's shape: held-listening-port refusal fails with EADDRINUSE and is surfaced, SO_REUSEPORT is read off the bound socket and pinned off, the SO_REUSEADDR-off assertion is dropped. Added proxy_bind_rebinds_over_the_time_wait_a_restart_leaves as the local pin of the exact CI failure (native-daemon-e2e run 37035644090): it drives one accepted connection into TIME_WAIT, proves the tuple is held by refusing a no-reuse bind on it — std's TcpListener::bind also sets SO_REUSEADDR on Unix, so the control must be a TcpSocket with the option explicitly off — then asserts bind_listener retakes the same port with SO_REUSEADDR on. The directive's required evidence, native-daemon-e2e green at the new head,…[truncated] |
|
/revise Round 6: round 5 is met (platform-default bind restored, restart rebind test, native-daemon-e2e green). Two small asks, scope unchanged:
|
…xes-across-two-vms-by-name-without-a-g Resolve the T15/NET-018 live-name-surface work against this branch's multi-VM listing and per-VM host publications: - min ls keeps the multi-VM listing (NET-057) and gains NET-018's name-surface verdict, one per VM from one shared host read, because on a two-VM host the resolver hook routes the zone to one VM's answerer (NET-059): the resolver's singular verdict became live_name_surfaces, which pays the list's one-second detection once for every VM's verdict, and format_ls_across_vms renders each VM's NAME SURFACE line beside its per-VM routing facts. One VM listed stays byte-for-byte the single-VM listing. - the answerer driver still records the port the host's resolver reaches — the walked publication's when the default was held — and NET-018's observability line now logs that reached port, so the log and the discovery field never name two ports for one answerer. All four plan test lines and T15's NET-018 tests pass on the merge.
A VM whose own name is one of the two reserved sidebar labels — both valid per paths::validate_vm_name — took the identity of the provider that label already belongs to: connect_missing skips any candidate whose label a connected provider carries, so a VM named host was never (re)connected once the host daemon was up and a VM named vm while the default VM was connected, and the dashboard — which keys refresh, attach, and the saved state by label alone — would conflate the two even without the skip. vm_label now escapes such a name into the VM side's namespace (vm:host, vm:vm), which no VM name can spell since validate_vm_name admits no colon, so no two providers ever share a label and every VM reaches the provider list under its own group. Pinned beside the probing test with a VM named host and one named vm, each keeping a candidate and a label no other candidate carries.
|
Round 6 of 10 on a /revise note, pushed as Resolved conflicts in:
Verify Outside the task's
Converted to a draft: something above needs a person before review. Review threads the coder judged:
With two VMs running, Notes from the agent: Round 6, both asks done in two commits (the merge commit, then the TUI fix). (1) Stale base: merged origin/main (T15/NET-018+NET-019, #1802) and resolved both conflicts keeping both sides' behaviour — cmd_ls keeps the branch's per-VM warnings and multi-VM listing and now computes main's verdict per VM via live_name_surfaces (the resolver's singular live_name_surface became the plural so the list's one-second detection is paid once for every VM's verdict, not once per VM; format_ls_across_vms renders a NAME SURFACE line per VM beside its per-VM routing facts, and one VM listed stays byte-for-byte the single-VM listing); minimald's answerer tail still records the port the host's resolver reaches (the walked publication's, NET-059) and main's log_live_name_surface now logs that same reached port. The merge itself carried main's own changes into files outside this task's layers — crates/minimal/src/cmd/session.rs, crates/minimal/src/resolver.rs, crates/minimal/tests/cli.rs, crates/minimald-rpc/src/lib.rs, crates/minimald/src/net/proxy.rs, crates/minimald/src/rpc.rs — all from main's commit or its signature fallout (resolver.rs's plural verdict and the src/tests.rs call-site updates are my resolution of that fallout, not new scope). (2) The LOW thread on vm_label: verified valid (both |
norrietaylor
left a comment
There was a problem hiding this comment.
Round 6 meets every ask: main merged with one name-surface verdict per VM, vm_label collision fixed with a test, platform-default bind kept (SO_REUSEPORT off), ARCH C1/C2 tests intact, all lanes green.
T60 — Address boxes across two VMs by name without a global flag
slice: S15
kind: task
covers: NET-057, NET-058, NET-059
size: L
est: 450 code, 240 tests
executor: agent
difficulty: needs care
model: strongest
diagnostics: the bundle's daemon log tail names each VM's proxy publication
observability: one debug log line per box-name resolution naming the VM it resolved to
layers:
- cli:
- crates/minimal/src/cmd/list.rs: ls lists every VM and adds a VM column, filled on the client side
- crates/minimal/src/cmd/session.rs: attach resolves the VM from the box name through the shared resolution attach.rs provides, which expose reuses once T53 lands
- crates/minimal/src/attach.rs: resolution across every VM's socket
- crates/minimal/src/tests.rs: hosts the listing and resolution tests
- crates/minimal-client/src/lib.rs: enumerates the VMs' sockets
test: cargo nextest run -p minimal ls_shows_vm_per_box
test: cargo nextest run -p minimal box_name_resolves_vm_without_flag
- tui:
- crates/minimal-tui/src/rpc.rs: the provider probes cover every named VM
test: cargo nextest run -p minimal-tui probes_every_named_vm
- daemon:
- crates/minimald/src/server.rs: each VM publishes the proxy on a host port of its own instead of all taking the same one
- crates/minimald/src/net/proxy.rs: hosts the concurrent-routing test
test: cargo nextest run -p minimald two_vms_hostnames_route_concurrently
produces: none
consumes: none
proof: With two VMs running, ls shows the VM per box, attach finds the VM from the box name alone, and both VMs' box names route through the host at the same time; the expose verb's resolution of the VM is T53's.
depends on:
- blocked by #1621
- blocked by #1626
Proof
With two VMs running,
min lsshows the VM per box, attach finds the VM from the box name alone, and both VMs' box names route through the host at the same time. The expose verb's resolution of the VM belongs to T53.NET-059 is met on native hosts and on Linux VM hosts. The macOS VM backend is pending #1814, because minvmd can hand two VMs the same proxy port there.
How NET-059 is met depends on how the daemon boots:
0). If the host refuses a daemon's default publication, the daemon publishes on a host port of its own (the next rung) and reports that port at session start and inmin ls. Its listener keeps the documented port. This applies to both the proxy and the box-zone answerer.SO_REUSEADDRon Unix, and neverSO_REUSEPORT. A port that a live listener holds is still refused withEADDRINUSE. A native daemon restarted in place rebinds the documented port overTIME_WAIT.Behaviour changes
min lslists every VM. With more than one VM it adds a VM column and prefixes each VM's routing lines with the VM name. That includes NET-018'sNAME SURFACEline, which is computed per VM from one shared host read, because the resolver hook routes the zone to one VM's answerer. With one VM the output is unchanged.min ls --jsonwith more than one VM returns one object:sessionsspans every VM, each entry carries"vm", and each VM's own facts sit undervms[]. With one VM the output is unchanged.Client::probe, 4 sPROBE_TIMEOUT). A stopped VM's stale socket reads as not running. The selected VM keeps the gated connect and its retry window.min session attach <box>falls through to the VM that owns the name and announces it. If two VMs know the name, attach refuses and lists both.hostorvmgets the labelvm:hostorvm:vm, so it never collides with the host daemon's or the default VM's group.Tests (round 6, head 73e7f98)
cargo nextest run -p minimal ls_shows_vm_per_boxcargo nextest run -p minimal box_name_resolves_vm_without_flagcargo nextest run -p minimal-tui probes_every_named_vmcargo nextest run -p minimald two_vms_hostnames_route_concurrentlyAlso covered:
attach_refuses_a_box_name_two_vms_know,walked_proxy_port_reported_at_start_and_in_ls,two_vms_pinned_ports_route_concurrently,proxy_bind_rebinds_over_the_time_wait_a_restart_leaves,vms_named_for_the_reserved_labels_keep_their_own_candidates,a_stopped_vm_does_not_hold_a_listing,ls_keeps_the_selected_vm_when_its_socket_appears_late,ls_leashes_the_vms_it_did_not_select,attach_fall_through_hands_off_the_owning_vm,a_stopped_vm_does_not_hold_a_box_name_resolution,a_walked_answerer_publication_keeps_the_bind_and_reports_the_rung.crates/minimal/src/resolver.rsis outside the plan's layers. It changes because of the merge with T15 (#1802): the single-daemonlive_name_surfacebecamelive_name_surfaces, one verdict per listed VM, with no change for a single VM.All lanes are green on 73e7f98, KVM and macOS included.
Closes #1670