roundabout

public

Star0

Fork 0

Watch0

1 commit 1 branch 0 tags 0 releases158.8 KiB

Commit `6f5b84fad3ef`

tarball

atagen <boss@atagen.co>2026-09-27 03:59 UTC

18 files changed+3772-0

roundabout: admit builds by self-reported size so parallel agents stop ooming the box

A per-user daemon, spawned on first use and gone once idle, grants leases for as long as the requesting connection stays open, so a crashed agent can never strand a lock. Admission is fifo with easy backfill. Heavies never overlap, disk is never promised twice, and small jobs only jump the queue when they will be gone before the head could start. Build artifacts are tracked per project and gc'd once idle or over their caps.

Added file: .gitignore+2

@@ -0,0 +1,2 @@

1+/target

2+/result*

Added file: Cargo.lock+198 additions@@ -0,0 +1,198 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "libc"
+version = "0.2.189"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "pound"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c86a0567fb5ffd1e933983f6baef4e557d0cc2bf3541b26c169bbb8099889487"
+dependencies = [
+ "pound-derive",
+]
+
+[[package]]
+name = "pound-derive"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ea8a0689abf825dc184168cda08d14ff35a451cea2650464400932589cf4cf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "venial",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "roundabout"
+version = "0.1.0"
+dependencies = [
+ "libc",
+ "pound",
+ "serde",
+ "serde_json",
+ "toml",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.3+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"
+dependencies = [
+ "winnow 1.0.4",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954"
+
+[[package]]
+name = "venial"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a42528baceab6c7784446df2a10f4185078c39bf73dc614f154353f1a6b1229"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+
+[[package]]
+name = "winnow"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

Added file: Cargo.toml+38 additions@@ -0,0 +1,38 @@
+[package]
+name         = "roundabout"
+version      = "0.1.0"
+edition      = "2024"
+authors      = [ "atagen" ]
+description  = "build admission for agents that can't share"
+license      = "EUPL-1.2"
+rust-version = "1.91"
+
+[[bin]]
+name = "rabt"
+path = "src/main.rs"
+
+[dependencies]
+libc       = "0.2"
+pound      = "0.1"
+serde      = { version = "1", features = [ "derive" ] }
+serde_json = "1"
+toml       = { version = "0.9", default-features = false, features = [ "parse", "serde" ] }
+
+[lints.clippy]
+nursery  = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+
+cast_possible_truncation = "allow"
+cast_precision_loss      = "allow"
+cast_sign_loss           = "allow"
+missing_errors_doc       = "allow"
+module_name_repetitions  = "allow"
+option_if_let_else       = "allow"
+too_many_lines           = "allow"
+
+[profile.release]
+codegen-units = 1
+lto           = "fat"
+opt-level     = "s"
+panic         = "abort"
+strip         = true

Added file: src/artifacts.rs+341 additions@@ -0,0 +1,341 @@
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    fs,
+    os::unix::fs::MetadataExt,
+    path::{Path, PathBuf},
+    process::Command,
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    client,
+    config::{Config, Rule},
+    paths,
+    proto::{self, Event, Reader, Request},
+    store, sys,
+    units::Bytes,
+};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Entry {
+    pub root: PathBuf,
+    pub rule: String,
+    pub last_used: u64,
+    pub pinned: bool,
+    pub size: Bytes,
+    pub sized_at: u64,
+}
+
+type Registry = BTreeMap<PathBuf, Entry>;
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |d| d.as_secs())
+}
+
+fn matches(rule: &Rule, name: &str) -> bool {
+    match rule.name.strip_suffix('*') {
+        Some(prefix) => name.starts_with(prefix),
+        None => name == rule.name,
+    }
+}
+
+fn discover<'a>(cfg: &'a Config, root: &Path) -> Vec<(PathBuf, &'a Rule)> {
+    let Ok(dir) = fs::read_dir(root) else {
+        return Vec::new();
+    };
+    let names: Vec<String> = dir
+        .flatten()
+        .map(|e| e.file_name().to_string_lossy().into_owned())
+        .collect();
+    names
+        .iter()
+        .filter_map(|name| {
+            let rule = cfg.artifact_rules().find(|r| {
+                matches(r, name) && r.marker.as_ref().is_none_or(|m| root.join(m).exists())
+            })?;
+            Some((root.join(name), rule))
+        })
+        .collect()
+}
+
+/// symlinks are followed at the top only, so a nix `result` counts its store
+/// path. hardlinks count once, the store is full of them
+fn size_of(path: &Path) -> Bytes {
+    let mut seen = BTreeSet::new();
+    let mut total = 0;
+    let mut stack = vec![fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())];
+    while let Some(p) = stack.pop() {
+        let Ok(meta) = fs::symlink_metadata(&p) else {
+            continue;
+        };
+        if meta.nlink() > 1 && !seen.insert((meta.dev(), meta.ino())) {
+            continue;
+        }
+        total += meta.blocks() * 512;
+        if meta.is_dir()
+            && let Ok(dir) = fs::read_dir(&p)
+        {
+            stack.extend(dir.flatten().map(|e| e.path()));
+        }
+    }
+    Bytes(total)
+}
+
+/// only builds bump `last_used`. checking sizes isn't using them
+pub fn register(cfg: &Config, root: &Path, used: bool) {
+    let found = discover(cfg, root);
+    if found.is_empty() {
+        return;
+    }
+    let _ = store::update("artifacts", |reg: &mut Registry| {
+        for (path, rule) in found {
+            reg.entry(path)
+                .and_modify(|e| {
+                    if used {
+                        e.last_used = now();
+                    }
+                })
+                .or_insert_with(|| Entry {
+                    root: root.to_path_buf(),
+                    rule: rule.name.clone(),
+                    last_used: now(),
+                    pinned: false,
+                    size: Bytes::ZERO,
+                    sized_at: 0,
+                });
+        }
+    });
+}
+
+pub fn pin(path: &Path, pinned: bool) -> Result<(), String> {
+    let path = fs::canonicalize(path).map_err(|e| format!("{}: {e}", path.display()))?;
+    let root = paths::project_root(path.parent().unwrap_or(&path));
+    store::update("artifacts", |reg: &mut Registry| {
+        reg.entry(path.clone())
+            .or_insert_with(|| Entry {
+                root: root.clone(),
+                rule: "manual".into(),
+                last_used: now(),
+                pinned,
+                size: Bytes::ZERO,
+                sized_at: 0,
+            })
+            .pinned = pinned;
+    })
+    .map_err(|e| e.to_string())
+}
+
+fn active_roots() -> BTreeSet<PathBuf> {
+    let Some(mut s) = client::connect() else {
+        return BTreeSet::new();
+    };
+    if proto::send(&mut s, &Request::Status).is_err() {
+        return BTreeSet::new();
+    }
+    match Reader::new(&s).and_then(|mut r| r.recv::<Event>()) {
+        Ok(Some(Event::Status(st))) => st
+            .leases
+            .iter()
+            .map(|l| paths::project_root(&l.cwd))
+            .collect(),
+        _ => BTreeSet::new(),
+    }
+}
+
+fn refresh(cfg: &Config, root: Option<&Path>, fresh: bool) -> Registry {
+    if let Some(root) = root {
+        register(cfg, root, false);
+    }
+    let ttl = cfg.artifacts.size_ttl.0.as_secs();
+    store::update("artifacts", |reg: &mut Registry| {
+        reg.retain(|p, _| fs::symlink_metadata(p).is_ok());
+        for (path, e) in reg.iter_mut() {
+            if fresh || now().saturating_sub(e.sized_at) > ttl {
+                e.size = size_of(path);
+                e.sized_at = now();
+            }
+        }
+        reg.clone()
+    })
+    .unwrap_or_default()
+}
+
+pub struct Report {
+    pub project: Option<(PathBuf, Bytes)>,
+    pub global: Bytes,
+    pub over_project: bool,
+    pub over_global: bool,
+    pub entries: Registry,
+}
+
+impl Report {
+    pub const fn over(&self) -> bool {
+        self.over_project || self.over_global
+    }
+
+    pub fn describe(&self, cfg: &Config) -> String {
+        let mut out = Vec::new();
+        if let Some((root, size)) = &self.project
+            && self.over_project
+        {
+            out.push(format!(
+                "{} holds {size} of build artifacts, cap is {}",
+                root.display(),
+                cfg.artifacts.project_cap
+            ));
+        }
+        if self.over_global {
+            out.push(format!(
+                "artifacts total {} across projects, cap is {}",
+                self.global, cfg.artifacts.global_cap
+            ));
+        }
+        out.join(". ")
+    }
+}
+
+pub fn check(cfg: &Config, root: Option<&Path>, fresh: bool) -> Report {
+    let entries = refresh(cfg, root, fresh);
+    let global = entries.values().map(|e| e.size).sum();
+    let project = root.map(|r| {
+        let size = entries
+            .values()
+            .filter(|e| e.root == r)
+            .map(|e| e.size)
+            .sum();
+        (r.to_path_buf(), size)
+    });
+    Report {
+        over_project: project
+            .as_ref()
+            .is_some_and(|(_, s)| *s > cfg.artifacts.project_cap),
+        over_global: global > cfg.artifacts.global_cap,
+        project,
+        global,
+        entries,
+    }
+}
+
+fn remove(cfg: &Config, path: &Path, e: &Entry) -> Result<(), String> {
+    let rule = cfg.artifact_rules().find(|r| r.name == e.rule);
+    if let Some(clean) = rule.and_then(|r| r.clean.as_ref())
+        && let Some((prog, args)) = clean.split_first()
+    {
+        let ok = Command::new(prog)
+            .args(args)
+            .current_dir(&e.root)
+            .status()
+            .is_ok_and(|s| s.success());
+        return if ok {
+            Ok(())
+        } else {
+            Err(format!("`{}` failed", clean.join(" ")))
+        };
+    }
+    let meta = fs::symlink_metadata(path).map_err(|err| err.to_string())?;
+    if meta.is_dir() {
+        fs::remove_dir_all(path)
+    } else {
+        fs::remove_file(path)
+    }
+    .map_err(|err| format!("{}: {err}", path.display()))
+}
+
+pub struct Gc {
+    pub freed: Bytes,
+    pub removed: Vec<PathBuf>,
+    pub failed: Vec<String>,
+}
+
+pub fn gc(cfg: &Config, to_cap: bool, dry_run: bool) -> Gc {
+    let entries = refresh(cfg, None, false);
+    let active = active_roots();
+    let idle_after = cfg.artifacts.idle_after.0.as_secs();
+    let movable = |e: &Entry| !e.pinned && !active.contains(&e.root);
+
+    let mut doomed: Vec<PathBuf> = entries
+        .iter()
+        .filter(|(_, e)| movable(e) && now().saturating_sub(e.last_used) > idle_after)
+        .map(|(p, _)| p.clone())
+        .collect();
+
+    if to_cap {
+        let mut global: Bytes = entries
+            .iter()
+            .filter(|(p, _)| !doomed.contains(p))
+            .map(|(_, e)| e.size)
+            .sum();
+        let mut per_root: BTreeMap<&Path, Bytes> = BTreeMap::new();
+        for (p, e) in &entries {
+            if !doomed.contains(p) {
+                *per_root.entry(&e.root).or_default() += e.size;
+            }
+        }
+        let mut lru: Vec<(&PathBuf, &Entry)> = entries
+            .iter()
+            .filter(|(p, e)| movable(e) && !doomed.contains(p))
+            .collect();
+        lru.sort_by_key(|(_, e)| e.last_used);
+        for (p, e) in lru {
+            let root_size = per_root.get(e.root.as_path()).copied().unwrap_or_default();
+            if global <= cfg.artifacts.global_cap && root_size <= cfg.artifacts.project_cap {
+                continue;
+            }
+            global = global.saturating_sub(e.size);
+            per_root.insert(&e.root, root_size.saturating_sub(e.size));
+            doomed.push(p.clone());
+        }
+    }
+
+    let mut out = Gc {
+        freed: Bytes::ZERO,
+        removed: Vec::new(),
+        failed: Vec::new(),
+    };
+    for path in doomed {
+        let e = &entries[&path];
+        if !dry_run && let Err(err) = remove(cfg, &path, e) {
+            out.failed.push(err);
+            continue;
+        }
+        out.freed += e.size;
+        out.removed.push(path);
+    }
+    if !dry_run {
+        let removed = out.removed.clone();
+        let _ = store::update("artifacts", |reg: &mut Registry| {
+            for p in &removed {
+                reg.remove(p);
+            }
+        });
+        nix_gc(cfg, &mut out);
+    }
+    out
+}
+
+fn nix_gc(cfg: &Config, out: &mut Gc) {
+    if !cfg.artifacts.nix_gc {
+        return;
+    }
+    let Some(store) = sys::fs(Path::new("/nix/store")) else {
+        return;
+    };
+    let want = cfg.artifacts.nix_min_free.saturating_sub(store.free);
+    if want == Bytes::ZERO {
+        return;
+    }
+    let ok = Command::new("nix")
+        .args(["store", "gc", "--max", &want.0.to_string()])
+        .status()
+        .is_ok_and(|s| s.success());
+    if ok {
+        let after = sys::fs(Path::new("/nix/store")).map_or(store.free, |s| s.free);
+        out.freed += after.saturating_sub(store.free);
+    } else {
+        out.failed.push("nix store gc failed".into());
+    }
+}

