Struct WorkerCapabilities 

pub struct WorkerCapabilities {

    pub rustc_version: Option<String>,
    pub rustup_toolchains: Vec<String>,
    pub rustup_components: Vec<String>,
    pub probe_warnings: Vec<String>,
    pub bun_version: Option<String>,
    pub node_version: Option<String>,
    pub npm_version: Option<String>,
    pub nix_version: Option<String>,
    pub go_version: Option<String>,
    pub zig_version: Option<String>,
    pub cargo_zigbuild_version: Option<String>,
    pub cpu_microarch_level: Option<u8>,
    pub tools_present: Vec<String>,
    pub tools_absent: Vec<String>,
    pub num_cpus: Option<u32>,
    pub load_avg_1: Option<f64>,
    pub load_avg_5: Option<f64>,
    pub load_avg_15: Option<f64>,
    pub disk_free_gb: Option<f64>,
    pub disk_total_gb: Option<f64>,
    pub build_disk_free_gb: Option<f64>,
    pub build_disk_total_gb: Option<f64>,
    pub projects_root_ok: Option<bool>,
    pub projects_root_issue: Option<String>,
    pub projects_root_checked_at_unix_ms: Option<i64>,
}

Runtime capabilities detected on a worker.

These are probed during health checks and cached for routing decisions. Commands requiring specific runtimes (e.g., bun test) can be routed only to workers with the corresponding capability.

Fields

rustc_version: Option<String>

Rust compiler version (from rustc --version).

rustup_toolchains: Vec<String>

Installed rustup toolchains, including their host triple when rustup reports one (for example nightly-2026-07-05-x86_64-unknown-linux-gnu).

rustup_components: Vec<String>

Installed rustup components as <toolchain>:<component> facts. Component names are normalized by removing only the probed host-triple suffix, so clippy-preview can never satisfy a clippy requirement.

probe_warnings: Vec<String>

Non-fatal diagnostics gathered while probing (for example a tool binary that had to be resolved from a well-known fallback location because the caller’s PATH was minimal). Empty in the common case; clients may surface these so “no facts” is distinguishable from “facts show absence” (bd-deft5).

bun_version: Option<String>

Bun runtime version (from bun --version).

node_version: Option<String>

Node.js version (from node --version).

npm_version: Option<String>

npm version (from npm --version).

nix_version: Option<String>

Nix version (from nix --version). Presence implies a usable nix binary with an accompanying /nix/store, gating nix build/nix develop -c routing to this worker.

go_version: Option<String>

Go toolchain version (from go version). Presence gates go build/ go test/go vet routing to this worker.

zig_version: Option<String>

Zig version (from zig version). cargo zigbuild shells out to zig as the linker/C toolchain, so the bare zig binary is necessary but not sufficient — see WorkerCapabilities::has_zig.

cargo_zigbuild_version: Option<String>

cargo-zigbuild version (from cargo-zigbuild --version). Probed as the hyphenated binary rather than cargo zigbuild --version, which the subcommand’s own parser rejects.

cpu_microarch_level: Option<u8>

x86-64 microarchitecture level (1..=4) parsed from /proc/cpuinfo flags on the worker (bd-6qchz / bd-68hon item 4). Some(2) marks a pre-AVX2 box (e.g. ovh-b’s Ivy Bridge) whose build scripts SIGILL on x86-64-v3 codegen; selection deprioritizes such workers proactively while the reactive SIGILL quarantine remains the primary mechanism. None on non-x86 workers or when the probe cannot read cpuinfo.

tools_present: Vec<String>

Operator-declared named tools whose probe exited ZERO on this worker.

The list is evidence, not configuration: a name appears here only because the worker ran the declared argv and it succeeded. Selection gates --require-tool on this, which is the difference between a verified capability and a tag somebody wrote by hand.

tools_absent: Vec<String>

Operator-declared named tools whose probe RAN and did not exit zero.

Kept separate from “never declared” so an operator can tell a worker that is missing a tool from a fleet that never probed for it — the two have different fixes.

num_cpus: Option<u32>

Number of CPU cores on the worker.

load_avg_1: Option<f64>

1-minute load average.

load_avg_5: Option<f64>

5-minute load average.

load_avg_15: Option<f64>

