Repository navigation
Conversation
Contributor
Security scan found no critical or high findings on lines changed by this pull requestView the security scan run for complete reports. “New” means the finding is located in a changed file on an added or modified line; it is not a base-versus-head findings delta. |
This was referenced Nov 11, 2026
rominf
force-pushed
the
ROCMAI-456-fix-dash-daemon-handoff
branch
3 times, most recently
from
November 17, 2026 11:24
33a55bb to
3a4e6e8
Compare
…ROCMAI-456) On Linux the telemetry daemon behind `rocm dash` ran inside whichever dashboard started first. Nothing took it over when that process exited, so every other dashboard still open stayed on "disconnected" until it was restarted. The daemon also unlinked any existing socket before binding, so a second daemon at the same path could orphan a live listener and every client attached to it. Each live dashboard now runs a keeper that serves the socket whenever no other daemon does. Ownership is an exclusive lock on a file next to the socket, held for the daemon's life and released by the OS however the process exits; a daemon that finds the path owned returns SocketInUse and the keeper retries, so a surviving dashboard takes over when the owner closes or is killed. Holding the lock, a daemon removes an existing socket only when a connection to it is refused, never removes a path that is not a socket, and on exit removes the socket only if it is still the one it bound. Covered by unit tests for each state of the socket path and for the keeper's takeover, and by scenario dash-55, which opens two dashboards, quits the first and requires the second to reconnect. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
…CMAI-456) The daemon now owns its runner and client tasks and stops them when it stops, closing its clients' connections. A runner that stops or panics ends the daemon with an error, so the keeper restarts it. A serving daemon checks every 2 s that the socket path is still its own: if the socket was removed or replaced it gives the path up (SocketReplaced); an unreadable path is tolerated, and five unreadable checks in a row give it up. The stale-socket probe waits for the greeting before hanging up, a listener that holds no lock is polled every 5 s instead of every 250 ms, and a bind that loses to something at the path reports it as not a socket when what is there now is not one, and as in use otherwise. The keeper counts only failures in a row and starts its backoff over once another daemon is found or the socket was taken from a serving daemon. It records the failure its daemon is stuck in, and rocm dash prints it after the dashboard closes, naming the client log only when the warning was actually logged. A dashboard starts its benchmark list over on each connection, from the rows the daemon replays, since a daemon that took over re-reads the whole benchmark CSV and would otherwise send rows the dashboard already lists; daemon and dashboard share BENCH_HISTORY_CAP, so the replay holds as many rows as the dashboard keeps. Adds scenario dash-56 for the failure report and updates the README, architecture, testing and manual-testing docs. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
The socket directory is now checked before the claim creates, opens or probes anything in it. Another user's non-sticky directory is refused. A sticky directory is never chmodded and is used when root or this user owns it. A non-sticky directory this user owns is restricted to 0700 before it is used when group or others can reach it (a later commit settles exactly which modes count). A directory the daemon had to create is checked again afterwards, and the lock file is opened with O_NOFOLLOW. A run that served starts the keeper's backoff and failure count over only once it has served for 30 s, so a runner that keeps stopping soon after it starts is still backed off. The report after the dashboard closes says "could not start" or "stopped serving" by whether the daemon had served, and is dropped when another daemon serves the socket by then. A keeper panic is always reported, with its message. Adds unit tests, including keeper timing on a paused clock, and scenarios dash-57 (benchmark rows listed once after a hand-off) and dash-58 (a daemon that stopped serving is reported as such), and updates the help text, README and docs. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
…-456) The dashboard's wait for its daemon to start now probes with socket_answers, which reads the daemon's greeting before hanging up, so the daemon no longer logs a client error for every dashboard opened. The stale-socket probe reads at most 4 KiB of greeting, so a listener that streams bytes without ending a line is still answered promptly rather than buffered until the probe's timeout. The helper that counts unreadable socket-path checks now takes the check's result and returns the error that gives the path up, so the serving loop has no unreachable branch. The PTY-spawned rocm in the e2e harness drops the caller's RUST_LOG, so steps that count the client log's info-level lines do not depend on the filter in the shell running the suite. User-facing text no longer says "keeper": a crash of the dashboard's own supervision of its telemetry daemon is reported as such in the failure report, help text, README and manual-testing guide. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
…I-456) A non-sticky socket directory this user owns is now restricted to 0700 whenever group or others have any access to it (mode & 0o077), as main did, rather than only when they may write in it, so an owned 0755 directory is tightened again. Sticky directories such as /tmp are still never chmodded, and another user's non-sticky directory is still refused. The tightening is logged once, at info, with the directory and its old mode; a directory already private is left alone and logs nothing. Test the keeper's wait while another daemon owns the socket on a paused clock: one takeover poll when the lock holder serves it, the slower poll when something without the lock answers there, and neither recorded as a failure. Update the architecture, testing and manual-testing docs to the new rule, including that a configured dashboard.tui.connect socket path has its directory restricted too. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
Pull the empty-parent filter for a bare socket name such as `unix:rocmdashd.sock` out into a pure function and test it: such a path has no directory to check, and the check would otherwise refuse the empty path, so the daemon would never serve. The test drives the helper only; serving a bare name would change the process-wide current directory under parallel tests. Say in the comments why that directory is left unchecked, and note the exception where the daemon's directory policy is documented. Add tests for more of the claim's branches: a probe that fails for a reason other than refused (the socket's mode forbids connecting), which is reported rather than replaced as stale; a bind that loses the path, reported by what the path names now (a socket, a file, or a path that vanished since); and a chmod that fails after binding, after which the claim still removes the socket it bound. List them in docs/testing.md. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
rominf
force-pushed
the
ROCMAI-456-fix-dash-daemon-handoff
branch
from
November 17, 2026 13:14
3a4e6e8 to
26b4c85
Compare
…c (ROCMAI-456) The tests that capture the dash daemon's and the keeper's log lines failed intermittently when run in parallel. tracing-core caches each callsite's interest the first time the callsite is hit, and while at most one dispatcher is registered it asks only the default subscriber of the thread that hit it. A parallel test with no subscriber could therefore cache a callsite as never enabled, and the capturing subscriber then missed the line. Each test's log_at helper now first registers two process-lifetime no-op dispatchers, so tracing-core asks every live dispatcher and caches the same interest on every thread. The stale-socket fixture now waits, within the test deadline, until a connection is refused instead of asserting it on the first try. A child process started by a parallel test can briefly inherit the listener's descriptor until it execs, so the socket can still accept just after the listener is dropped. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
…CMAI-456) The up-to-5 s wait for the dashboard's daemon socket to answer before the dashboard draws is now a separate function, so a test on tokio's paused clock can drive each of its three exits: the socket answers, the limit is reached, and the daemon has already failed. README no longer calls rocmd the dashboard's telemetry daemon: that daemon runs inside `rocm dash`, and rocmd runs the watchers, the managed-service supervisor and the MCP tools. The e2e steps reuse the client-log reader and share one whitespace squash helper instead of repeating both inline. Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
… real probe (ROCMAI-456) The socket directory test now checks that every directory the recursive create makes, intermediate ones included, is created at 0700 rather than chmodded afterwards, and the directory policy table gains sticky rows where only group or only others may write. spawn_keeper is tested against a real daemon, so the dashboard's ready-wait is seen to end on the socket answering rather than on its time limit. dash-55/57 now wait for both dashboards' connection lines before taking the baseline count, since the client log is written through a non-blocking appender and a late line could pass for the reconnection. The chat help says the interactive chat shares the dashboard's daemon and reports its failure after closing; the dashboard wording names Linux/WSL; doc comments and docs/architecture.md are corrected to match the code (keeper retry after one poll, the bind-loss refusal, the ready-wait's possible overrun). Signed-off-by: Roman Inflianskas <Roman.Inflianskas@amd.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Why
On Linux/WSL, with two
rocm dashsessions open, quitting (or killing) the one that started first leaves the other showingdisconnecteduntil it is restarted.The embedded telemetry daemon ran inside whichever dashboard started first, and whether a dashboard hosts it was decided once, at startup. When the host exited, no surviving dashboard ever took over. Removing or guarding the exit-time socket cleanup alone does not fix this: with the first dashboard killed by SIGKILL the socket file stays behind and the second session is still stranded.
A second defect sat next to it: the daemon unlinked whatever was at the socket path before binding, so a second daemon at the same path replaced a live listener (reproduced: a new inode at the path, and the old daemon and its clients unreachable).
Once several dashboards contend for one path, what a daemon may do with the socket's directory matters on every attempt, so the directory policy is settled here too rather than left as it was.
What changes
apps/rocm/src/dash_daemon.rs, new) that serves the socket whenever no other daemon does. It retries every 250 ms while another daemon of this build owns the path, every 5 s while something without the ownership lock answers there (an older build, or another program), and backs off from 1 s to 30 s on any other failure. The backoff and the failed-attempt count start over when another daemon is found serving, when the socket is taken from a serving daemon, or after a run that served for at least 30 s; a run that served for less does not reset them, so a daemon that keeps stopping soon after it starts is still backed off rather than restarted every second. When the owning dashboard closes or is killed, a surviving one takes over and its TUI reconnects, typically within 1–2 s.check_socket_dirand the puresocket_dir_verdictincrates/rocm-dash-daemon/src/server.rs), judged by what it resolves to when it is a symlink:0700, as is every missing parent the recursive create makes on the way to it, so none of them is chmodded afterwards; it is then checked again like an existing one, since another user could have created it in between;/tmp) is never chmodded, whoever owns it, root included; it is used when root or this user owns it, with a warning once the path is claimed when others may write in it, and refused when another user owns it;0700whenever group or others have any access to it (mode & 0o077 != 0), so an owned0755one is tightened too; the chmod is logged once, at info, with the directory and its old mode. One that group and others cannot reach at all (0700,0500) is left exactly as it is, so a dashboard polling for the socket never repeats a chmod or the log line.unix:socket path the dashboard serves, including one configured indashboard.tui.connect: when this user owns that directory and it is not sticky, it is restricted to0700, so such a path belongs in a dedicated directory, not$HOMEor one shared with others.<socket>.lock(mode0600, opened withO_NOFOLLOW, so a symlink planted at the lock path is refused rather than followed) next to the socket, held for the daemon's life and released by the OS however the process exits (SocketClaim). A daemon that finds the path owned returns the publicSocketInUseerror (saying whether a lock holder or an unlocked listener holds it) and removes or replaces nothing at the path.SocketInUseotherwise, including a path that vanished or cannot be inspected by then. On exit the daemon removes the socket only if the path is still the one it bound.SocketReplacederror and releases the lock, so a keeper can claim the path again without counting a failure. A check that cannot read the path is tolerated; five unreadable checks in a row give the path up.JoinSets owned by the serving future, so stopping the daemon stops them and closes its clients' connections (the runner's own background GPU detection task is not among them). A runner that stops or panics ends the daemon with an error, and the keeper restarts it with backoff; a panicking client task is logged.rocm dashprints it to stderr once the TUI has left the terminal. The report opens with "could not start" when the daemon never served and "stopped serving" when it had served and has not served again; it names the path and the last error, adds "(N failed attempts)" from two failed runs on, and names the client log directory only when the warnings actually reached the log. It is dropped when another daemon answers at the socket by the time the dashboard closes, since that dashboard was then working on the other daemon. A panic of the keeper itself is always reported, as "the dashboard's supervision of it stopped unexpectedly" with the panic's own message (and the failure recorded before it, if there was one and it was not dropped). While the dashboard waits about 5 s at most for its daemon to start (it can run over by one probe of a listener that does not greet, up to 0.5 s), it probes the socket the same way the stale-socket check does, reading the greeting before it hangs up, so the daemon does not log a client error for every dashboard opened; it stops waiting as soon as the daemon has failed.BENCH_HISTORY_CAPinrocm-dash-core), so clearing loses nothing.rocmdrops the caller'sRUST_LOG(piped runs still inherit it), so steps that count the info-level lines in the client log do not depend on the log filter of the shell running the suite. This is test-harness hardening; the CLI's own behaviour does not change.eprintln!on exit, which wrote into the TUI's alternate screen, is replaced withtracing.libcforrocm-dash-daemonon unix only (geteuidandO_NOFOLLOW; already in the lockfile throughrocm-core), and tokio'stest-utilfeature as arocmdev-dependency, for the keeper's paused-clock timing tests.User-visible changes:
disconnected, and keeps its chart history.main) and is not fixed here.amd-smiagain (its 5 s detection limit plus its 10 s limit on the first system query).session-*.ndjsonrecording, since the daemon that takes over is a new daemon.<socket>.lockfile exists beside the socket and stays after the last dashboard closes.rocm chator the barerocmlauncher; from the launcher the lines land on the main screen and are seen when the launcher itself exits.main, which created the directory and then always chmodded it to0700, refusing it only when that chmod failed and it was not a root-owned sticky directory: a non-sticky directory this user owns that group or others have any access to, such as a0755one, is still tightened to0700as onmain, and the change is now logged at info; one they cannot reach at all keeps its mode (a0500one is no longer made0700); a sticky directory is no longer chmodded by anyone, so root no longer chmods/tmpwhen its socket lives there, and a sticky directory of this user's own keeps its mode; and a directory another user owns (other than a root-owned sticky one such as/tmp) is refused without a chmod being attempted, so a daemon running as root now refuses it wheremainchmodded it and used it (as a regular usermainalready refused it, after its chmod failed).rocm dash --helpand the README now say that open dashboards share one telemetry daemon on Linux/WSL, that a surviving one takes it over, and when the failure report is printed, including that a crash of the dashboard's own supervision of its telemetry daemon is reported even when another dashboard's daemon is serving. The README also no longer says the dashboard auto-starts an embeddedrocmd: the embedded daemon is the dashboard's own telemetry daemon. Its build section no longer callsrocmdthe dashboard's telemetry daemon either, and says whatrocmddoes run: the watchers, the managed-service supervisor and the MCP tools.rocm chat --helpnow says that on Linux/WSL the interactive chat shares the dashboard's telemetry daemon the wayrocm dashdoes and, like it, prints why that daemon was failing after it closes.Windows is unaffected: there is no embedded daemon or socket there, so no keeper starts and nothing is reported.
Docs updated in the same change:
README.md,docs/architecture.md(the new file entry, the socket-directory policy and the socket-ownership boundary),docs/testing.md, anddocs/manual-testing.md(section 4e, Two Dashboards At Once, including the hand-off costs, the failure report, how to see the "stopped serving" report by hand, and how to see a configured socket path's directory restricted to0700and the one log line it leaves).Decisions for the reviewer
std::fs::File::try_lockinstead ofrocm_core::FileLock.FileLockcannot create the lock file with mode0600, and using it would add a productionrocm-dash-daemon→rocm-coredependency edge for one call.0700on the next attempt and is neither chmodded nor logged again. The shared-sticky-directory warning is given once, by the daemon that claims the path, not on every poll.0600socket and lock cannot be replaced there by another user; chmodding a shared directory such as/tmp(which root could do) would break it for everyone else.rocm-dash-daemon:SocketInUse.holderwith theSocketHolderenum,SocketReplaced, theNOT_A_SOCKETconstant,run_with_ready(a callback once the daemon is serving) andsocket_answers(the claim's liveness probe). The keeper is the only in-repo caller;runkeeps its signature.Scope
<socket>.lockfile and hold its lock (or leave it unopenable), which keeps every dashboard from serving at that path. The fix is not to publish the socket in a shared directory at all, which belongs with that work.unix:rocmdashd.sockis created in the current directory, which is not checked at all.docs/manual-testing.mddescribe it as a known issue.(dev, ino). If an older build without the lock, or a manual bind, recreates the path after an external unlink and the filesystem reuses the inode number, the daemon could take that socket for its own. Daemons from this build cannot produce that sequence, because a second one cannot bind while the lock is held.Verification
New tests, each seen to fail with the code it covers broken:
crates/rocm-dash-daemon/src/server.rs, by area:the_socket_directory_policy); a missing directory created private, every directory the recursive create makes on the way included, with no chmod logged (creates_missing_parent_at_0700,serving_creates_a_missing_socket_directory_privately); only a directory of ours that group or others have any access to tightened, before the claim, an owned0755one included and logged once with its old mode (only_a_socket_directory_others_can_reach_is_tightened,tightens_owned_preexisting_parent,serving_restricts_a_socket_directory_it_owns,a_loose_socket_directory_of_ours_is_made_private_before_the_claim,a_loose_socket_directory_is_tightened_before_the_claim_runs); another user's directory refused before anything is touched, never chmodded, also through a symlink (a_socket_directory_another_user_owns_is_refused_before_anything_is_touched,another_users_writable_socket_directory_is_refused_not_chmodded,a_symlink_to_another_users_socket_directory_is_refused) and when the daemon had just created it (a_socket_directory_just_created_is_judged_like_an_existing_one); a sticky directory never chmodded and reported as shared, with the warning given once by the daemon that claims the path (a_sticky_socket_directory_is_served_as_it_is,preexisting_root_sticky_parent_is_used_as_it_is,a_sticky_socket_directory_is_reported_as_shared,the_shared_directory_warning_comes_once_from_the_daemon_that_claims_the_path); a directory that cannot be inspected or is not a directory (a_socket_directory_that_cannot_be_inspected_is_reported,a_socket_directory_that_is_not_a_directory_is_refused); a symlinked directory judged by its target (a_symlinked_socket_directory_is_judged_by_its_target); a symlink at the lock path not followed (a_symlink_at_the_lock_path_is_not_followed); the helper that gives a bare socket file name no directory to check, rather than the empty path the check refuses (a_bare_socket_name_has_no_directory_to_check; it calls the helper only, since serving a bare name in a unit test would change the process-wide current directory under parallel tests). The cross-user cases run the check as a different uid through a test seam (ServeSeams::our_uid), since a test cannot create a directory another user really owns.the_probe_reads_a_bounded_greeting_from_a_listener_that_never_ends_a_line); a socket the probe cannot connect to for a reason other than refusal, here its mode, is reported rather than replaced (a_socket_the_probe_cannot_reach_is_reported_not_replaced); a bind lost to a listener without the lock is reported in use; a file that appears before the bind is refused as not a socket; what a bind that finds the path taken reports for a socket, a file, and a path that vanished since (a_bind_that_finds_the_path_taken_reports_what_is_there_now); and a chmod that fails after binding still leaves the claim to remove its socket (a_claim_whose_chmod_fails_still_removes_its_socket).only_five_unreadable_path_checks_in_a_row_give_the_path_up).apps/rocm/src/dash_daemon.rs(keeper): a surviving dashboard takes over when the owner leaves; closing a dashboard that never owned the daemon leaves it running; the pure retry decisionnext_step(backoff doubling to 30 s, resets on an owner, on a reclaim and after a run that served long enough, 5 s polling for an unlocked listener, counting only failures in a row); a daemon refused its path is retried and reported after the dashboard closes (the report names the path once and the log, the log holds the warning, the file is untouched); the report names the log only when the warning reached it, and counts failed attempts from two; a failure ends, and is not reported, once another daemon serves the socket; a daemon that recovered is not reported; a failed daemon does not hold up the dashboard; started against a real daemon, the dashboard stops waiting as soon as the real probe finds the socket answering, well inside its limit, with nothing to report on close (the_dashboard_waits_only_until_its_daemon_answers); the up-to-5 s wait before the dashboard draws, as its own function on tokio's paused clock, ends at the first probe that finds the socket answering (the_ready_wait_ends_once_the_socket_answers), at once when the daemon has already failed (the_ready_wait_ends_at_once_when_the_daemon_has_failed), and after its limit otherwise (the_ready_wait_gives_up_after_its_limit); a removed socket is served again without a failure; a keeper that panicked is reported, with its message, as having stopped when it had served, ahead of a failure recorded before it, and even when another daemon serves; a non-unix target starts no keeper. The keeper's timing is checked with the daemon scripted on tokio's paused clock: failed runs spaced by the growing backoff (failed_runs_are_spaced_by_the_growing_backoff), a daemon that keeps stopping soon after it starts serving backed off rather than restarted every second (a_daemon_that_keeps_stopping_soon_after_serving_backs_off), the backoff starting over after a run that served long enough (a_run_that_served_long_enough_starts_the_backoff_over), a daemon that served and then stopped reported as having stopped (a_daemon_that_served_and_then_stopped_is_reported_as_stopped), a replaced socket claimed again one poll later without a failure (a_replaced_socket_is_claimed_again_after_one_poll_without_a_failure), and a socket in use tried again after one 250 ms takeover poll when another daemon holds its lock and after 5 s when something without the lock answers there, neither recorded as a failure (a_socket_in_use_is_tried_again_after_its_holders_poll).crates/rocm-dash-tui/src/app/mod.rs:benchmark_rows_are_held_once_across_a_reconnect.Scenarios in
tests/e2e-cucumber/features/dash.feature. Each simulates a GPU-less host itself (likedash-37), so the runner's GPU does not change the outcome.dash-55todash-57are tagged only@requires-os:linux, so they run on every Linux e2e lane, GPU or not, and are skipped on Windows;dash-58also carries@requires-dir-permissions, since a directory permission does not bind root, and is skipped where the suite runs as root.dash-55,@id:dash-second-session-survives-first-closing: opens two dashboards, waits until both connections are in the client log, quits the first, and requires the second to connect again and show the connected header. Against the pre-fix code it fails at "the second dashboard is connected to its telemetry daemon again".dash-56,@id:dash-reports-unusable-telemetry-socket-on-exit: puts a regular file where the socket goes, opens and quits the dashboard, and requires it to exit successfully, report after closing that its telemetry daemon could not use that file and where the warning was logged (and the log to hold the warning), and leave the file in place.dash-57,@id:dash-handoff-lists-each-benchmark-result-once: records two benchmark results, opens two dashboards (waiting, likedash-55, for both connections in the client log before the first is quit), and requires the second to list each result once on its Observe view, both before and after the first is quit and it has connected to the daemon that took over. This also drives the event loop's call toon_connected.dash-58,@id:dash-reports-telemetry-daemon-that-stopped-serving: makes the socket's directory unreadable under a serving daemon, waits until the daemon gives the socket up, requires the dashboard to show it is disconnected and, after it closes, to report that its telemetry daemon stopped serving (naming the socket), not that it could not start.Run locally (Linux, no WSL), on the final tree, rebased on
mainat9e50eac:cargo fmt --all -- --check;cargo clippy --locked --workspace --all-targets -- -D warnings;cargo clippy --locked -p e2e-cucumber --test e2e -- -D warnings;cargo xtask check-module-size,check-architecture-docandcheck-crate-edges;cargo testforrocm-dash-daemon,rocm-dash-tuiandrocm-dash-core(unit and integration tests), and therocmbinary'sdashtests (run from the built test binary); andcargo xtask e2e -- -n "dash-5[5-8]", wheredash-55todash-58passed, 35 of 35 steps. All passed. The tests that capture log lines through a thread-localtracingsubscriber, inrocm-dash-daemonand in therocmbinary's keeper tests, install it through alog_attest helper in each crate that first registers two process-lifetime no-op dispatchers: tracing-core caches a callsite's interest when it is first hit, and while at most one dispatcher is registered it asks only the hitting thread's default subscriber, so a test running in parallel with no subscriber could cache a callsite as disabled and the capturing test then saw no line. With the helper, therocm-dash-daemonunit tests ran 60 times, ten processes at once, with 0 failures; with that registration disabled, the same loop failed 4 of 40 runs, each withtightens_owned_preexisting_parentseeing no log line. The stale-socket test fixture likewise waits, within the test deadline, until a connection to the dropped listener is refused, because a child process a parallel test starts can hold the listener's descriptor until it execs. The four tests named above for the probe, the bind, the chmod and a bare socket name were each seen to fail with the branch they cover broken: the probe's other errors taken as stale or as answering, the bind's not-a-socket check inverted or applied to a vanished path, the socket's identity recorded after the chmod instead of before, and the helper passing a bare name's empty parent to the directory check.Not verified locally:
stop_keeperandfailure_reportare unreachable at runtime becausespawn_keeperstarts nothing there.000path-watch tests anda_socket_the_probe_cannot_reach_is_reported_not_replacedprint a skip line and count as passed when run as root.cargo xtask coverage: not run locally.cargo xtask smoke: not run on the final tree. On this host it stops at itsrocmd sandbox examine snapshotstep, unrelated to this change: bubblewrap cannot configure the sandbox's loopback interface under the host's user-namespace policy.cargo test --workspace --all-targetswas not run on the final tree (only the dash crates and tests above), nor the dash scenarios other thandash-55todash-58; the CI e2e lanes run the whole feature. An earlier full run on this branch had failures that were all environmental (anoexec/tmp, git signing inside scratch repositories) and reproduced identically onmain.Checklist
tests/e2e-cucumber/expectations.tomlfor the fixed ticket ID and removed/narrowed any now-stale xfail rows.docs/architecture.md(the clap declaration incli.rsand the dispatch wiring inmain.rs/lib.rsare expected, not a violation)..rsfile underxtask/srcortests/e2e-cucumber),docs/architecture.mdhas the matching entry (cargo xtask check-architecture-docfails otherwise), and the prose of any entry whose file changed role still describes it, which the check cannot verify.socket_dir_verdict, the info-level chmod log namesDEFAULT_FILTERinapps/rocm/src/logging.rsas what keeps it, and the ready-wait comment names the test proving the probe reads the greeting.e2ejob (for example by a tag) is justified as a deletion (AGENTS.md §8). Not applicable: no existing scenario is moved or retagged;dash-55todash-58are new.