Added file: src/cli.rs+326 additions@@ -0,0 +1,326 @@
+use std::{io, os::unix::net::UnixStream, path::PathBuf};
+
+use pound::Parse;
+
+use crate::{
+    artifacts, client,
+    config::Config,
+    daemon, history, hook, paths,
+    proto::{self, Event, Reader, Request},
+    run,
+    units::{Amount, Bytes, Dur},
+};
+
+/// one build at a time, please
+#[derive(Parse)]
+#[pound(name = "rabt", version = env!("CARGO_PKG_VERSION"))]
+pub enum Rabt {
+    /// wait your turn, then run the thing
+    Run {
+        /// preset from config, s m l xl out of the box
+        #[pound(short, long)]
+        size: Option<String>,
+        #[pound(long)]
+        ram: Option<Bytes>,
+        #[pound(long)]
+        disk: Option<Bytes>,
+        /// count or percentage of the machine
+        #[pound(long)]
+        cores: Option<Amount<u32>>,
+        /// how long you reckon it'll take
+        #[pound(short, long)]
+        time: Option<Dur>,
+        /// kill it past this, exit 124
+        #[pound(long)]
+        deadline: Option<Dur>,
+        /// stop queueing past this, exit 75
+        #[pound(long)]
+        max_wait: Option<Dur>,
+        #[pound(long, hidden, env = "CLAUDE_CODE_SESSION_ID")]
+        session: Option<String>,
+        #[pound(trailing)]
+        cmd: Vec<String>,
+    },
+    /// who's running, who's waiting
+    Status {
+        #[pound(long)]
+        json: bool,
+    },
+    /// a size guess from past runs
+    Suggest {
+        #[pound(trailing)]
+        cmd: Vec<String>,
+    },
+    /// stop a lease's build
+    Kill { lease: u64 },
+    /// buy an overdue build more time
+    Extend { lease: u64, by: Dur },
+    /// exit when a lease goes overdue or finishes
+    Watch { lease: u64 },
+    /// build output and how much of it there is
+    Artifacts {
+        #[pound(subcommand)]
+        action: Artifacts,
+    },
+    /// claude code hook entrypoint, json on stdin
+    Hook {
+        /// pre-tool-use post-tool-use prompt-submit stop subagent-stop
+        event: String,
+    },
+    #[pound(hidden)]
+    Daemon,
+}
+
+#[derive(Parse)]
+pub enum Artifacts {
+    /// sizes against the caps, exits 1 when over
+    Check {
+        /// re-measure instead of trusting the cache
+        #[pound(long)]
+        fresh: bool,
+    },
+    /// everything tracked, biggest first
+    List,
+    /// delete idle artifacts
+    Gc {
+        /// keep going, oldest first, until under the caps
+        #[pound(long)]
+        cap: bool,
+        #[pound(short = 'n', long)]
+        dry_run: bool,
+    },
+    /// never gc this
+    Pin {
+        path: PathBuf,
+    },
+    Unpin {
+        path: PathBuf,
+    },
+}
+
+fn artifacts(cfg: &Config, action: Artifacts) -> i32 {
+    let cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
+    let root = paths::project_root(&cwd);
+    match action {
+        Artifacts::Check { fresh } => {
+            let r = artifacts::check(cfg, Some(&root), fresh);
+            if let Some((root, size)) = &r.project {
+                println!(
+                    "{}: {size} of {}",
+                    root.display(),
+                    cfg.artifacts.project_cap
+                );
+            }
+            println!("everything: {} of {}", r.global, cfg.artifacts.global_cap);
+            if r.over() {
+                println!("over. `rabt artifacts gc --cap`");
+                1
+            } else {
+                0
+            }
+        }
+        Artifacts::List => {
+            let r = artifacts::check(cfg, Some(&root), false);
+            let mut rows: Vec<_> = r.entries.iter().collect();
+            rows.sort_by_key(|(_, e)| std::cmp::Reverse(e.size));
+            for (path, e) in rows {
+                println!(
+                    "{:>10}  {}{}",
+                    e.size.to_string(),
+                    path.display(),
+                    if e.pinned { "  (pinned)" } else { "" }
+                );
+            }
+            0
+        }
+        Artifacts::Gc { cap, dry_run } => {
+            let g = artifacts::gc(cfg, cap, dry_run);
+            for p in &g.removed {
+                println!(
+                    "{}{}",
+                    if dry_run { "would remove " } else { "removed " },
+                    p.display()
+                );
+            }
+            for f in &g.failed {
+                eprintln!("rabt: {f}");
+            }
+            println!(
+                "{} {}",
+                if dry_run { "would free" } else { "freed" },
+                g.freed
+            );
+            i32::from(!g.failed.is_empty())
+        }
+        Artifacts::Pin { path } | Artifacts::Unpin { path } if !path.exists() => {
+            eprintln!("rabt: {} doesn't exist", path.display());
+            1
+        }
+        Artifacts::Pin { path } => report(artifacts::pin(&path, true)),
+        Artifacts::Unpin { path } => report(artifacts::pin(&path, false)),
+    }
+}
+
+fn report(r: Result<(), String>) -> i32 {
+    r.map_or_else(
+        |e| {
+            eprintln!("rabt: {e}");
+            1
+        },
+        |()| 0,
+    )
+}
+
+fn ask(req: &Request) -> io::Result<Option<Event>> {
+    let Some(mut s) = client::connect() else {
+        return Ok(None);
+    };
+    proto::send(&mut s, req)?;
+    Reader::new(&s)?.recv()
+}
+
+fn reply(ev: io::Result<Option<Event>>) -> i32 {
+    match ev {
+        Ok(Some(Event::Ok)) => 0,
+        Ok(Some(Event::Err { msg })) => {
+            eprintln!("rabt: {msg}");
+            1
+        }
+        Ok(None) => {
+            eprintln!("rabt: nothing running");
+            1
+        }
+        Ok(Some(_)) => 1,
+        Err(e) => {
+            eprintln!("rabt: {e}");
+            1
+        }
+    }
+}
+
+fn status(json: bool) -> i32 {
+    let Ok(Some(Event::Status(st))) = ask(&Request::Status) else {
+        if json {
+            println!("null");
+        } else {
+            println!("idle");
+        }
+        return 0;
+    };
+    if json {
+        println!("{}", serde_json::to_string(&st).unwrap_or_default());
+        return 0;
+    }
+    println!(
+        "ram {} free of {}, cores {} free of {}",
+        st.ram_free, st.ram_budget, st.cores_free, st.cores
+    );
+    for l in &st.leases {
+        let state = if l.running {
+            format!(
+                "running {}{}",
+                Dur::secs(l.elapsed),
+                if l.overdue { " OVERDUE" } else { "" }
+            )
+        } else {
+            format!(
+                "#{} {}",
+                l.position,
+                l.waiting.map(|r| r.to_string()).unwrap_or_default()
+            )
+        };
+        println!(
+            "{:>4} {}{} {} ram {} cores {} rss {}  {}",
+            l.id,
+            if l.heavy { "H " } else { "" },
+            state,
+            Dur(l.need.time),
+            l.need.ram,
+            l.need.cores,
+            l.rss,
+            l.cmd.join(" ")
+        );
+    }
+    0
+}
+
+fn suggest(cfg: &Config, cmd: &[String]) -> i32 {
+    let cwd = std::env::current_dir().unwrap_or_else(|_| "/".into());
+    let key = history::key(&paths::project_root(&cwd), cmd);
+    let Some(rec) = history::lookup(&key) else {
+        println!("never seen it, pick a --size");
+        return 1;
+    };
+    let base = match run::base(cfg) {
+        Ok(b) => b,
+        Err(e) => {
+            eprintln!("rabt: {e}");
+            return 2;
+        }
+    };
+    let n = history::suggest(&rec, base, cmd);
+    println!(
+        "--ram {} --cores {} --time {} --disk {}",
+        n.ram,
+        n.cores,
+        Dur(n.time),
+        n.disk
+    );
+    0
+}
+
+fn watch(lease: u64) -> i32 {
+    let Some(mut s): Option<UnixStream> = client::connect() else {
+        return 0;
+    };
+    if proto::send(&mut s, &Request::Watch { lease }).is_err() {
+        return 0;
+    }
+    if matches!(
+        Reader::new(&s).and_then(|mut r| r.recv::<Event>()),
+        Ok(Some(Event::Fired { overdue: true }))
+    ) {
+        println!("lease {lease} is overdue, `rabt kill {lease}` or `rabt extend {lease} <dur>`");
+        3
+    } else {
+        println!("lease {lease} is done");
+        0
+    }
+}
+
+pub fn dispatch(cfg: &Config, cmd: Rabt) -> i32 {
+    match cmd {
+        Rabt::Run {
+            size,
+            ram,
+            disk,
+            cores,
+            time,
+            deadline,
+            max_wait,
+            session,
+            cmd,
+        } => run::run(
+            cfg,
+            &run::Args {
+                size,
+                ram,
+                disk,
+                cores,
+                time,
+                deadline,
+                max_wait,
+                session,
+                cmd,
+            },
+        ),
+        Rabt::Status { json } => status(json),
+        Rabt::Suggest { cmd } => suggest(cfg, &cmd),
+        Rabt::Kill { lease } => reply(ask(&Request::Kill { lease })),
+        Rabt::Extend { lease, by } => reply(ask(&Request::Extend { lease, by })),
+        Rabt::Watch { lease } => watch(lease),
+        Rabt::Artifacts { action } => artifacts(cfg, action),
+        Rabt::Hook { event } => hook::main(cfg, &event),
+        Rabt::Daemon => daemon::main(Config::load().unwrap_or_default()),
+    }
+}

Added file: src/client.rs+92 additions@@ -0,0 +1,92 @@
+use std::{
+    fs::{self, File, OpenOptions},
+    io,
+    os::unix::{fs::OpenOptionsExt, net::UnixStream, process::CommandExt},
+    process::{Command, Stdio},
+    thread,
+    time::Duration,
+};
+
+use crate::paths;
+
+pub struct Flock(File);
+
+impl Flock {
+    pub fn exclusive(file: File) -> io::Result<Self> {
+        use std::os::fd::AsRawFd;
+        if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) } != 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(Self(file))
+    }
+
+    pub fn try_exclusive(file: File) -> Option<Self> {
+        use std::os::fd::AsRawFd;
+        (unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } == 0)
+            .then_some(Self(file))
+    }
+}
+
+impl Drop for Flock {
+    fn drop(&mut self) {
+        use std::os::fd::AsRawFd;
+        unsafe { libc::flock(self.0.as_raw_fd(), libc::LOCK_UN) };
+    }
+}
+
+pub fn spawn_lock() -> io::Result<Flock> {
+    let file = OpenOptions::new()
+        .create(true)
+        .truncate(false)
+        .write(true)
+        .mode(0o600)
+        .open(paths::spawn_lock())?;
+    Flock::exclusive(file)
+}
+
+pub fn connect() -> Option<UnixStream> {
+    UnixStream::connect(paths::socket()).ok()
+}
+
+pub fn connect_or_spawn() -> io::Result<UnixStream> {
+    if let Some(s) = connect() {
+        return Ok(s);
+    }
+    let _lock = spawn_lock()?;
+    if let Some(s) = connect() {
+        return Ok(s);
+    }
+    let _ = fs::remove_file(paths::socket());
+    let log = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(paths::state_dir().join("daemon.log"))?;
+    let mut cmd = Command::new(std::env::current_exe()?);
+    cmd.arg("daemon")
+        .stdin(Stdio::null())
+        .stdout(Stdio::null())
+        .stderr(log);
+    unsafe {
+        cmd.pre_exec(|| {
+            libc::setsid();
+            Ok(())
+        });
+    }
+    let mut child = cmd.spawn()?;
+    for _ in 0..200 {
+        if let Some(s) = connect() {
+            let _ = child.wait();
+            return Ok(s);
+        }
+        if let Ok(Some(status)) = child.try_wait()
+            && !status.success()
+        {
+            return Err(io::Error::other(format!(
+                "daemon died on startup ({status}), see {}",
+                paths::state_dir().join("daemon.log").display()
+            )));
+        }
+        thread::sleep(Duration::from_millis(10));
+    }
+    Err(io::Error::other("daemon never showed up"))
+}