15-minute load average.

disk_free_gb: Option<f64>

Free space in GB on the tightest mount a build touches: whichever of the projects root, its alias and /tmp has the lowest free ratio. Drives pressure classification (a full /tmp breaks scp/mktemp).

disk_total_gb: Option<f64>

Total size in GB of the mount reported in disk_free_gb.

build_disk_free_gb: Option<f64>

Free space in GB on the filesystem that holds build trees (the fuller of the projects root and its alias; /tmp excluded). Sizes capacity: slot derating, disk headroom and the free-space floor (GH #78). None from an rch-wkr that predates the field.

build_disk_total_gb: Option<f64>

Total size in GB of the mount reported in build_disk_free_gb.

projects_root_ok: Option<bool>

Canonical path-topology preflight status (/data/projects + /dp alias).

Some(false) indicates a hard preflight failure that should exclude this worker from remote scheduling until a subsequent successful revalidation.

projects_root_issue: Option<String>

Machine-readable failure reason for path-topology preflight.

projects_root_checked_at_unix_ms: Option<i64>

Unix timestamp (ms) when topology preflight last executed.

Implementations

impl WorkerCapabilities

pub fn new() -> Self

Create new empty capabilities.

pub fn mock_with_rust() -> Self

Create mock capabilities with Rust installed.

Used by mock transport to simulate a worker with Rust toolchain.

pub fn is_pre_v3_x86(&self) -> bool

Whether this is a known pre-x86-64-v3 (no AVX2) x86 worker — the class whose build-script/proc-macro binaries SIGILL on v3 codegen (bd-68hon). None (unknown/non-x86) is NOT pre-v3: only affirmative evidence deprioritizes a worker.

pub fn has_bun(&self) -> bool

Check if this worker has Bun installed.

pub fn has_node(&self) -> bool

Check if this worker has Node.js installed.

pub fn has_rust(&self) -> bool

Check if this worker has Rust installed.

pub fn has_rustup_component(&self, toolchain: &str, component: &str) -> bool

Check whether component is installed for toolchain.

Rustup reports pinned toolchains with a host-triple suffix. The request carries the project pin without that suffix, so the owner half uses the same exact-or---boundary prefix rule as toolchain admission. The component half is exact.

pub fn has_nix(&self) -> bool

Check if this worker has Nix installed (nix binary + /nix/store).

pub fn has_go(&self) -> bool

Check if this worker has the Go toolchain installed.

pub fn has_zig(&self) -> bool

Check if this worker can run cargo zigbuild cross-compiles.

Requires BOTH halves of the toolchain: the cargo-zigbuild cargo subcommand and the zig binary it drives as the linker. Either one alone fails at build time with an error the remote-result heuristics do not recognize as infrastructure (error: no such command: 'zigbuild' is not a rustup message), so the exit code would be surfaced verbatim instead of falling open to local. Gating both here keeps that failure out of the user’s build.

pub fn load_per_core(&self) -> Option<f64>

Calculate load per core (1-minute load average / num_cpus). Returns None if metrics are unavailable.

pub fn is_high_load(&self, max_load_per_core: f64) -> Option<bool>

Check if worker has high load (exceeds threshold). Returns None if metrics unavailable (fail-open).

pub fn build_disk_gb(&self) -> (Option<f64>, Option<f64>)

(free_gb, total_gb) of the filesystem that holds build trees.

Capacity questions (how many builds fit, is the free-space floor met) are about that filesystem, not about a small tmpfs /tmp that happens to be the tightest mount. Falls back to the tightest-mount sample when the worker does not report a build-disk sample (older rch-wkr), which is the conservative pre-GH-#78 behaviour.

pub fn is_low_disk(&self, min_free_gb: f64) -> Option<bool>

Check if the build disk is below the free-space threshold. Returns None if metrics unavailable (fail-open).

pub fn is_topology_healthy(&self) -> Option<bool>

Check if canonical path-topology preflight is healthy.

Returns None when probe data is unavailable (fail-open behavior).

Trait Implementations

impl Clone for WorkerCapabilities

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WorkerCapabilities

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for WorkerCapabilities

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for WorkerCapabilities

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for WorkerCapabilities

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for WorkerCapabilities

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.