Added file: src/config.rs+380 additions@@ -0,0 +1,380 @@
+use std::{collections::BTreeMap, fs, path::PathBuf};
+
+use serde::Deserialize;
+
+use crate::{
+    paths,
+    units::{Amount, Bytes, Dur},
+};
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Config {
+    pub budget: Budget,
+    pub heavy: Heavy,
+    pub sizes: BTreeMap<String, Preset>,
+    pub queue: Queue,
+    pub overrun: Overrun,
+    pub enforce: Enforce,
+    pub artifacts: Artifacts,
+    pub nix: Nix,
+    pub detect: Detect,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Budget {
+    pub ram: Amount<Bytes>,
+    pub ram_reserve: Bytes,
+    pub cores: Amount<u32>,
+    pub disk_reserve: Bytes,
+    /// every lease's disk estimate is charged to all of these as well as its
+    /// cwd. pessimistic when they share a fs, which is the point
+    pub disk_paths: Vec<PathBuf>,
+    /// memory psi `some avg10`. only gates heavies
+    pub psi_max: Option<f64>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Heavy {
+    pub ram: Bytes,
+    pub cores: Amount<u32>,
+    pub disk: Bytes,
+}
+
+#[derive(Clone, Copy, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Preset {
+    pub ram: Bytes,
+    pub disk: Bytes,
+    pub cores: Amount<u32>,
+    pub time: Dur,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Queue {
+    pub linger: Dur,
+    pub backfill_max_time: Dur,
+    pub max_wait: Option<Dur>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum RamOverrun {
+    Warn,
+    Throttle,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Overrun {
+    pub ram: RamOverrun,
+    /// multiple of the ram estimate
+    pub ram_slack: f64,
+    /// multiple of the time estimate
+    pub time_grace: f64,
+    pub remind_every: Dur,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Unwrapped {
+    Deny,
+    Wrap,
+    Allow,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Enforce {
+    pub unwrapped: Unwrapped,
+    pub default_size: String,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum OverCap {
+    Warn,
+    Block,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StopPolicy {
+    Block,
+    Nudge,
+    Warn,
+    Off,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Rule {
+    /// trailing `*` for a prefix match, that's all the glob you get
+    pub name: String,
+    /// sibling that must exist, so we don't go deleting someone's `build/`
+    /// because it had a suggestive name
+    pub marker: Option<String>,
+    pub clean: Option<Vec<String>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Artifacts {
+    pub project_cap: Bytes,
+    pub global_cap: Bytes,
+    pub idle_after: Dur,
+    pub size_ttl: Dur,
+    pub over_cap: OverCap,
+    pub stop: StopPolicy,
+    pub rules: Vec<Rule>,
+    pub extra_rules: Vec<Rule>,
+    pub nix_gc: bool,
+    pub nix_min_free: Bytes,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Nix {
+    pub inject: bool,
+    pub cores_per_job: u32,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct Detect {
+    pub commands: Vec<String>,
+    pub extra: Vec<String>,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        let preset = |ram, disk, cores: &str, time| Preset {
+            ram,
+            disk,
+            cores: cores.parse().unwrap_or(Amount::Abs(1)),
+            time: Dur::secs(time),
+        };
+        let sizes = BTreeMap::from([
+            (
+                "s".into(),
+                preset(Bytes::mib(512), Bytes::mib(256), "1", 60),
+            ),
+            ("m".into(), preset(Bytes::gib(2), Bytes::gib(1), "4", 300)),
+            ("l".into(), preset(Bytes::gib(6), Bytes::gib(5), "50%", 900)),
+            (
+                "xl".into(),
+                preset(Bytes::gib(12), Bytes::gib(20), "100%", 2700),
+            ),
+        ]);
+        Self {
+            budget: Budget::default(),
+            heavy: Heavy::default(),
+            sizes,
+            queue: Queue::default(),
+            overrun: Overrun::default(),
+            enforce: Enforce::default(),
+            artifacts: Artifacts::default(),
+            nix: Nix::default(),
+            detect: Detect::default(),
+        }
+    }
+}
+
+impl Default for Budget {
+    fn default() -> Self {
+        Self {
+            ram: Amount::Percent(75.0),
+            ram_reserve: Bytes::gib(4),
+            cores: Amount::Percent(100.0),
+            disk_reserve: Bytes::gib(20),
+            disk_paths: vec!["/nix/store".into()],
+            psi_max: Some(40.0),
+        }
+    }
+}
+
+impl Default for Heavy {
+    fn default() -> Self {
+        Self {
+            ram: Bytes::gib(4),
+            cores: Amount::Percent(50.0),
+            disk: Bytes::gib(5),
+        }
+    }
+}
+
+impl Default for Queue {
+    fn default() -> Self {
+        Self {
+            linger: Dur::secs(5),
+            backfill_max_time: Dur::secs(120),
+            max_wait: None,
+        }
+    }
+}
+
+impl Default for Overrun {
+    fn default() -> Self {
+        Self {
+            ram: RamOverrun::Warn,
+            ram_slack: 1.25,
+            time_grace: 1.5,
+            remind_every: Dur::secs(300),
+        }
+    }
+}
+
+impl Default for Enforce {
+    fn default() -> Self {
+        Self {
+            unwrapped: Unwrapped::Deny,
+            default_size: "m".into(),
+        }
+    }
+}
+
+impl Default for Artifacts {
+    fn default() -> Self {
+        let rule = |name: &str, marker: Option<&str>| Rule {
+            name: name.into(),
+            marker: marker.map(Into::into),
+            clean: None,
+        };
+        Self {
+            project_cap: Bytes::gib(10),
+            global_cap: Bytes::gib(60),
+            idle_after: Dur::secs(86_400),
+            size_ttl: Dur::secs(600),
+            over_cap: OverCap::Warn,
+            stop: StopPolicy::Nudge,
+            rules: vec![
+                rule("target", Some("Cargo.toml")),
+                rule("result*", None),
+                rule("node_modules", Some("package.json")),
+                rule("zig-out", Some("build.zig")),
+                rule(".zig-cache", Some("build.zig")),
+                rule("_build", Some("dune-project")),
+                rule("dist-newstyle", Some("cabal.project")),
+            ],
+            extra_rules: Vec::new(),
+            nix_gc: false,
+            nix_min_free: Bytes::gib(30),
+        }
+    }
+}
+
+impl Default for Nix {
+    fn default() -> Self {
+        Self {
+            inject: true,
+            cores_per_job: 4,
+        }
+    }
+}
+
+impl Default for Detect {
+    fn default() -> Self {
+        let commands = [
+            "cargo build",
+            "cargo b",
+            "cargo test",
+            "cargo t",
+            "cargo check",
+            "cargo c",
+            "cargo clippy",
+            "cargo run",
+            "cargo r",
+            "cargo nextest",
+            "cargo bench",
+            "cargo install",
+            "cargo doc",
+            "nix build",
+            "nix flake check",
+            "nix develop",
+            "nix run",
+            "nix shell",
+            "nix-build",
+            "nix-shell",
+            "nixos-rebuild",
+            "home-manager switch",
+            "home-manager build",
+            "make",
+            "gmake",
+            "cmake --build",
+            "ninja",
+            "meson compile",
+            "go build",
+            "go test",
+            "zig build",
+            "dune build",
+            "cabal build",
+            "stack build",
+            "npm run build",
+            "npm test",
+            "npm ci",
+            "npm install",
+            "pnpm build",
+            "pnpm install",
+            "yarn build",
+            "bun run build",
+            "docker build",
+            "podman build",
+            "mvn",
+            "gradle",
+            "./gradlew",
+            "bazel build",
+            "bazel test",
+        ];
+        Self {
+            commands: commands.into_iter().map(Into::into).collect(),
+            extra: Vec::new(),
+        }
+    }
+}
+
+impl Config {
+    pub fn load() -> Result<Self, String> {
+        let path = paths::config_file();
+        match fs::read_to_string(&path) {
+            Ok(text) => Self::parse(&text).map_err(|e| format!("{}: {e}", path.display())),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Self::default()),
+            Err(e) => Err(format!("{}: {e}", path.display())),
+        }
+    }
+
+    pub fn parse(text: &str) -> Result<Self, toml::de::Error> {
+        let mut config: Self = toml::from_str(text)?;
+        for (name, preset) in Self::default().sizes {
+            config.sizes.entry(name).or_insert(preset);
+        }
+        Ok(config)
+    }
+
+    pub fn preset(&self, name: &str) -> Result<Preset, String> {
+        self.sizes.get(name).copied().ok_or_else(|| {
+            let known: Vec<_> = self.sizes.keys().map(String::as_str).collect();
+            format!(
+                "unknown size '{name}', known sizes are {}",
+                known.join(", ")
+            )
+        })
+    }
+
+    pub fn artifact_rules(&self) -> impl Iterator<Item = &Rule> {
+        self.artifacts
+            .rules
+            .iter()
+            .chain(&self.artifacts.extra_rules)
+    }
+
+    pub fn detect_patterns(&self) -> impl Iterator<Item = &str> {
+        self.detect
+            .commands
+            .iter()
+            .chain(&self.detect.extra)
+            .map(String::as_str)
+    }
+}

Added file: src/daemon.rs+526 additions@@ -0,0 +1,526 @@
+use std::{
+    collections::BTreeMap,
+    fs, io,
+    os::unix::net::{UnixListener, UnixStream},
+    path::PathBuf,
+    process,
+    sync::{Arc, Mutex, MutexGuard},
+    thread,
+    time::{Duration, Instant},
+};
+
+use crate::{
+    client,
+    config::Config,
+    paths,
+    proto::{self, Acquire, Event, LeaseId, LeaseInfo, Reader, Request, Status},
+    sched::{self, Capacity, Disk, FsId, Need, Queued, Reason, Running, Verdict},
+    sys,
+    units::Bytes,
+};
+
+struct Run {
+    started: Instant,
+    rss: Bytes,
+    reminded: Option<Instant>,
+}
+
+struct Lease {
+    req: Acquire,
+    heavy: bool,
+    fs: Vec<FsId>,
+    queued_at: Instant,
+    run: Option<Run>,
+    out: UnixStream,
+    waiting: Option<Reason>,
+    last_pos: usize,
+    watchers: Vec<UnixStream>,
+}
+
+impl Lease {
+    fn elapsed(&self) -> Duration {
+        self.run
+            .as_ref()
+            .map_or(self.queued_at, |r| r.started)
+            .elapsed()
+    }
+
+    fn overdue(&self, grace: f64) -> bool {
+        self.run.is_some() && self.elapsed() > self.req.need.time.mul_f64(grace)
+    }
+}
+
+struct State {
+    cfg: Config,
+    next: LeaseId,
+    leases: BTreeMap<LeaseId, Lease>,
+    cap: Capacity,
+    baselines: BTreeMap<FsId, Bytes>,
+    conns: usize,
+    idle_since: Instant,
+}
+
+type Shared = Arc<Mutex<State>>;
+
+fn lock(shared: &Shared) -> MutexGuard<'_, State> {
+    shared
+        .lock()
+        .unwrap_or_else(std::sync::PoisonError::into_inner)
+}
+
+impl State {
+    fn new(cfg: Config) -> Self {
+        let (total, live) = sys::memory();
+        let cap = Capacity {
+            ram_budget: cfg.budget.ram.resolve(total),
+            ram_live: live,
+            ram_reserve: cfg.budget.ram_reserve,
+            cores: cfg.budget.cores.resolve(sys::cores()),
+            disks: BTreeMap::new(),
+            pressure: false,
+        };
+        Self {
+            cfg,
+            next: 1,
+            leases: BTreeMap::new(),
+            cap,
+            baselines: BTreeMap::new(),
+            conns: 0,
+            idle_since: Instant::now(),
+        }
+    }
+
+    fn heavy(&self, need: &Need) -> bool {
+        let h = &self.cfg.heavy;
+        need.ram >= h.ram || need.disk >= h.disk || need.cores >= h.cores.resolve(sys::cores())
+    }
+
+    /// capped at a tenth of the fs, or a 16G tmpfs /tmp with a 20G reserve
+    /// admits nothing ever
+    fn reserve(&self, size: Bytes) -> Bytes {
+        self.cfg.budget.disk_reserve.min(Bytes(size.0 / 10))
+    }
+
+    fn fs_for(&mut self, cwd: &PathBuf) -> Vec<FsId> {
+        let mut ids = Vec::new();
+        for path in std::iter::once(cwd).chain(&self.cfg.budget.disk_paths) {
+            if let Some(fs) = sys::fs(path) {
+                if !ids.contains(&fs.id) {
+                    ids.push(fs.id);
+                }
+                let reserve = self.reserve(fs.size);
+                self.cap.disks.entry(fs.id).or_insert(Disk {
+                    free: fs.free,
+                    reserve,
+                    consumed: Bytes::ZERO,
+                });
+            }
+        }
+        ids
+    }
+
+    fn refresh(&mut self) {
+        let (_, live) = sys::memory();
+        self.cap.ram_live = live;
+        self.cap.pressure = self
+            .cfg
+            .budget
+            .psi_max
+            .is_some_and(|max| sys::pressure().is_some_and(|p| p > max));
+
+        let mut paths: Vec<PathBuf> = self.leases.values().map(|l| l.req.cwd.clone()).collect();
+        paths.extend(self.cfg.budget.disk_paths.iter().cloned());
+        let mut disks = BTreeMap::new();
+        for path in paths {
+            if let Some(fs) = sys::fs(&path) {
+                disks.insert(fs.id, (fs.free, self.reserve(fs.size)));
+            }
+        }
+
+        let busy: Vec<FsId> = self
+            .leases
+            .values()
+            .filter(|l| l.run.is_some())
+            .flat_map(|l| l.fs.iter().copied())
+            .collect();
+        self.baselines.retain(|id, _| busy.contains(id));
+        self.cap.disks = disks
+            .into_iter()
+            .map(|(id, (free, reserve))| {
+                let consumed = if busy.contains(&id) {
+                    self.baselines
+                        .entry(id)
+                        .or_insert(free)
+                        .saturating_sub(free)
+                } else {
+                    Bytes::ZERO
+                };
+                (
+                    id,
+                    Disk {
+                        free,
+                        reserve,
+                        consumed,
+                    },
+                )
+            })
+            .collect();
+    }
+
+    fn running(&self) -> Vec<Running> {
+        self.leases
+            .values()
+            .filter_map(|l| {
+                let run = l.run.as_ref()?;
+                Some(Running {
+                    need: l.req.need,
+                    heavy: l.heavy,
+                    fs: l.fs.clone(),
+                    rss: run.rss,
+                    remaining: l.req.need.time.saturating_sub(run.started.elapsed()),
+                })
+            })
+            .collect()
+    }
+
+    fn reschedule(&mut self) {
+        let queue: Vec<Queued> = self
+            .leases
+            .iter()
+            .filter(|(_, l)| l.run.is_none())
+            .map(|(id, l)| Queued {
+                id: *id,
+                need: l.req.need,
+                heavy: l.heavy,
+                fs: l.fs.clone(),
+            })
+            .collect();
+        if queue.is_empty() {
+            return;
+        }
+        let verdicts = sched::plan(
+            &queue,
+            &self.running(),
+            &self.cap,
+            self.cfg.queue.backfill_max_time.0,
+        );
+        let cores = self.cap.cores;
+        let mut position = 0;
+        for (id, verdict) in verdicts {
+            let Some(lease) = self.leases.get_mut(&id) else {
+                continue;
+            };
+            match verdict {
+                Verdict::Admit => {
+                    lease.run = Some(Run {
+                        started: Instant::now(),
+                        rss: Bytes::ZERO,
+                        reminded: None,
+                    });
+                    let _ = proto::send(
+                        &mut lease.out,
+                        &Event::Granted {
+                            lease: id,
+                            cores: lease.req.need.cores.clamp(1, cores.max(1)),
+                            heavy: lease.heavy,
+                        },
+                    );
+                }
+                Verdict::Wait(reason) => {
+                    position += 1;
+                    lease.waiting = Some(reason);
+                    if lease.last_pos != position {
+                        lease.last_pos = position;
+                        let _ = proto::send(
+                            &mut lease.out,
+                            &Event::Queued {
+                                lease: id,
+                                position,
+                                reason: Some(reason),
+                            },
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    fn remove(&mut self, id: LeaseId) {
+        if let Some(lease) = self.leases.remove(&id) {
+            for mut w in lease.watchers {
+                let _ = proto::send(&mut w, &Event::Fired { overdue: false });
+            }
+        }
+        if self.leases.is_empty() {
+            self.idle_since = Instant::now();
+        }
+        self.refresh();
+        self.reschedule();
+    }
+
+    fn fire_overdue(&mut self) {
+        let grace = self.cfg.overrun.time_grace;
+        for lease in self.leases.values_mut() {
+            if !lease.watchers.is_empty() && lease.overdue(grace) {
+                for mut w in lease.watchers.drain(..) {
+                    let _ = proto::send(&mut w, &Event::Fired { overdue: true });
+                }
+            }
+        }
+    }
+
+    fn info(&self) -> Vec<LeaseInfo> {
+        let grace = self.cfg.overrun.time_grace;
+        let mut position = 0;
+        self.leases
+            .iter()
+            .map(|(id, l)| {
+                if l.run.is_none() {
+                    position += 1;
+                }
+                LeaseInfo {
+                    id: *id,
+                    cmd: l.req.cmd.clone(),
+                    cwd: l.req.cwd.clone(),
+                    session: l.req.session.clone(),
+                    need: l.req.need,
+                    heavy: l.heavy,
+                    running: l.run.is_some(),
+                    elapsed: l.elapsed().as_secs(),
+                    rss: l.run.as_ref().map_or(Bytes::ZERO, |r| r.rss),
+                    overdue: l.overdue(grace),
+                    waiting: l.waiting.filter(|_| l.run.is_none()),
+                    position: if l.run.is_none() { position } else { 0 },
+                }
+            })
+            .collect()
+    }
+
+    fn status(&self) -> Status {
+        let (ram_free, cores_free) = sched::headroom(&self.running(), &self.cap);
+        Status {
+            leases: self.info(),
+            ram_free,
+            ram_budget: self.cap.ram_budget,
+            cores_free,
+            cores: self.cap.cores,
+        }
+    }
+}
+
+fn serve(shared: &Shared, mut stream: UnixStream) -> io::Result<()> {
+    let mut reader = Reader::new(&stream)?;
+    let Some(req) = reader.recv::<Request>()? else {
+        return Ok(());
+    };
+    match req {
+        Request::Acquire(req) => {
+            let id = {
+                let mut st = lock(shared);
+                let id = st.next;
+                st.next += 1;
+                let fs = st.fs_for(&req.cwd);
+                let heavy = st.heavy(&req.need);
+                st.leases.insert(
+                    id,
+                    Lease {
+                        req,
+                        heavy,
+                        fs,
+                        queued_at: Instant::now(),
+                        run: None,
+                        out: stream.try_clone()?,
+                        waiting: None,
+                        last_pos: 0,
+                        watchers: Vec::new(),
+                    },
+                );
+                st.reschedule();
+                id
+            };
+            hold(shared, id, &mut reader);
+            lock(shared).remove(id);
+            Ok(())
+        }
+        Request::Status => {
+            let status = lock(shared).status();
+            proto::send(&mut stream, &Event::Status(status))
+        }
+        Request::Kill { lease } => {
+            let mut st = lock(shared);
+            let reply = match st.leases.get_mut(&lease) {
+                Some(l) => {
+                    let _ = proto::send(&mut l.out, &Event::Kill);
+                    Event::Ok
+                }
+                None => Event::Err {
+                    msg: format!("no lease {lease}"),
+                },
+            };
+            drop(st);
+            proto::send(&mut stream, &reply)
+        }
+        Request::Extend { lease, by } => {
+            let mut st = lock(shared);
+            let reply = match st.leases.get_mut(&lease) {
+                Some(l) => {
+                    l.req.need.time += by.0;
+                    if let Some(run) = &mut l.run {
+                        run.reminded = None;
+                    }
+                    Event::Ok
+                }
+                None => Event::Err {
+                    msg: format!("no lease {lease}"),
+                },
+            };
+            drop(st);
+            proto::send(&mut stream, &reply)
+        }
+        Request::Watch { lease } => {
+            let mut st = lock(shared);
+            let grace = st.cfg.overrun.time_grace;
+            match st.leases.get_mut(&lease) {
+                Some(l) if l.overdue(grace) => {
+                    proto::send(&mut stream, &Event::Fired { overdue: true })
+                }
+                Some(l) => {
+                    l.watchers.push(stream);
+                    Ok(())
+                }
+                None => proto::send(&mut stream, &Event::Fired { overdue: false }),
+            }
+        }
+        Request::Overdue { session } => {
+            let mut st = lock(shared);
+            let grace = st.cfg.overrun.time_grace;
+            let every = st.cfg.overrun.remind_every.0;
+            let mut due = Vec::new();
+            for (id, l) in &mut st.leases {
+                if l.req.session.as_deref() != Some(&session) || !l.overdue(grace) {
+                    continue;
+                }
+                let Some(run) = &mut l.run else { continue };
+                if run.reminded.is_some_and(|t| t.elapsed() < every) {
+                    continue;
+                }
+                run.reminded = Some(Instant::now());
+                due.push(*id);
+            }
+            let leases = st
+                .info()
+                .into_iter()
+                .filter(|i| due.contains(&i.id))
+                .collect();
+            drop(st);
+            proto::send(&mut stream, &Event::Overdue { leases })
+        }
+        Request::Started { .. } | Request::Usage { .. } | Request::Done => proto::send(
+            &mut stream,
+            &Event::Err {
+                msg: "no lease on this connection".into(),
+            },
+        ),
+    }
+}
+
+/// a client that vanishes without saying done got sigkilled or similar, and
+/// pdeathsig only reaches its direct child. take the rest of the group down
+/// so a headless build doesn't keep eating ram off the books
+fn hold(shared: &Shared, id: LeaseId, reader: &mut Reader) {
+    let mut pgid = None;
+    let clean = loop {
+        match reader.recv::<Request>() {
+            Ok(Some(Request::Usage { rss })) => {
+                if let Some(run) = lock(shared)
+                    .leases
+                    .get_mut(&id)
+                    .and_then(|l| l.run.as_mut())
+                {
+                    run.rss = rss;
+                }
+            }
+            Ok(Some(Request::Started { pid })) => pgid = Some(pid),
+            Ok(Some(Request::Done)) => break true,
+            Ok(Some(_)) => {}
+            Ok(None) | Err(_) => break false,
+        }
+    };
+    if !clean && let Some(pgid) = pgid.filter(|p| *p > 1) {
+        unsafe { libc::kill(-pgid, libc::SIGTERM) };
+    }
+}
+
+fn tick(shared: &Shared) {
+    loop {
+        thread::sleep(Duration::from_secs(1));
+        let mut st = lock(shared);
+        st.refresh();
+        st.reschedule();
+        st.fire_overdue();
+        if st.conns == 0 && st.leases.is_empty() && st.idle_since.elapsed() >= st.cfg.queue.linger.0
+        {
+            // a spawner holds this while it clears a stale socket, so taking it
+            // here stops us unlinking our successor's socket on the way out
+            if let Some(_guard) = try_spawn_lock() {
+                let _ = fs::remove_file(paths::socket());
+                process::exit(0);
+            }
+        }
+    }
+}
+
+fn try_spawn_lock() -> Option<client::Flock> {
+    let file = fs::OpenOptions::new()
+        .write(true)
+        .open(paths::spawn_lock())
+        .ok()?;
+    client::Flock::try_exclusive(file)
+}
+
+pub fn main(cfg: Config) -> ! {
+    // fork once more so the client that spawned us can reap its child now
+    // instead of carrying a zombie for the length of its build
+    match unsafe { libc::fork() } {
+        -1 => {
+            eprintln!("roundabout: fork failed: {}", io::Error::last_os_error());
+            process::exit(1);
+        }
+        0 => {}
+        _ => process::exit(0),
+    }
+
+    let listener = match UnixListener::bind(paths::socket()) {
+        Ok(l) => l,
+        Err(e) if e.kind() == io::ErrorKind::AddrInUse && client::connect().is_some() => {
+            process::exit(0)
+        }
+        Err(e) => {
+            eprintln!("roundabout: bind: {e}");
+            process::exit(1);
+        }
+    };
+
+    let shared: Shared = Arc::new(Mutex::new(State::new(cfg)));
+    {
+        let shared = shared.clone();
+        thread::spawn(move || tick(&shared));
+    }
+
+    for stream in listener.incoming() {
+        let Ok(stream) = stream else { continue };
+        lock(&shared).conns += 1;
+        let shared = shared.clone();
+        thread::spawn(move || {
+            if let Err(e) = serve(&shared, stream) {
+                eprintln!("roundabout: {e}");
+            }
+            let mut st = lock(&shared);
+            st.conns -= 1;
+            if st.leases.is_empty() {
+                st.idle_since = Instant::now();
+            }
+        });
+    }
+    process::exit(0)
+}

Added file: src/history.rs+89 additions@@ -0,0 +1,89 @@
+use std::{
+    collections::BTreeMap,
+    path::Path,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{sched::Need, store, units::Bytes};
+
+const KEEP: usize = 1000;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct Record {
+    pub runs: u32,
+    pub peak_rss: Bytes,
+    /// ewma, so one freak run doesn't define the command forever
+    pub wall: u64,
+    pub cpu: u64,
+    pub cores: u32,
+    pub last: u64,
+}
+
+type History = BTreeMap<String, Record>;
+
+pub fn key(root: &Path, cmd: &[String]) -> String {
+    let mut k = format!("{}\t{}", root.display(), cmd.join(" "));
+    k.truncate(k.floor_char_boundary(400));
+    k
+}
+
+fn now() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |d| d.as_secs())
+}
+
+pub fn record(key: String, peak_rss: Bytes, wall: Duration, cpu: Duration, cores: u32) {
+    let _ = store::update("history", |h: &mut History| {
+        let wall = wall.as_secs();
+        h.entry(key)
+            .and_modify(|r| {
+                r.runs += 1;
+                r.peak_rss = r.peak_rss.max(peak_rss);
+                r.wall = (r.wall * 7 + wall * 3) / 10;
+                r.cpu = cpu.as_secs();
+                r.cores = cores;
+                r.last = now();
+            })
+            .or_insert_with(|| Record {
+                runs: 1,
+                peak_rss,
+                wall,
+                cpu: cpu.as_secs(),
+                cores,
+                last: now(),
+            });
+        if h.len() > KEEP {
+            let mut ages: Vec<_> = h.iter().map(|(k, r)| (r.last, k.clone())).collect();
+            ages.sort();
+            for (_, k) in ages.into_iter().take(h.len() - KEEP) {
+                h.remove(&k);
+            }
+        }
+    });
+}
+
+pub fn lookup(key: &str) -> Option<Record> {
+    store::load::<History>("history").get(key).copied()
+}
+
+/// padded, since the agent that under-asks is the one that ooms the video.
+/// nix builds happen in nix-daemon, so their rss never shows up in ours and
+/// the base estimate stands
+pub fn suggest(rec: &Record, base: Need, cmd: &[String]) -> Need {
+    let via_daemon = cmd
+        .iter()
+        .any(|t| t.contains("nix") || t.contains("home-manager"));
+    Need {
+        ram: if via_daemon {
+            base.ram
+        } else {
+            Bytes(rec.peak_rss.0 + rec.peak_rss.0 / 4).max(Bytes::mib(256))
+        },
+        cores: rec.cores.max(1),
+        time: Duration::from_secs((rec.wall * 3 / 2).max(30)),
+        ..base
+    }
+}

Added file: src/hook.rs+319 additions@@ -0,0 +1,319 @@
+use std::{
+    io::{self, Read},
+    path::{Path, PathBuf},
+};
+
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+use crate::{
+    artifacts, client,
+    config::{Config, StopPolicy, Unwrapped},
+    history, paths,
+    proto::{self, Event, LeaseInfo, Reader, Request},
+    units::Dur,
+};
+
+#[derive(Deserialize)]
+struct Input {
+    #[serde(default)]
+    session_id: String,
+    #[serde(default)]
+    cwd: Option<PathBuf>,
+    #[serde(default)]
+    tool_name: Option<String>,
+    #[serde(default, rename = "tool_input")]
+    tool_args: Option<Value>,
+    #[serde(default)]
+    stop_hook_active: bool,
+}
+
+fn read_input() -> Option<Input> {
+    let mut buf = String::new();
+    io::stdin().read_to_string(&mut buf).ok()?;
+    serde_json::from_str(&buf).ok()
+}
+
+fn emit(v: &Value) {
+    println!("{v}");
+}
+
+/// quote-aware split on `&& || ; | & \n`. subshells, heredocs and friends get
+/// treated as words, which errs toward seeing a build that isn't there
+fn segments(cmd: &str) -> Vec<Vec<String>> {
+    let mut out = Vec::new();
+    let mut words = Vec::new();
+    let mut word = String::new();
+    let mut quote: Option<char> = None;
+    let mut chars = cmd.chars().peekable();
+    let flush_word = |word: &mut String, words: &mut Vec<String>| {
+        if !word.is_empty() {
+            words.push(std::mem::take(word));
+        }
+    };
+    while let Some(c) = chars.next() {
+        match (quote, c) {
+            (Some(q), c) if c == q => quote = None,
+            (Some('"') | None, '\\') => {
+                if let Some(n) = chars.next() {
+                    word.push(n);
+                }
+            }
+            (None, '\'' | '"') => quote = Some(c),
+            (None, '&') if word.ends_with('>') || chars.peek() == Some(&'>') => word.push(c),
+            (None, '&' | '|' | ';' | '\n' | '(' | ')') => {
+                flush_word(&mut word, &mut words);
+                if !words.is_empty() {
+                    out.push(std::mem::take(&mut words));
+                }
+            }
+            (None, c) if c.is_whitespace() => flush_word(&mut word, &mut words),
+            (_, c) => word.push(c),
+        }
+    }
+    flush_word(&mut word, &mut words);
+    if !words.is_empty() {
+        out.push(words);
+    }
+    out
+}
+
+/// peels env assignments and wrappers that don't change what runs
+fn head(seg: &[String]) -> &[String] {
+    let mut s = seg;
+    loop {
+        match s.first().map(String::as_str) {
+            Some(w) if w.contains('=') && !w.starts_with('-') && !w.starts_with('=') => s = &s[1..],
+            Some("time" | "nice" | "nohup" | "command" | "exec" | "env" | "sudo" | "doas") => {
+                s = &s[1..];
+            }
+            Some("timeout") => {
+                s = &s[1..];
+                while s.first().is_some_and(|w| w.starts_with('-')) {
+                    s = &s[1..];
+                }
+                s = s.get(1..).unwrap_or_default();
+            }
+            _ => return s,
+        }
+    }
+}
+
+fn is_rabt(word: &str) -> bool {
+    word == "rabt" || word.ends_with("/rabt")
+}
+
+fn matches_pattern(seg: &[String], pattern: &str) -> bool {
+    let want: Vec<&str> = pattern.split_whitespace().collect();
+    let first_ok = |w: &str, p: &str| w == p || w.rsplit('/').next() == Some(p);
+    !want.is_empty()
+        && seg.len() >= want.len()
+        && first_ok(&seg[0], want[0])
+        && seg[1..want.len()]
+            .iter()
+            .zip(&want[1..])
+            .all(|(w, p)| w == p)
+}
+
+enum Scan {
+    Clean,
+    Unwrapped(Vec<String>),
+}
+
+fn scan(cfg: &Config, cmd: &str) -> Scan {
+    let mut found = Vec::new();
+    for seg in segments(cmd) {
+        let seg = head(&seg);
+        if seg.first().is_some_and(|w| is_rabt(w)) {
+            continue;
+        }
+        if cfg.detect_patterns().any(|p| matches_pattern(seg, p)) {
+            let words: Vec<&str> = seg
+                .iter()
+                .map(String::as_str)
+                .take_while(|w| !w.contains('>') && !w.contains('<'))
+                .collect();
+            found.push(words.join(" "));
+        }
+    }
+    if found.is_empty() {
+        Scan::Clean
+    } else {
+        Scan::Unwrapped(found)
+    }
+}
+
+fn guess(cfg: &Config, cwd: &Path, cmd: &[String]) -> String {
+    let key = history::key(&paths::project_root(cwd), cmd);
+    history::lookup(&key).map_or_else(
+        || format!("--size {}", cfg.enforce.default_size),
+        |rec| {
+            crate::run::base(cfg).map_or_else(
+                |_| format!("--size {}", cfg.enforce.default_size),
+                |b| {
+                    let n = history::suggest(&rec, b, cmd);
+                    format!("--ram {} --cores {} --time {}", n.ram, n.cores, Dur(n.time))
+                },
+            )
+        },
+    )
+}
+
+fn shell_quote(s: &str) -> String {
+    format!("'{}'", s.replace('\'', r"'\''"))
+}
+
+fn pre_tool_use(cfg: &Config, input: Input) {
+    if input.tool_name.as_deref() != Some("Bash") {
+        return;
+    }
+    let Some(mut tool_input) = input.tool_args else {
+        return;
+    };
+    let Some(cmd) = tool_input
+        .get("command")
+        .and_then(Value::as_str)
+        .map(str::to_owned)
+    else {
+        return;
+    };
+    let cwd = input.cwd.unwrap_or_else(|| "/".into());
+
+    match (scan(cfg, &cmd), cfg.enforce.unwrapped) {
+        (Scan::Clean, _) | (_, Unwrapped::Allow) => {}
+        (Scan::Unwrapped(found), Unwrapped::Deny) => {
+            let first: Vec<String> = found[0].split_whitespace().map(Into::into).collect();
+            let hint = guess(cfg, &cwd, &first);
+            let reason = format!(
+                "builds go through roundabout here so parallel agents don't oom the box. wrap each build \
+                 in `rabt run <size> -- <cmd>`, e.g. `rabt run {hint} -- {}`. sizes are {}, or \
+                 give --ram/--disk/--cores/--time yourself. for anything long use \
+                 run_in_background and start `rabt watch <lease>` in the background too so you \
+                 hear if it drags. see the roundabout skill",
+                found[0],
+                cfg.sizes.keys().cloned().collect::<Vec<_>>().join("/"),
+            );
+            emit(&json!({
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "permissionDecision": "deny",
+                    "permissionDecisionReason": reason,
+                }
+            }));
+        }
+        (Scan::Unwrapped(_), Unwrapped::Wrap) => {
+            let hint = guess(cfg, &cwd, std::slice::from_ref(&cmd));
+            tool_input["command"] =
+                Value::String(format!("rabt run {hint} -- bash -c {}", shell_quote(&cmd)));
+            // no permissionDecision on purpose. allow would skip the user's
+            // prompt for whatever the agent wrote, rewriting shouldn't
+            emit(&json!({
+                "hookSpecificOutput": {
+                    "hookEventName": "PreToolUse",
+                    "updatedInput": tool_input,
+                }
+            }));
+        }
+    }
+}
+
+fn overdue(session: &str) -> Vec<LeaseInfo> {
+    if session.is_empty() {
+        return Vec::new();
+    }
+    let Some(mut s) = client::connect() else {
+        return Vec::new();
+    };
+    if proto::send(
+        &mut s,
+        &Request::Overdue {
+            session: session.to_owned(),
+        },
+    )
+    .is_err()
+    {
+        return Vec::new();
+    }
+    match Reader::new(&s).and_then(|mut r| r.recv::<Event>()) {
+        Ok(Some(Event::Overdue { leases })) => leases,
+        _ => Vec::new(),
+    }
+}
+
+/// same source `rabt run` reads. after `--continue` the env var can keep the
+/// startup id while the json moves on, and we need both ends to agree
+fn session(input: &Input) -> String {
+    std::env::var("CLAUDE_CODE_SESSION_ID")
+        .ok()
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| input.session_id.clone())
+}
+
+fn remind(event: &str, input: &Input) {
+    let late = overdue(&session(input));
+    if late.is_empty() {
+        return;
+    }
+    let lines: Vec<String> = late
+        .iter()
+        .map(|l| {
+            format!(
+                "roundabout lease {} (`{}`) has run {} against a {} estimate. `rabt kill {}` to stop it, \
+                 `rabt extend {} <dur>` if it's worth the wait",
+                l.id,
+                l.cmd.join(" "),
+                Dur::secs(l.elapsed),
+                Dur(l.need.time),
+                l.id,
+                l.id
+            )
+        })
+        .collect();
+    emit(&json!({
+        "hookSpecificOutput": {
+            "hookEventName": event,
+            "additionalContext": lines.join("\n"),
+        }
+    }));
+}
+
+fn stop(cfg: &Config, event: &str, input: &Input) {
+    if input.stop_hook_active || cfg.artifacts.stop == StopPolicy::Off {
+        return;
+    }
+    let root = input.cwd.as_deref().map(paths::project_root);
+    let report = artifacts::check(cfg, root.as_deref(), false);
+    if !report.over() {
+        return;
+    }
+    let msg = format!(
+        "{}. run `rabt artifacts gc --cap`, or `rabt artifacts list` and clear out what you \
+         don't need",
+        report.describe(cfg)
+    );
+    let out = match cfg.artifacts.stop {
+        StopPolicy::Block => json!({ "decision": "block", "reason": msg }),
+        StopPolicy::Nudge => json!({
+            "hookSpecificOutput": { "hookEventName": event, "additionalContext": msg }
+        }),
+        StopPolicy::Warn => json!({ "systemMessage": msg }),
+        StopPolicy::Off => return,
+    };
+    emit(&out);
+}
+
+/// hooks never fail loudly. a broken roundabout shouldn't wedge the agent
+pub fn main(cfg: &Config, event: &str) -> i32 {
+    let Some(input) = read_input() else {
+        return 0;
+    };
+    match event {
+        "pre-tool-use" => pre_tool_use(cfg, input),
+        "post-tool-use" => remind("PostToolUse", &input),
+        "prompt-submit" => remind("UserPromptSubmit", &input),
+        "stop" => stop(cfg, "Stop", &input),
+        "subagent-stop" => stop(cfg, "SubagentStop", &input),
+        other => eprintln!("rabt: unknown hook {other}"),
+    }
+    0
+}

Added file: src/main.rs+27 additions@@ -0,0 +1,27 @@
+mod artifacts;
+mod cli;
+mod client;
+mod config;
+mod daemon;
+mod history;
+mod hook;
+mod paths;
+mod proto;
+mod run;
+mod sched;
+mod store;
+mod sys;
+mod units;
+
+use pound::Parse;
+
+fn main() {
+    let cfg = match config::Config::load() {
+        Ok(c) => c,
+        Err(e) => {
+            eprintln!("rabt: bad config, {e}");
+            std::process::exit(2);
+        }
+    };
+    std::process::exit(cli::dispatch(&cfg, cli::Rabt::parse()));
+}

Added file: src/paths.rs+83 additions@@ -0,0 +1,83 @@
+use std::{
+    env, fs,
+    os::unix::fs::{DirBuilderExt, PermissionsExt},
+    path::{Path, PathBuf},
+};
+
+fn home() -> PathBuf {
+    env::var_os("HOME").map_or_else(|| PathBuf::from("/"), PathBuf::from)
+}
+
+fn xdg(var: &str, fallback: &str) -> PathBuf {
+    env::var_os(var)
+        .map(PathBuf::from)
+        .filter(|p| p.is_absolute())
+        .unwrap_or_else(|| home().join(fallback))
+}
+
+pub fn config_file() -> PathBuf {
+    env::var_os("ROUNDABOUT_CONFIG").map_or_else(
+        || xdg("XDG_CONFIG_HOME", ".config").join("roundabout/config.toml"),
+        PathBuf::from,
+    )
+}
+
+pub fn state_dir() -> PathBuf {
+    let dir = env::var_os("ROUNDABOUT_STATE_DIR").map_or_else(
+        || xdg("XDG_STATE_HOME", ".local/state").join("roundabout"),
+        PathBuf::from,
+    );
+    let _ = fs::create_dir_all(&dir);
+    dir
+}
+
+pub fn runtime_dir() -> PathBuf {
+    if let Some(dir) = env::var_os("ROUNDABOUT_RUNTIME_DIR") {
+        let dir = PathBuf::from(dir);
+        let _ = fs::DirBuilder::new()
+            .recursive(true)
+            .mode(0o700)
+            .create(&dir);
+        return dir;
+    }
+    if let Some(dir) = env::var_os("XDG_RUNTIME_DIR").map(PathBuf::from)
+        && dir.is_absolute()
+        && dir.is_dir()
+    {
+        return dir;
+    }
+    let uid = unsafe { libc::getuid() };
+    let dir = env::temp_dir().join(format!("roundabout-{uid}"));
+    let _ = fs::DirBuilder::new().mode(0o700).create(&dir);
+    let _ = fs::set_permissions(&dir, fs::Permissions::from_mode(0o700));
+    dir
+}
+
+pub fn socket() -> PathBuf {
+    runtime_dir().join("roundabout.sock")
+}
+
+pub fn spawn_lock() -> PathBuf {
+    runtime_dir().join("roundabout.lock")
+}
+
+pub fn project_root(cwd: &Path) -> PathBuf {
+    const MARKERS: [&str; 6] = [
+        ".jj",
+        ".git",
+        ".hg",
+        "flake.nix",
+        "Cargo.toml",
+        "package.json",
+    ];
+    let mut best = None;
+    for dir in cwd.ancestors() {
+        if dir.join(".jj").exists() || dir.join(".git").exists() || dir.join(".hg").exists() {
+            return dir.to_path_buf();
+        }
+        if best.is_none() && MARKERS.iter().any(|m| dir.join(m).exists()) {
+            best = Some(dir.to_path_buf());
+        }
+    }
+    best.unwrap_or_else(|| cwd.to_path_buf())
+}

Added file: src/proto.rs+115 additions@@ -0,0 +1,115 @@
+use std::{
+    io::{self, BufRead, BufReader, Write},
+    os::unix::net::UnixStream,
+    path::PathBuf,
+};
+
+use serde::{Deserialize, Serialize, de::DeserializeOwned};
+
+use crate::{
+    sched::{Need, Reason},
+    units::{Bytes, Dur},
+};
+
+pub type LeaseId = u64;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Acquire {
+    pub need: Need,
+    pub cwd: PathBuf,
+    pub cmd: Vec<String>,
+    pub session: Option<String>,
+    pub deadline: Option<Dur>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "op", rename_all = "snake_case")]
+pub enum Request {
+    Acquire(Acquire),
+    Started { pid: i32 },
+    Usage { rss: Bytes },
+    Done,
+    Status,
+    Kill { lease: LeaseId },
+    Extend { lease: LeaseId, by: Dur },
+    Watch { lease: LeaseId },
+    Overdue { session: String },
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct LeaseInfo {
+    pub id: LeaseId,
+    pub cmd: Vec<String>,
+    pub cwd: PathBuf,
+    pub session: Option<String>,
+    pub need: Need,
+    pub heavy: bool,
+    pub running: bool,
+    /// seconds since queued or started, whichever it's doing
+    pub elapsed: u64,
+    pub rss: Bytes,
+    pub overdue: bool,
+    pub waiting: Option<Reason>,
+    pub position: usize,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Status {
+    pub leases: Vec<LeaseInfo>,
+    pub ram_free: Bytes,
+    pub ram_budget: Bytes,
+    pub cores_free: u32,
+    pub cores: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "ev", rename_all = "snake_case")]
+pub enum Event {
+    Queued {
+        lease: LeaseId,
+        position: usize,
+        reason: Option<Reason>,
+    },
+    Granted {
+        lease: LeaseId,
+        cores: u32,
+        heavy: bool,
+    },
+    Kill,
+    Status(Status),
+    Overdue {
+        leases: Vec<LeaseInfo>,
+    },
+    Fired {
+        overdue: bool,
+    },
+    Ok,
+    Err {
+        msg: String,
+    },
+}
+
+pub fn send<T: Serialize>(stream: &mut UnixStream, msg: &T) -> io::Result<()> {
+    let mut line = serde_json::to_vec(msg)?;
+    line.push(b'\n');
+    stream.write_all(&line)
+}
+
+pub struct Reader(BufReader<UnixStream>);
+
+impl Reader {
+    pub fn new(stream: &UnixStream) -> io::Result<Self> {
+        Ok(Self(BufReader::new(stream.try_clone()?)))
+    }
+
+    /// `Ok(None)` on eof
+    pub fn recv<T: DeserializeOwned>(&mut self) -> io::Result<Option<T>> {
+        let mut line = String::new();
+        if self.0.read_line(&mut line)? == 0 {
+            return Ok(None);
+        }
+        serde_json::from_str(&line)
+            .map(Some)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+}

Added file: src/run.rs+384 additions@@ -0,0 +1,384 @@
+use std::{
+    env,
+    fmt::Write as _,
+    os::unix::{net::UnixStream, process::CommandExt},
+    process::{Command, ExitStatus},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, AtomicI32, Ordering},
+    },
+    thread,
+    time::{Duration, Instant},
+};
+
+use crate::{
+    artifacts, client,
+    config::{Config, OverCap, RamOverrun},
+    history, paths,
+    proto::{self, Acquire, Event, Reader, Request},
+    sched::Need,
+    sys,
+    units::{Amount, Bytes, Dur},
+};
+
+pub const EXIT_TIMEOUT: i32 = 124;
+pub const EXIT_GAVE_UP: i32 = 75;
+
+pub struct Args {
+    pub size: Option<String>,
+    pub ram: Option<Bytes>,
+    pub disk: Option<Bytes>,
+    pub cores: Option<Amount<u32>>,
+    pub time: Option<Dur>,
+    pub deadline: Option<Dur>,
+    pub max_wait: Option<Dur>,
+    pub session: Option<String>,
+    pub cmd: Vec<String>,
+}
+
+static PGID: AtomicI32 = AtomicI32::new(0);
+
+extern "C" fn forward(sig: libc::c_int) {
+    let pgid = PGID.load(Ordering::Relaxed);
+    if pgid > 1 {
+        unsafe { libc::kill(-pgid, sig) };
+    }
+}
+
+fn say(msg: &str) {
+    eprintln!("rabt: {msg}");
+}
+
+fn need(cfg: &Config, a: &Args) -> Result<Need, String> {
+    let base = cfg.preset(a.size.as_deref().unwrap_or(&cfg.enforce.default_size))?;
+    Ok(Need {
+        ram: a.ram.unwrap_or(base.ram),
+        disk: a.disk.unwrap_or(base.disk),
+        cores: a.cores.unwrap_or(base.cores).resolve(sys::cores()),
+        time: a.time.unwrap_or(base.time).0,
+    })
+}
+
+pub fn base(cfg: &Config) -> Result<Need, String> {
+    let p = cfg.preset(&cfg.enforce.default_size)?;
+    Ok(Need {
+        ram: p.ram,
+        disk: p.disk,
+        cores: p.cores.resolve(sys::cores()),
+        time: p.time.0,
+    })
+}
+
+struct Grant {
+    stream: UnixStream,
+    lease: u64,
+    cores: u32,
+}
+
+fn acquire(req: &Acquire, max_wait: Option<Dur>) -> Result<Grant, i32> {
+    let started = Instant::now();
+    // a daemon on its way out can accept us then hang up, so go round again
+    for _ in 0..3 {
+        let mut stream = client::connect_or_spawn().map_err(|e| {
+            say(&format!("can't reach the daemon: {e}"));
+            1
+        })?;
+        if proto::send(&mut stream, &Request::Acquire(req.clone())).is_err() {
+            continue;
+        }
+        let _ = stream.set_read_timeout(Some(Duration::from_secs(1)));
+        let mut reader = Reader::new(&stream).map_err(|_| 1)?;
+        loop {
+            match reader.recv::<Event>() {
+                Ok(Some(Event::Granted {
+                    lease,
+                    cores,
+                    heavy,
+                })) => {
+                    say(&format!(
+                        "lease {lease} go, cores {cores}{}",
+                        if heavy { ", heavy" } else { "" }
+                    ));
+                    let _ = stream.set_read_timeout(None);
+                    return Ok(Grant {
+                        stream,
+                        lease,
+                        cores,
+                    });
+                }
+                Ok(Some(Event::Queued {
+                    lease,
+                    position,
+                    reason,
+                })) => {
+                    let why = reason.map(|r| format!(", {r}")).unwrap_or_default();
+                    say(&format!("lease {lease} queued at #{position}{why}"));
+                }
+                Ok(Some(Event::Kill)) => {
+                    say("killed while queued");
+                    return Err(143);
+                }
+                Ok(Some(_)) => {}
+                Err(e)
+                    if matches!(
+                        e.kind(),
+                        std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
+                    ) =>
+                {
+                    if max_wait.is_some_and(|m| started.elapsed() > m.0) {
+                        say("gave up waiting");
+                        return Err(EXIT_GAVE_UP);
+                    }
+                }
+                Ok(None) | Err(_) => break,
+            }
+        }
+    }
+    say("daemon keeps hanging up");
+    Err(1)
+}
+
+fn has_systemd_run() -> bool {
+    env::var_os("PATH")
+        .is_some_and(|p| env::split_paths(&p).any(|d| d.join("systemd-run").exists()))
+}
+
+fn command(cfg: &Config, a: &Args, need: &Need, grant: &Grant) -> Command {
+    let mut argv = a.cmd.clone();
+    if cfg.overrun.ram == RamOverrun::Throttle && cfg!(target_os = "linux") && has_systemd_run() {
+        let high = Bytes((need.ram.0 as f64 * cfg.overrun.ram_slack) as u64);
+        let mut wrapped: Vec<String> = [
+            "systemd-run",
+            "--user",
+            "--scope",
+            "--quiet",
+            "--collect",
+            "-p",
+        ]
+        .map(Into::into)
+        .into();
+        wrapped.push(format!("MemoryHigh={}", high.0));
+        wrapped.push("--".into());
+        wrapped.append(&mut argv);
+        argv = wrapped;
+    }
+
+    let n = grant.cores.to_string();
+    let mut cmd = Command::new(&argv[0]);
+    cmd.args(&argv[1..])
+        .process_group(0)
+        .env("ROUNDABOUT_LEASE", grant.lease.to_string())
+        .env("CARGO_BUILD_JOBS", &n)
+        .env("CMAKE_BUILD_PARALLEL_LEVEL", &n);
+
+    let make = env::var("MAKEFLAGS").unwrap_or_default();
+    if !make.contains("-j") {
+        cmd.env("MAKEFLAGS", format!("-j{n} {make}").trim_end());
+    }
+
+    if cfg.nix.inject {
+        let per = cfg.nix.cores_per_job.max(1);
+        let jobs = (grant.cores / per).max(1);
+        let cores = grant.cores.min(per);
+        let mut nix = env::var("NIX_CONFIG").unwrap_or_default();
+        let _ = write!(nix, "\ncores = {cores}\nmax-jobs = {jobs}\n");
+        cmd.env("NIX_CONFIG", nix);
+    }
+
+    #[cfg(target_os = "linux")]
+    unsafe {
+        cmd.pre_exec(|| {
+            libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM);
+            Ok(())
+        });
+    }
+    cmd
+}
+
+fn cpu_time() -> Duration {
+    let mut ru = std::mem::MaybeUninit::<libc::rusage>::uninit();
+    unsafe {
+        if libc::getrusage(libc::RUSAGE_CHILDREN, ru.as_mut_ptr()) != 0 {
+            return Duration::ZERO;
+        }
+        let ru = ru.assume_init();
+        let tv = |t: libc::timeval| {
+            Duration::from_secs(t.tv_sec as u64) + Duration::from_micros(t.tv_usec as u64)
+        };
+        tv(ru.ru_utime) + tv(ru.ru_stime)
+    }
+}
+
+fn code(status: ExitStatus) -> i32 {
+    use std::os::unix::process::ExitStatusExt;
+    status
+        .code()
+        .or_else(|| status.signal().map(|s| 128 + s))
+        .unwrap_or(1)
+}
+
+pub fn run(cfg: &Config, a: &Args) -> i32 {
+    if a.cmd.is_empty() {
+        say("nothing to run, put the command after --");
+        return 2;
+    }
+    if a.size.is_none() && a.ram.is_none() {
+        let sizes: Vec<_> = cfg.sizes.keys().map(String::as_str).collect();
+        say(&format!(
+            "how big is it? pass --size {} or --ram and friends. `rabt suggest -- <cmd>` has a guess",
+            sizes.join("|")
+        ));
+        return 2;
+    }
+    let need = match need(cfg, a) {
+        Ok(n) => n,
+        Err(e) => {
+            say(&e);
+            return 2;
+        }
+    };
+    let cwd = env::current_dir().unwrap_or_else(|_| "/".into());
+    let root = paths::project_root(&cwd);
+
+    let report = artifacts::check(cfg, Some(&root), false);
+    if report.over() {
+        let msg = report.describe(cfg);
+        if cfg.artifacts.over_cap == OverCap::Block {
+            say(&format!("{msg}. clean up first, `rabt artifacts gc --cap`"));
+            return EXIT_GAVE_UP;
+        }
+        say(&format!(
+            "{msg}. `rabt artifacts gc --cap` when you get a sec"
+        ));
+    }
+
+    let req = Acquire {
+        need,
+        cwd,
+        cmd: a.cmd.clone(),
+        session: a.session.clone(),
+        deadline: a.deadline,
+    };
+
+    let grant = match acquire(&req, a.max_wait.or(cfg.queue.max_wait)) {
+        Ok(g) => g,
+        Err(code) => return code,
+    };
+
+    let mut child = match command(cfg, a, &need, &grant).spawn() {
+        Ok(c) => c,
+        Err(e) => {
+            say(&format!("couldn't start {}: {e}", a.cmd[0]));
+            return 127;
+        }
+    };
+    let pgid = i32::try_from(child.id()).expect("pid fits in pid_t");
+    PGID.store(pgid, Ordering::Relaxed);
+    for sig in [libc::SIGINT, libc::SIGTERM, libc::SIGHUP] {
+        unsafe { libc::signal(sig, forward as *const () as libc::sighandler_t) };
+    }
+
+    let mut out = grant.stream.try_clone().ok();
+    if let Some(s) = &mut out {
+        let _ = proto::send(s, &Request::Started { pid: pgid });
+    }
+
+    let killed = Arc::new(AtomicBool::new(false));
+    if let Ok(mut reader) = Reader::new(&grant.stream) {
+        let killed = killed.clone();
+        thread::spawn(move || {
+            while let Ok(Some(ev)) = reader.recv::<Event>() {
+                if matches!(ev, Event::Kill) {
+                    killed.store(true, Ordering::Relaxed);
+                }
+            }
+        });
+    }
+
+    let started = Instant::now();
+    let grace = need.time.mul_f64(cfg.overrun.time_grace);
+    let loud_ram = Bytes((need.ram.0 as f64 * cfg.overrun.ram_slack) as u64);
+    let mut peak = Bytes::ZERO;
+    let mut last_sample: Option<Instant> = None;
+    let mut term_sent: Option<Instant> = None;
+    let mut timed_out = false;
+    let mut warned_ram = false;
+    let mut warned_time = false;
+
+    let status = loop {
+        match child.try_wait() {
+            Ok(Some(status)) => break status,
+            Ok(None) => {}
+            Err(e) => {
+                say(&format!("lost track of the child: {e}"));
+                return 1;
+            }
+        }
+        let elapsed = started.elapsed();
+
+        if term_sent.is_none() {
+            if killed.load(Ordering::Relaxed) {
+                say("killed on request");
+                term_sent = Some(Instant::now());
+            } else if a.deadline.is_some_and(|d| elapsed > d.0) {
+                say("deadline hit, killing it");
+                timed_out = true;
+                term_sent = Some(Instant::now());
+            }
+            if term_sent.is_some() {
+                unsafe { libc::kill(-pgid, libc::SIGTERM) };
+            }
+        } else if term_sent.is_some_and(|t| t.elapsed() > Duration::from_secs(10)) {
+            unsafe { libc::kill(-pgid, libc::SIGKILL) };
+        }
+
+        if last_sample.is_none_or(|t| t.elapsed() >= Duration::from_secs(2)) {
+            last_sample = Some(Instant::now());
+            let rss = sys::group_rss(pgid);
+            peak = peak.max(rss);
+            if let Some(s) = &mut out {
+                let _ = proto::send(s, &Request::Usage { rss });
+            }
+            if !warned_ram && rss > loud_ram {
+                warned_ram = true;
+                say(&format!("using {rss} against a {} estimate", need.ram));
+            }
+        }
+        if !warned_time && elapsed > grace {
+            warned_time = true;
+            say(&format!(
+                "{} past its {} estimate and still going",
+                Dur(elapsed),
+                Dur(need.time)
+            ));
+        }
+        thread::sleep(Duration::from_millis(250));
+    };
+
+    let wall = started.elapsed();
+    if let Some(s) = &mut out {
+        let _ = proto::send(s, &Request::Done);
+    }
+    history::record(
+        history::key(&root, &a.cmd),
+        peak,
+        wall,
+        cpu_time(),
+        grant.cores,
+    );
+    artifacts::register(cfg, &root, true);
+    if peak > loud_ram || wall > grace {
+        say(&format!(
+            "took {} and peaked at {}, asked for {} and {}. ask for more next time",
+            Dur(wall),
+            peak,
+            Dur(need.time),
+            need.ram
+        ));
+    }
+    if timed_out {
+        EXIT_TIMEOUT
+    } else {
+        code(status)
+    }
+}

Added file: src/sched.rs+353 additions@@ -0,0 +1,353 @@
+//! fifo with easy backfill. the first job that can't start gets a reservation,
+//! and anyone behind it only cuts in if they'll be gone before it starts or fit
+//! in the leftovers once it does
+
+use std::{collections::BTreeMap, time::Duration};
+
+use serde::{Deserialize, Serialize};
+
+use crate::units::Bytes;
+
+pub type JobId = u64;
+pub type FsId = u64;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Need {
+    pub ram: Bytes,
+    pub disk: Bytes,
+    pub cores: u32,
+    pub time: Duration,
+}
+
+#[derive(Clone, Debug)]
+pub struct Queued {
+    pub id: JobId,
+    pub need: Need,
+    pub heavy: bool,
+    pub fs: Vec<FsId>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Running {
+    pub need: Need,
+    pub heavy: bool,
+    pub fs: Vec<FsId>,
+    pub rss: Bytes,
+    /// zero once overdue
+    pub remaining: Duration,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Disk {
+    pub free: Bytes,
+    pub reserve: Bytes,
+    /// written since the fs last went from idle to busy. free space already
+    /// reflects this, so it's netted off promises to avoid counting it twice
+    pub consumed: Bytes,
+}
+
+#[derive(Clone, Debug)]
+pub struct Capacity {
+    pub ram_budget: Bytes,
+    pub ram_live: Bytes,
+    pub ram_reserve: Bytes,
+    pub cores: u32,
+    pub disks: BTreeMap<FsId, Disk>,
+    pub pressure: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", tag = "reason", content = "fs")]
+pub enum Reason {
+    HeavyRunning,
+    Pressure,
+    Ram,
+    Cores,
+    Disk(FsId),
+    Reserved,
+}
+
+impl std::fmt::Display for Reason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::HeavyRunning => "another heavy build is running",
+            Self::Pressure => "memory pressure is high",
+            Self::Ram => "not enough free RAM",
+            Self::Cores => "not enough free cores",
+            Self::Disk(_) => "not enough free disk",
+            Self::Reserved => "waiting behind a reserved build",
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Verdict {
+    Admit,
+    Wait(Reason),
+}
+
+#[derive(Clone, Debug)]
+struct Free {
+    ram: Bytes,
+    cores: u32,
+    disk: BTreeMap<FsId, Bytes>,
+    heavy_slot: bool,
+}
+
+impl Free {
+    fn shortfall(&self, need: &Need, fs: &[FsId], heavy: bool) -> Option<Reason> {
+        if heavy && !self.heavy_slot {
+            return Some(Reason::HeavyRunning);
+        }
+        if need.ram > self.ram {
+            return Some(Reason::Ram);
+        }
+        if need.cores > self.cores {
+            return Some(Reason::Cores);
+        }
+        fs.iter()
+            .find(|id| self.disk.get(id).is_some_and(|free| need.disk > *free))
+            .map(|id| Reason::Disk(*id))
+    }
+
+    fn take(&mut self, need: &Need, fs: &[FsId], heavy: bool) {
+        self.ram = self.ram.saturating_sub(need.ram);
+        self.cores = self.cores.saturating_sub(need.cores);
+        for id in fs {
+            if let Some(free) = self.disk.get_mut(id) {
+                *free = free.saturating_sub(need.disk);
+            }
+        }
+        if heavy {
+            self.heavy_slot = false;
+        }
+    }
+
+    /// no disk here. builds leave their output behind when they finish
+    fn give_back(&mut self, ram: Bytes, cores: u32, heavy: bool) {
+        self.ram += ram;
+        self.cores += cores;
+        if heavy {
+            self.heavy_slot = true;
+        }
+    }
+}
+
+fn clamp(need: Need, cap: &Capacity) -> Need {
+    Need {
+        ram: need.ram.min(cap.ram_budget),
+        cores: need.cores.clamp(1, cap.cores.max(1)),
+        ..need
+    }
+}
+
+fn free_now(running: &[Running], cap: &Capacity) -> Free {
+    let charged: Bytes = running.iter().map(|r| r.need.ram.max(r.rss)).sum();
+    let unrealised: Bytes = running
+        .iter()
+        .map(|r| r.need.ram.saturating_sub(r.rss))
+        .sum();
+    let by_budget = cap.ram_budget.saturating_sub(charged);
+    let by_live = cap
+        .ram_live
+        .saturating_sub(cap.ram_reserve)
+        .saturating_sub(unrealised);
+
+    let disk = cap
+        .disks
+        .iter()
+        .map(|(id, d)| {
+            let promised: Bytes = running
+                .iter()
+                .filter(|r| r.fs.contains(id))
+                .map(|r| r.need.disk)
+                .sum();
+            let outstanding = promised.saturating_sub(d.consumed);
+            (
+                *id,
+                d.free.saturating_sub(d.reserve).saturating_sub(outstanding),
+            )
+        })
+        .collect();
+
+    Free {
+        ram: by_budget.min(by_live),
+        cores: cap
+            .cores
+            .saturating_sub(running.iter().map(|r| r.need.cores).sum()),
+        disk,
+        heavy_slot: !running.iter().any(|r| r.heavy),
+    }
+}
+
+pub fn headroom(running: &[Running], cap: &Capacity) -> (Bytes, u32) {
+    let free = free_now(running, cap);
+    (free.ram, free.cores)
+}
+
+struct Reservation {
+    /// `None` when nothing finishing would free enough, e.g. disk or someone
+    /// else's ram. backfill falls back to the time cap then
+    shadow: Option<Duration>,
+    extra: Option<Free>,
+}
+
+fn reserve(
+    job: &Queued,
+    need: &Need,
+    free: &Free,
+    ends: &[(Duration, Bytes, u32, bool)],
+) -> Reservation {
+    let mut sim = free.clone();
+    let mut ends = ends.to_vec();
+    ends.sort_by_key(|e| e.0);
+    for (at, ram, cores, heavy) in ends {
+        sim.give_back(ram, cores, heavy);
+        if sim.shortfall(need, &job.fs, job.heavy).is_none() {
+            sim.take(need, &job.fs, job.heavy);
+            return Reservation {
+                shadow: Some(at),
+                extra: Some(sim),
+            };
+        }
+    }
+    Reservation {
+        shadow: None,
+        extra: None,
+    }
+}
+
+pub fn plan(
+    queue: &[Queued],
+    running: &[Running],
+    cap: &Capacity,
+    backfill_max: Duration,
+) -> Vec<(JobId, Verdict)> {
+    let mut free = free_now(running, cap);
+    let mut ends: Vec<_> = running
+        .iter()
+        .map(|r| (r.remaining, r.need.ram.max(r.rss), r.need.cores, r.heavy))
+        .collect();
+    let mut reservation: Option<Reservation> = None;
+    let mut out = Vec::with_capacity(queue.len());
+
+    for job in queue {
+        let need = clamp(job.need, cap);
+
+        if job.heavy && cap.pressure {
+            out.push((job.id, Verdict::Wait(Reason::Pressure)));
+            continue;
+        }
+
+        if let Some(why) = free.shortfall(&need, &job.fs, job.heavy) {
+            if reservation.is_none() {
+                reservation = Some(reserve(job, &need, &free, &ends));
+            }
+            out.push((job.id, Verdict::Wait(why)));
+            continue;
+        }
+
+        if let Some(res) = &mut reservation {
+            let finishes_first = match res.shadow {
+                Some(shadow) => need.time <= shadow,
+                None => need.time <= backfill_max,
+            };
+            let fits_extra = res
+                .extra
+                .as_ref()
+                .is_some_and(|x| x.shortfall(&need, &job.fs, job.heavy).is_none());
+            if !finishes_first && !fits_extra {
+                out.push((job.id, Verdict::Wait(Reason::Reserved)));
+                continue;
+            }
+            if !finishes_first && let Some(extra) = &mut res.extra {
+                extra.take(&need, &job.fs, job.heavy);
+            }
+        }
+
+        free.take(&need, &job.fs, job.heavy);
+        ends.push((need.time, need.ram, need.cores, job.heavy));
+        out.push((job.id, Verdict::Admit));
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const FS: FsId = 1;
+
+    fn need(ram_gib: u64, cores: u32, disk_gib: u64, mins: u64) -> Need {
+        Need {
+            ram: Bytes::gib(ram_gib),
+            disk: Bytes::gib(disk_gib),
+            cores,
+            time: Duration::from_secs(mins * 60),
+        }
+    }
+
+    fn q(id: JobId, need: Need, heavy: bool) -> Queued {
+        Queued {
+            id,
+            need,
+            heavy,
+            fs: vec![FS],
+        }
+    }
+
+    fn cap() -> Capacity {
+        Capacity {
+            ram_budget: Bytes::gib(24),
+            ram_live: Bytes::gib(28),
+            ram_reserve: Bytes::gib(4),
+            cores: 16,
+            disks: BTreeMap::from([(
+                FS,
+                Disk {
+                    free: Bytes::gib(100),
+                    reserve: Bytes::gib(20),
+                    consumed: Bytes::ZERO,
+                },
+            )]),
+            pressure: false,
+        }
+    }
+
+    fn verdicts(plan: &[(JobId, Verdict)]) -> Vec<Verdict> {
+        plan.iter().map(|(_, v)| *v).collect()
+    }
+
+    const BF: Duration = Duration::from_secs(120);
+
+    #[test]
+    fn two_heavies_never_collide() {
+        let out = plan(
+            &[q(1, need(8, 8, 5, 10), true), q(2, need(8, 4, 5, 10), true)],
+            &[],
+            &cap(),
+            BF,
+        );
+        assert_eq!(
+            verdicts(&out),
+            [Verdict::Admit, Verdict::Wait(Reason::HeavyRunning)]
+        );
+    }
+
+    #[test]
+    fn disk_never_double_booked() {
+        let out = plan(
+            &[
+                q(1, need(1, 1, 50, 10), false),
+                q(2, need(1, 1, 50, 10), false),
+            ],
+            &[],
+            &cap(),
+            BF,
+        );
+        assert_eq!(
+            verdicts(&out),
+            [Verdict::Admit, Verdict::Wait(Reason::Disk(FS))]
+        );
+    }
+}

Added file: src/store.rs+35 additions@@ -0,0 +1,35 @@
+use std::{fs, io, path::PathBuf};
+
+use serde::{Serialize, de::DeserializeOwned};
+
+use crate::{client::Flock, paths};
+
+fn path(name: &str) -> PathBuf {
+    paths::state_dir().join(format!("{name}.json"))
+}
+
+pub fn load<T: DeserializeOwned + Default>(name: &str) -> T {
+    fs::read(path(name))
+        .ok()
+        .and_then(|b| serde_json::from_slice(&b).ok())
+        .unwrap_or_default()
+}
+
+/// readers skip the lock, the rename keeps them from seeing half a file
+pub fn update<T, R>(name: &str, f: impl FnOnce(&mut T) -> R) -> io::Result<R>
+where
+    T: Serialize + DeserializeOwned + Default,
+{
+    let lock = fs::OpenOptions::new()
+        .create(true)
+        .truncate(false)
+        .write(true)
+        .open(paths::state_dir().join(format!("{name}.lock")))?;
+    let _guard = Flock::exclusive(lock)?;
+    let mut value = load(name);
+    let out = f(&mut value);
+    let tmp = path(&format!("{name}.tmp"));
+    fs::write(&tmp, serde_json::to_vec(&value)?)?;
+    fs::rename(tmp, path(name))?;
+    Ok(out)
+}

Added file: src/sys.rs+163 additions@@ -0,0 +1,163 @@
+use std::{ffi::CString, os::unix::ffi::OsStrExt, path::Path};
+
+use crate::{sched::FsId, units::Bytes};
+
+pub fn cores() -> u32 {
+    std::thread::available_parallelism().map_or(1, |n| n.get() as u32)
+}
+
+pub struct FsStat {
+    pub id: FsId,
+    pub free: Bytes,
+    pub size: Bytes,
+}
+
+pub fn fs(path: &Path) -> Option<FsStat> {
+    let c = CString::new(path.as_os_str().as_bytes()).ok()?;
+    let mut vfs = std::mem::MaybeUninit::<libc::statvfs>::uninit();
+    let mut st = std::mem::MaybeUninit::<libc::stat>::uninit();
+    unsafe {
+        if libc::statvfs(c.as_ptr(), vfs.as_mut_ptr()) != 0
+            || libc::stat(c.as_ptr(), st.as_mut_ptr()) != 0
+        {
+            return None;
+        }
+        let vfs = vfs.assume_init();
+        let st = st.assume_init();
+        #[allow(clippy::unnecessary_cast)]
+        let block = vfs.f_frsize as u64;
+        #[allow(clippy::unnecessary_cast)]
+        Some(FsStat {
+            id: st.st_dev as u64,
+            free: Bytes(vfs.f_bavail as u64 * block),
+            size: Bytes(vfs.f_blocks as u64 * block),
+        })
+    }
+}
+
+pub fn page_size() -> u64 {
+    unsafe { libc::sysconf(libc::_SC_PAGESIZE) as u64 }
+}
+
+#[cfg(target_os = "linux")]
+mod imp {
+    use std::fs;
+
+    use crate::units::Bytes;
+
+    pub fn memory() -> (Bytes, Bytes) {
+        let text = fs::read_to_string("/proc/meminfo").unwrap_or_default();
+        let field = |name: &str| {
+            text.lines()
+                .find_map(|l| l.strip_prefix(name))
+                .and_then(|rest| {
+                    rest.trim()
+                        .trim_end_matches("kB")
+                        .trim()
+                        .parse::<u64>()
+                        .ok()
+                })
+                .map_or(Bytes::ZERO, |kib| Bytes(kib * 1024))
+        };
+        (field("MemTotal:"), field("MemAvailable:"))
+    }
+
+    pub fn pressure() -> Option<f64> {
+        let text = fs::read_to_string("/proc/pressure/memory").ok()?;
+        text.lines()
+            .find(|l| l.starts_with("some"))?
+            .split_whitespace()
+            .find_map(|kv| kv.strip_prefix("avg10="))?
+            .parse()
+            .ok()
+    }
+
+    pub fn group_rss(pgid: i32) -> Bytes {
+        let page = super::page_size();
+        let Ok(dir) = fs::read_dir("/proc") else {
+            return Bytes::ZERO;
+        };
+        let mut total = 0;
+        for entry in dir.flatten() {
+            let name = entry.file_name();
+            if !name.as_encoded_bytes().iter().all(u8::is_ascii_digit) {
+                continue;
+            }
+            let Ok(stat) = fs::read_to_string(entry.path().join("stat")) else {
+                continue;
+            };
+            // comm can hold spaces and parens, fields only make sense after the last ')'
+            let Some(tail) = stat.rsplit_once(')').map(|(_, t)| t) else {
+                continue;
+            };
+            let fields: Vec<&str> = tail.split_whitespace().collect();
+            let pgrp = fields.get(2).and_then(|f| f.parse::<i32>().ok());
+            let rss = fields.get(21).and_then(|f| f.parse::<u64>().ok());
+            if pgrp == Some(pgid) {
+                total += rss.unwrap_or(0) * page;
+            }
+        }
+        Bytes(total)
+    }
+}
+
+#[cfg(target_os = "macos")]
+mod imp {
+    use std::process::Command;
+
+    use crate::units::Bytes;
+
+    pub fn memory() -> (Bytes, Bytes) {
+        let mut total: u64 = 0;
+        let mut len = std::mem::size_of::<u64>();
+        unsafe {
+            libc::sysctlbyname(
+                c"hw.memsize".as_ptr(),
+                (&raw mut total).cast(),
+                &raw mut len,
+                std::ptr::null_mut(),
+                0,
+            );
+        }
+        // vm_stat over mach calls, libc's mach bindings are deprecated and this
+        // runs once a second at most
+        let out = Command::new("vm_stat")
+            .output()
+            .map(|o| o.stdout)
+            .unwrap_or_default();
+        let text = String::from_utf8_lossy(&out);
+        let pages = |name: &str| {
+            text.lines()
+                .find_map(|l| l.strip_prefix(name))
+                .and_then(|r| r.trim().trim_end_matches('.').parse::<u64>().ok())
+                .unwrap_or(0)
+        };
+        let avail = (pages("Pages free:") + pages("Pages inactive:") + pages("Pages purgeable:"))
+            * super::page_size();
+        (Bytes(total), Bytes(avail))
+    }
+
+    pub const fn pressure() -> Option<f64> {
+        None
+    }
+
+    pub fn group_rss(pgid: i32) -> Bytes {
+        let out = Command::new("ps")
+            .args(["-A", "-o", "pgid=,rss="])
+            .output()
+            .map(|o| o.stdout)
+            .unwrap_or_default();
+        let kib: u64 = String::from_utf8_lossy(&out)
+            .lines()
+            .filter_map(|l| {
+                let mut f = l.split_whitespace();
+                let g = f.next()?.parse::<i32>().ok()?;
+                let rss = f.next()?.parse::<u64>().ok()?;
+                (g == pgid).then_some(rss)
+            })
+            .sum();
+        Bytes(kib * 1024)
+    }
+}
+
+pub use imp::{group_rss, memory, pressure};

Added file: src/units.rs+301 additions@@ -0,0 +1,301 @@
+use std::{fmt, str::FromStr, time::Duration};
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
+
+const KIB: u64 = 1024;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Bytes(pub u64);
+
+impl Bytes {
+    pub const ZERO: Self = Self(0);
+
+    pub const fn gib(n: u64) -> Self {
+        Self(n * KIB * KIB * KIB)
+    }
+
+    pub const fn mib(n: u64) -> Self {
+        Self(n * KIB * KIB)
+    }
+
+    pub const fn saturating_sub(self, other: Self) -> Self {
+        Self(self.0.saturating_sub(other.0))
+    }
+}
+
+impl std::ops::Add for Bytes {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self(self.0.saturating_add(other.0))
+    }
+}
+
+impl std::ops::AddAssign for Bytes {
+    fn add_assign(&mut self, other: Self) {
+        *self = *self + other;
+    }
+}
+
+impl std::iter::Sum for Bytes {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(Self::ZERO, |a, b| a + b)
+    }
+}
+
+fn split_number(s: &str) -> Result<(f64, &str), &'static str> {
+    let s = s.trim();
+    let end = s
+        .find(|c: char| !(c.is_ascii_digit() || c == '.'))
+        .unwrap_or(s.len());
+    let (num, suffix) = s.split_at(end);
+    let num = num.parse::<f64>().map_err(|_| "expected a number")?;
+    if !num.is_finite() || num < 0.0 {
+        return Err("expected a non-negative number");
+    }
+    Ok((num, suffix.trim()))
+}
+
+impl FromStr for Bytes {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (num, suffix) = split_number(s)?;
+        let scale = match suffix.to_ascii_lowercase().as_str() {
+            "" | "b" => 1,
+            "k" | "kb" | "kib" => KIB,
+            "m" | "mb" | "mib" => KIB.pow(2),
+            "g" | "gb" | "gib" => KIB.pow(3),
+            "t" | "tb" | "tib" => KIB.pow(4),
+            _ => return Err("expected a size like 512M or 4GiB"),
+        };
+        Ok(Self((num * scale as f64) as u64))
+    }
+}
+
+impl fmt::Display for Bytes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
+        let mut value = self.0 as f64;
+        let mut unit = 0;
+        while value >= 1024.0 && unit < UNITS.len() - 1 {
+            value /= 1024.0;
+            unit += 1;
+        }
+        if unit == 0 {
+            write!(f, "{}B", self.0)
+        } else {
+            write!(f, "{value:.1}{}", UNITS[unit])
+        }
+    }
+}
+
+impl pound::FromArg for Bytes {
+    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {
+        s.parse().map_err(|e| pound::ValueError::new(s, e))
+    }
+}
+
+impl Serialize for Bytes {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.serialize_u64(self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for Bytes {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        struct V;
+        impl de::Visitor<'_> for V {
+            type Value = Bytes;
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("a byte count or a size string like \"4GiB\"")
+            }
+
+            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Bytes, E> {
+                Ok(Bytes(v))
+            }
+
+            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Bytes, E> {
+                u64::try_from(v)
+                    .map(Bytes)
+                    .map_err(|_| E::custom("negative size"))
+            }
+
+            fn visit_str<E: de::Error>(self, v: &str) -> Result<Bytes, E> {
+                v.parse().map_err(E::custom)
+            }
+        }
+        d.deserialize_any(V)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Dur(pub Duration);
+
+impl Dur {
+    pub const fn secs(n: u64) -> Self {
+        Self(Duration::from_secs(n))
+    }
+}
+
+impl FromStr for Dur {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut rest = s.trim();
+        if rest.is_empty() {
+            return Err("expected a duration like 90s or 5m");
+        }
+        let mut total = 0.0;
+        while !rest.is_empty() {
+            let (num, tail) = split_number(rest)?;
+            let unit_len = tail
+                .find(|c: char| c.is_ascii_digit() || c == '.')
+                .unwrap_or(tail.len());
+            let (unit, next) = tail.split_at(unit_len);
+            let scale = match unit.trim() {
+                "" | "s" | "sec" | "secs" => 1.0,
+                "ms" => 0.001,
+                "m" | "min" | "mins" => 60.0,
+                "h" | "hr" | "hrs" => 3600.0,
+                "d" | "day" | "days" => 86400.0,
+                _ => return Err("expected a duration like 90s or 5m"),
+            };
+            total = num.mul_add(scale, total);
+            rest = next.trim();
+        }
+        Ok(Self(Duration::from_secs_f64(total)))
+    }
+}
+
+impl fmt::Display for Dur {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let s = self.0.as_secs();
+        match s {
+            0..60 => write!(f, "{s}s"),
+            60..3600 if s.is_multiple_of(60) => write!(f, "{}m", s / 60),
+            60..3600 => write!(f, "{}m{}s", s / 60, s % 60),
+            _ if s.is_multiple_of(3600) => write!(f, "{}h", s / 3600),
+            _ => write!(f, "{}h{}m", s / 3600, (s % 3600) / 60),
+        }
+    }
+}
+
+impl pound::FromArg for Dur {
+    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {
+        s.parse().map_err(|e| pound::ValueError::new(s, e))
+    }
+}
+
+impl Serialize for Dur {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.serialize_u64(self.0.as_secs())
+    }
+}
+
+impl<'de> Deserialize<'de> for Dur {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        struct V;
+        impl de::Visitor<'_> for V {
+            type Value = Dur;
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("seconds or a duration string like \"5m\"")
+            }
+
+            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Dur, E> {
+                Ok(Dur::secs(v))
+            }
+
+            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Dur, E> {
+                u64::try_from(v)
+                    .map(Dur::secs)
+                    .map_err(|_| E::custom("negative duration"))
+            }
+
+            fn visit_str<E: de::Error>(self, v: &str) -> Result<Dur, E> {
+                v.parse().map_err(E::custom)
+            }
+        }
+        d.deserialize_any(V)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Amount<T> {
+    Abs(T),
+    Percent(f64),
+}
+
+impl Amount<Bytes> {
+    pub fn resolve(self, total: Bytes) -> Bytes {
+        match self {
+            Self::Abs(b) => b,
+            Self::Percent(p) => Bytes((total.0 as f64 * p / 100.0) as u64),
+        }
+    }
+}
+
+impl Amount<u32> {
+    pub fn resolve(self, total: u32) -> u32 {
+        match self {
+            Self::Abs(n) => n,
+            Self::Percent(p) => ((f64::from(total) * p / 100.0).round() as u32).max(1),
+        }
+    }
+}
+
+impl<T: FromStr> FromStr for Amount<T> {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(p) = s.trim().strip_suffix('%') {
+            let p = p
+                .trim()
+                .parse::<f64>()
+                .map_err(|_| "expected a percentage")?;
+            if !(0.0..=100.0).contains(&p) {
+                return Err("percentage must be between 0 and 100");
+            }
+            Ok(Self::Percent(p))
+        } else {
+            s.trim()
+                .parse()
+                .map(Self::Abs)
+                .map_err(|_| "expected an amount or a percentage")
+        }
+    }
+}
+
+impl<T: FromStr> pound::FromArg for Amount<T> {
+    fn from_arg(s: &str) -> Result<Self, pound::ValueError> {
+        s.parse().map_err(|e| pound::ValueError::new(s, e))
+    }
+}
+
+impl<'de, T: FromStr> Deserialize<'de> for Amount<T> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        struct V<T>(std::marker::PhantomData<T>);
+        impl<T: FromStr> de::Visitor<'_> for V<T> {
+            type Value = Amount<T>;
+
+            fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str("an amount or a percentage string like \"75%\"")
+            }
+
+            fn visit_u64<E: de::Error>(self, v: u64) -> Result<Amount<T>, E> {
+                self.visit_str(&v.to_string())
+            }
+
+            fn visit_i64<E: de::Error>(self, v: i64) -> Result<Amount<T>, E> {
+                self.visit_str(&v.to_string())
+            }
+
+            fn visit_str<E: de::Error>(self, v: &str) -> Result<Amount<T>, E> {
+                v.parse().map_err(E::custom)
+            }
+        }
+        d.deserialize_any(V(std::marker::PhantomData))
+    }
+}

roundabout

Commit 6f5b84fad3ef

Commit `6f5b84fad3ef`