roundabout

public

Star0

Fork 0

Watch0

13 commits 1 branch 0 tags 0 releases158.8 KiB

Commit `fdad58f8133a`

tarball

atagen <boss@atagen.co>2026-10-25 23:16 UTC

16 files changed+84-84

treewide: rename rabt to roundabout

Modified file: Cargo.toml+1−1

@@ -8,7 +8,7 @@ license = "EUPL-1.2"

88 rust-version = "1.91"

1010 [[bin]]

11-name = "rabt"

11+name = "roundabout"

1212 path = "src/main.rs"

1313

1414 [dependencies]

Modified file: README.md+17 additions−17 deletions@@ -6,27 +6,27 @@ agents say roughly how big a build is. a tiny daemon, started on demand and gone
 
 ## use
 
-the cli is `rabt`, short enough that agents don't mind typing it
+the cli is `roundabout`, short enough that agents don't mind typing it
 
 ```
-rabt run --size m -- cargo build
-rabt run --ram 6G --cores 8 --time 10m -- nix build .#thing
-rabt status
-rabt suggest -- cargo build --release
-rabt expect --size l   # building soon, save me a seat
-rabt watch 7        # exits when lease 7 is done or overdue
-rabt kill 7
-rabt extend 7 10m
-rabt artifacts check | list | gc [--cap] [--project] | pin <path>
+roundabout run --size m -- cargo build
+roundabout run --ram 6G --cores 8 --time 10m -- nix build .#thing
+roundabout status
+roundabout suggest -- cargo build --release
+roundabout expect --size l   # building soon, save me a seat
+roundabout watch 7        # exits when lease 7 is done or overdue
+roundabout kill 7
+roundabout extend 7 10m
+roundabout artifacts check | list | gc [--cap] [--project] | pin <path>
 ```
 
 `run` exits with the build's code, 124 if `--deadline` killed it, 75 if `--max-wait` ran out.
 
 a granted build gets `CARGO_BUILD_JOBS`, `MAKEFLAGS`, `CMAKE_BUILD_PARALLEL_LEVEL` and a `NIX_CONFIG` with `cores`/`max-jobs` to match its grant.
 
-on linux, `rabt` creates a transient scope through the systemd user manager's D-Bus `StartTransientUnit` method. the command waits until its scope is active, then runs with its original environment and terminal I/O. `CPUQuotaPerSecUSec` caps CPU time at the granted core count, and `MemoryMax` caps the whole build at its granted RAM multiplied by `overrun.ram_slack`, with at least the granted RAM available. these limits cover descendants too, even when a tool ignores the job-count environment variables. linux requires a running systemd user manager and user bus, a failed scope refuses the build rather than running it without limits. other platforms retain the job-count environment variables without cgroup enforcement.
+on linux, `roundabout` creates a transient scope through the systemd user manager's D-Bus `StartTransientUnit` method. the command waits until its scope is active, then runs with its original environment and terminal I/O. `CPUQuotaPerSecUSec` caps CPU time at the granted core count, and `MemoryMax` caps the whole build at its granted RAM multiplied by `overrun.ram_slack`, with at least the granted RAM available. these limits cover descendants too, even when a tool ignores the job-count environment variables. linux requires a running systemd user manager and user bus, a failed scope refuses the build rather than running it without limits. other platforms retain the job-count environment variables without cgroup enforcement.
 
-the grant can be bigger than the ask. idle cores go to whoever's building, minus what other sessions have said they'll want via `rabt expect`. spare cores never hold up admission, oversubscribing cpu only slows things down, but each one is charged ram at the build's own ram per core since more jobs eat more memory. a session's build counts as an `expect` too, so agents that forget still leave a mark. `--exact` opts out.
+the grant can be bigger than the ask. idle cores go to whoever's building, minus what other sessions have said they'll want via `roundabout expect`. spare cores never hold up admission, oversubscribing cpu only slows things down, but each one is charged ram at the build's own ram per core since more jobs eat more memory. a session's build counts as an `expect` too, so agents that forget still leave a mark. `--exact` opts out.
 
 ## claude code
 
@@ -46,7 +46,7 @@ programs.roundabout.settings.budget.ram = "16GiB";   # lands in /etc/roundabout/
 
 that installs roundabout and a socket-activated systemd user unit for the daemon (`socketActivation = false` to let clients spawn it instead). `programs.roundabout.claude` has read-only `hooks`, `skill` and `plugin` for whatever writes your claude config, e.g. `settings.hooks = config.programs.roundabout.claude.hooks`.
 
-the plugin brings a skill and hooks. unwrapped builds get bounced back with instructions, overdue builds get mentioned to the agent that started them, and agents over their artifact cap get told to tidy up before they stop. `rabt` needs to be on PATH for the agent too, so install `.#roundabout` alongside.
+the plugin brings a skill and hooks. unwrapped builds get bounced back with instructions, overdue builds get mentioned to the agent that started them, and agents over their artifact cap get told to tidy up before they stop. `roundabout` needs to be on PATH for the agent too, so install `.#roundabout` alongside.
 
 ## codex
 
@@ -56,9 +56,9 @@ codex plugin marketplace add ./result
 codex plugin add roundabout@roundabout
 ```
 
-restart codex and review the plugin hooks with `/hooks` before using them. install `.#roundabout` as well so `rabt run` and `rabt expect` are on PATH. codex can also load the hooks directly from `~/.codex/hooks.json` or a trusted project's `.codex/hooks.json` using the `hooks` object in `result/plugins/roundabout/hooks/hooks.json`. use one installation route to avoid duplicate reminders.
+restart codex and review the plugin hooks with `/hooks` before using them. install `.#roundabout` as well so `roundabout run` and `roundabout expect` are on PATH. codex can also load the hooks directly from `~/.codex/hooks.json` or a trusted project's `.codex/hooks.json` using the `hooks` object in `result/plugins/roundabout/hooks/hooks.json`. use one installation route to avoid duplicate reminders.
 
-on nixos, `programs.roundabout.codex` exposes read-only `hooks`, `skill` and `plugin`, alongside the claude options. the codex hooks deny unwrapped builds and suggest `rabt run` instead of silently rewriting the command, which keeps the normal tool approval flow intact even when `enforce.unwrapped` is set to `wrap`. `rabt run` and `rabt expect` associate builds with the current codex session, and session-end hooks release its expectation.
+on nixos, `programs.roundabout.codex` exposes read-only `hooks`, `skill` and `plugin`, alongside the claude options. the codex hooks deny unwrapped builds and suggest `roundabout run` instead of silently rewriting the command, which keeps the normal tool approval flow intact even when `enforce.unwrapped` is set to `wrap`. `roundabout run` and `roundabout expect` associate builds with the current codex session, and session-end hooks release its expectation.
 
 ## omp
 
@@ -67,7 +67,7 @@ nix build .#omp-plugin
 omp plugin link ./result
 ```
 
-restart omp after linking. install `.#roundabout` on PATH for the agent's bash tool, or set `ROUNDABOUT_CLI` to the `rabt` binary for the extension. the plugin bundles the skill and checks shell builds before they run. it also delivers overdue reminders, checks artifact caps before the main agent stops, and releases expectations when a session closes or switches. wrapped builds and `rabt expect` inherit the omp session id through the bash tool's environment. on nixos, `programs.roundabout.omp` exposes read-only `plugin` and `skill` options.
+restart omp after linking. install `.#roundabout` on PATH for the agent's bash tool, or set `ROUNDABOUT_CLI` to the `roundabout` binary for the extension. the plugin bundles the skill and checks shell builds before they run. it also delivers overdue reminders, checks artifact caps before the main agent stops, and releases expectations when a session closes or switches. wrapped builds and `roundabout expect` inherit the omp session id through the bash tool's environment. on nixos, `programs.roundabout.omp` exposes read-only `plugin` and `skill` options.
 
 ## config
 
@@ -98,7 +98,7 @@ linger = "5s"
 backfill_max_time = "2m"
 # max_wait = "30m"
 elastic = true         # hand idle cores to whoever's building
-intent_ttl = "20m"     # how long a `rabt expect` or a build keeps its claim
+intent_ttl = "20m"     # how long a `roundabout expect` or a build keeps its claim
 
 [overrun]
 ram = "warn"           # or "throttle", MemoryHigh at granted RAM on linux

Modified file: nix/omp-plugin.nix+1−1

@@ -9,5 +9,5 @@ runCommand "roundabout-omp-plugin-${roundabout.version}" { } ''

99 cp ${../plugin/omp/package.json} $out/package.json

1010 cp ${../plugin/omp/index.js} $out/index.js

1111 cp -r ${../plugin/skills}/. $out/skills/

12- ln -s ${lib.getExe roundabout} $out/bin/rabt

12+ ln -s ${lib.getExe roundabout} $out/bin/roundabout

1313 ''

Modified file: nix/omp-tests.nix+1−1

@@ -17,7 +17,7 @@ let

1717 };

1818 mockCli = writeScript "roundabout-test-cli" ''

1919 #!${lib.getExe nushell} --stdin

20- ${builtins.readFile ../tests/mock-rabt.nu}

20+ ${builtins.readFile ../tests/mock-roundabout.nu}

2121 '';

2222 in

2323 runCommand "roundabout-omp-tests"

Modified file: nix/package.nix+1−1

@@ -18,7 +18,7 @@ rustPlatform.buildRustPackage {

1818

1919 meta = {

2020 description = "build admission for agents that can't share";

21- mainProgram = "rabt";

21+ mainProgram = "roundabout";

2222 license = lib.licenses.eupl12;

2323 platforms = lib.platforms.unix;

2424 };

Modified file: nix/plugin.nix+1−1

@@ -42,5 +42,5 @@ runCommand "roundabout-plugin-${roundabout.version}" { } ''

4242 cp ${plugin} $p/.claude-plugin/plugin.json

4343 cp ${hooks} $p/hooks/hooks.json

4444 cp -r ${../plugin/skills}/. $p/skills/

45- ln -s ${lib.getExe roundabout} $p/bin/rabt

45+ ln -s ${lib.getExe roundabout} $p/bin/roundabout

4646 ''

Modified file: plugin/omp/index.js+2 additions−2 deletions@@ -2,10 +2,10 @@ import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-const packagedCli = fileURLToPath(new URL("./bin/rabt", import.meta.url));
+const packagedCli = fileURLToPath(new URL("./bin/roundabout", import.meta.url));
 
 function cli() {
-  return process.env.ROUNDABOUT_CLI || (existsSync(packagedCli) ? packagedCli : "rabt");
+  return process.env.ROUNDABOUT_CLI || (existsSync(packagedCli) ? packagedCli : "roundabout");
 }
 
 function invoke(event, context, input = {}) {

Modified file: plugin/skills/roundabout/SKILL.md+15 additions−15 deletions@@ -5,26 +5,26 @@ description: use before running any build, test suite or other heavy command (ca
 
 # roundabout
 
-this box is shared with other agents and a human who'd like their video to keep playing. builds queue through roundabout, whose cli is `rabt`, and only run when there's room.
+this box is shared with other agents and a human who'd like their video to keep playing. builds queue through roundabout, whose cli is `roundabout`, and only run when there's room.
 
 ## first, say you're coming
 
 when you pick up a task that'll involve building, before you start editing
 
 ```
-rabt expect --size m
+roundabout expect --size m
 ```
 
-sized like the biggest build you expect to run. idle cores get handed out to whoever's building, and this is how the others know to leave you some. it lapses 20 minutes after your last build or `expect`, so one call covers an edit-compile loop. `rabt expect --done` if the plan changes.
+sized like the biggest build you expect to run. idle cores get handed out to whoever's building, and this is how the others know to leave you some. it lapses 20 minutes after your last build or `expect`, so one call covers an edit-compile loop. `roundabout expect --done` if the plan changes.
 
 ## running something
 
 ```
-rabt run --size m -- cargo build
-rabt run --ram 6G --cores 8 --time 10m --disk 4G -- nix build .#thing
+roundabout run --size m -- cargo build
+roundabout run --ram 6G --cores 8 --time 10m --disk 4G -- nix build .#thing
 ```
 
-wrap the build, not the whole pipeline. `cd x && rabt run -s m -- cargo test 2>&1 | tail` is fine.
+wrap the build, not the whole pipeline. `cd x && roundabout run -s m -- cargo test 2>&1 | tail` is fine.
 
 sizes out of the box
 
@@ -35,7 +35,7 @@ sizes out of the box
 | l | 6G | 5G | half | 15m | release builds, big workspaces, nix closures |
 | xl | 12G | 20G | all | 45m | rebuilding the world |
 
-`rabt suggest -- <cmd>` has numbers from previous runs of that command in this project. use them.
+`roundabout suggest -- <cmd>` has numbers from previous runs of that command in this project. use them.
 
 guess honestly. under-asking is how the box ooms, and an honest `--time` is what lets small jobs slip past big ones. it tells you afterwards if you were off.
 
@@ -46,12 +46,12 @@ you may get more cores than you asked for when the box is quiet, `CARGO_BUILD_JO
 a queued build prints its place and why to stderr. for anything likely over a couple of minutes
 
 1. run the build with `run_in_background`
-2. read the lease id from `rabt: lease N go`
-3. also start `rabt watch N` with `run_in_background`. it exits when the build finishes or goes overdue, which wakes you up
+2. read the lease id from `roundabout: lease N go`
+3. also start `roundabout watch N` with `run_in_background`. it exits when the build finishes or goes overdue, which wakes you up
 
-in codex, use `exec_command` with a short `yield_time_ms` for the build, then poll its `session_id` with `write_stdin`. use another `exec_command` for `rabt watch N` if the build is likely to take longer. don't launch the build a second time while polling.
+in codex, use `exec_command` with a short `yield_time_ms` for the build, then poll its `session_id` with `write_stdin`. use another `exec_command` for `roundabout watch N` if the build is likely to take longer. don't launch the build a second time while polling.
 
-in omp, use the bash tool's `async` option for the build and `omp ps` to follow its output. use another bash call for `rabt watch N` if you need an overdue reminder.
+in omp, use the bash tool's `async` option for the build and `omp ps` to follow its output. use another bash call for `roundabout watch N` if you need an overdue reminder.
 
 `--max-wait 10m` gives up queueing after that (exit 75). `--deadline 30m` kills the build if it's still going (exit 124). only use a deadline when a late result is useless.
 
@@ -59,14 +59,14 @@ in omp, use the bash tool's `async` option for the build and `omp ps` to follow 
 
 you'll get told when a build is well past its time estimate. decide, don't ignore it
 
-- `rabt kill N` if it's stuck or not worth it
-- `rabt extend N 15m` if it's making progress
+- `roundabout kill N` if it's stuck or not worth it
+- `roundabout extend N 15m` if it's making progress
 
-`rabt status` shows everything running and queued.
+`roundabout status` shows everything running and queued.
 
 ## artifacts
 
-build output is capped per project and in total. `rabt artifacts check` compares, `list` shows the offenders, `gc` clears idle stuff, `gc --cap` keeps going until under, `--project` leaves everyone else's stuff alone. `pin <path>` protects something you need.
+build output is capped per project and in total. `roundabout artifacts check` compares, `list` shows the offenders, `gc` clears idle stuff, `gc --cap` keeps going until under, `--project` leaves everyone else's stuff alone. `pin <path>` protects something you need.
 
 if told you're over, clean up before you finish. scratch dirs full of `target/` and `result` links count too.
 

Modified file: src/artifacts.rs+2 additions−2 deletions@@ -178,9 +178,9 @@ impl Report {
 
     pub const fn remedy(&self) -> &'static str {
         if self.over_global {
-            "rabt artifacts gc --cap"
+            "roundabout artifacts gc --cap"
         } else {
-            "rabt artifacts gc --project --cap"
+            "roundabout artifacts gc --project --cap"
         }
     }
 

Modified file: src/cli.rs+13 additions−13 deletions@@ -13,7 +13,7 @@ use crate::{
 
 /// one build at a time, please
 #[derive(Parse)]
-#[pound(name = "rabt", version = env!("CARGO_PKG_VERSION"))]
+#[pound(name = "roundabout", version = env!("CARGO_PKG_VERSION"))]
 pub enum Rabt {
     /// wait your turn, then run the thing
     Run {
@@ -167,7 +167,7 @@ fn artifacts(cfg: &Config, action: Artifacts) -> i32 {
                 );
             }
             for f in &g.failed {
-                eprintln!("rabt: {f}");
+                eprintln!("roundabout: {f}");
             }
             println!(
                 "{} {}",
@@ -177,7 +177,7 @@ fn artifacts(cfg: &Config, action: Artifacts) -> i32 {
             i32::from(!g.failed.is_empty())
         }
         Artifacts::Pin { path } | Artifacts::Unpin { path } if !path.exists() => {
-            eprintln!("rabt: {} doesn't exist", path.display());
+            eprintln!("roundabout: {} doesn't exist", path.display());
             1
         }
         Artifacts::Pin { path } => report(artifacts::pin(&path, true)),
@@ -188,7 +188,7 @@ fn artifacts(cfg: &Config, action: Artifacts) -> i32 {
 fn report(r: Result<(), String>) -> i32 {
     r.map_or_else(
         |e| {
-            eprintln!("rabt: {e}");
+            eprintln!("roundabout: {e}");
             1
         },
         |()| 0,
@@ -207,16 +207,16 @@ fn reply(ev: io::Result<Option<Event>>) -> i32 {
     match ev {
         Ok(Some(Event::Ok)) => 0,
         Ok(Some(Event::Err { msg })) => {
-            eprintln!("rabt: {msg}");
+            eprintln!("roundabout: {msg}");
             1
         }
         Ok(None) => {
-            eprintln!("rabt: nothing running");
+            eprintln!("roundabout: nothing running");
             1
         }
         Ok(Some(_)) => 1,
         Err(e) => {
-            eprintln!("rabt: {e}");
+            eprintln!("roundabout: {e}");
             1
         }
     }
@@ -237,7 +237,7 @@ fn agent_session(session: Option<String>) -> Option<String> {
 
 fn expect(cfg: &Config, session: Option<String>, done: bool, a: &run::Args) -> i32 {
     let Some(session) = session.filter(|s| !s.is_empty()) else {
-        eprintln!("rabt: no agent session id, use --session to name one");
+        eprintln!("roundabout: no agent session id, use --session to name one");
         return 2;
     };
     let need = if done {
@@ -246,7 +246,7 @@ fn expect(cfg: &Config, session: Option<String>, done: bool, a: &run::Args) -> i
         match run::need(cfg, a) {
             Ok(n) => Some(n),
             Err(e) => {
-                eprintln!("rabt: {e}");
+                eprintln!("roundabout: {e}");
                 return 2;
             }
         }
@@ -254,12 +254,12 @@ fn expect(cfg: &Config, session: Option<String>, done: bool, a: &run::Args) -> i
     let mut s = match client::connect_or_spawn() {
         Ok(s) => s,
         Err(e) => {
-            eprintln!("rabt: can't reach the daemon: {e}");
+            eprintln!("roundabout: can't reach the daemon: {e}");
             return 1;
         }
     };
     if let Err(e) = proto::send(&mut s, &Request::Expect { session, need }) {
-        eprintln!("rabt: {e}");
+        eprintln!("roundabout: {e}");
         return 1;
     }
     reply(Reader::new(&s).and_then(|mut r| r.recv()))
@@ -335,7 +335,7 @@ fn suggest(cfg: &Config, cmd: &[String]) -> i32 {
     let base = match run::base(cfg) {
         Ok(b) => b,
         Err(e) => {
-            eprintln!("rabt: {e}");
+            eprintln!("roundabout: {e}");
             return 2;
         }
     };
@@ -361,7 +361,7 @@ fn watch(lease: u64) -> i32 {
         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>`");
+        println!("lease {lease} is overdue, `roundabout kill {lease}` or `roundabout extend {lease} <dur>`");
         3
     } else {
         println!("lease {lease} is done");

Modified file: src/hook.rs+14 additions−14 deletions@@ -99,8 +99,8 @@ fn head(seg: &[String]) -> &[String] {
     }
 }
 
-fn is_rabt(word: &str) -> bool {
-    word == "rabt" || word.ends_with("/rabt")
+fn is_roundabout(word: &str) -> bool {
+    word == "roundabout" || word.ends_with("/roundabout")
 }
 
 fn matches_pattern(seg: &[String], pattern: &str) -> bool {
@@ -124,7 +124,7 @@ 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)) {
+        if seg.first().is_some_and(|w| is_roundabout(w)) {
             continue;
         }
         if cfg.detect_patterns().any(|p| matches_pattern(seg, p)) {
@@ -186,9 +186,9 @@ fn pre_tool_use(cfg: &Config, input: Input) {
             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 \
+                 in `roundabout run <size> -- <cmd>`, e.g. `roundabout 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 \
+                 run_in_background and start `roundabout 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("/"),
@@ -204,7 +204,7 @@ fn pre_tool_use(cfg: &Config, input: Input) {
         (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)));
+                Value::String(format!("roundabout 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!({
@@ -232,7 +232,7 @@ fn codex_pre_tool_use(cfg: &Config, input: Input) -> Option<Value> {
     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. run `rabt run {hint} -- {}` instead. see the roundabout skill",
+        "builds go through roundabout here so parallel agents don't oom the box. run `roundabout run {hint} -- {}` instead. see the roundabout skill",
         found[0]
     );
     Some(json!({
@@ -267,7 +267,7 @@ fn overdue(session: &str) -> Vec<LeaseInfo> {
     }
 }
 
-/// same source `rabt run` reads. after `--continue` the env var can keep the
+/// same source `roundabout 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, codex: bool) -> String {
     if codex {
@@ -307,8 +307,8 @@ fn remind(event: &str, input: &Input, codex: bool) {
         .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",
+                "roundabout lease {} (`{}`) has run {} against a {} estimate. `roundabout kill {}` to stop it, \
+                 `roundabout extend {} <dur>` if it's worth the wait",
                 l.id,
                 l.cmd.join(" "),
                 Dur::secs(l.elapsed),
@@ -336,7 +336,7 @@ fn stop(cfg: &Config, event: &str, input: &Input) {
         return;
     }
     let msg = format!(
-        "{}. run `{}`, or `rabt artifacts list` and clear out what you don't need",
+        "{}. run `{}`, or `roundabout artifacts list` and clear out what you don't need",
         report.describe(cfg),
         report.remedy()
     );
@@ -373,7 +373,7 @@ pub fn main(cfg: &Config, event: &str) -> i32 {
         "post-tool-use" => remind("PostToolUse", &input, false),
         "prompt-submit" => remind("UserPromptSubmit", &input, false),
         "session-end" => session_end(&input, false),
-        other => eprintln!("rabt: unknown hook {other}"),
+        other => eprintln!("roundabout: unknown hook {other}"),
     }
     0
 }
@@ -400,7 +400,7 @@ mod tests {
             output["hookSpecificOutput"]["permissionDecisionReason"]
                 .as_str()
                 .unwrap()
-                .contains("rabt run")
+                .contains("roundabout run")
         );
     }
 
@@ -416,7 +416,7 @@ mod tests {
     #[test]
     fn codex_ignores_other_tools_and_wrapped_builds() {
         assert!(
-            codex_pre_tool_use(&Config::default(), bash("rabt run -s m -- cargo build")).is_none()
+            codex_pre_tool_use(&Config::default(), bash("roundabout run -s m -- cargo build")).is_none()
         );
         let mut input = bash("cargo build");
         input.tool_name = Some("apply_patch".into());

Modified file: src/main.rs+1−1

@@ -25,7 +25,7 @@ fn main() {

2525 // a typo must not exit 2, that's a blocking pretooluse verdict and would

2626 // wall off every bash call in every session

2727 let cfg = config::Config::load().unwrap_or_else(|e| {

28- eprintln!("rabt: bad config, using defaults. {e}");

28+ eprintln!("roundabout: bad config, using defaults. {e}");

2929 config::Config::default()

3030 });

3131 std::process::exit(cli::dispatch(&cfg, cli::Rabt::parse()));

Modified file: src/run.rs+2 additions−2 deletions@@ -52,7 +52,7 @@ extern "C" fn forward(sig: libc::c_int) {
 }
 
 fn say(msg: &str) {
-    eprintln!("rabt: {msg}");
+    eprintln!("roundabout: {msg}");
 }
 
 pub fn need(cfg: &Config, a: &Args) -> Result<Need, String> {
@@ -209,7 +209,7 @@ pub fn run(cfg: &Config, a: &Args) -> i32 {
     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",
+            "how big is it? pass --size {} or --ram and friends. `roundabout suggest -- <cmd>` has a guess",
             sizes.join("|")
         ));
         return 2;

Modified file: src/systemd.rs+1−1

@@ -247,7 +247,7 @@ pub fn exec() -> Option<i32> {

247247 };

248248 let error = Command::new(&program).args(arguments).exec();

249249 eprintln!(

250- "rabt: couldn't start {}: {error}",

250+ "roundabout: couldn't start {}: {error}",

251251 program.to_string_lossy()

252252 );

253253 Some(127)

Modified file: tests/omp.test.mjs+7 additions−7 deletions@@ -42,14 +42,14 @@ function input() {
 }
 
 test("maps build guards and preserves wrapped command arguments", async () => {
-  output({ hookSpecificOutput: { permissionDecision: "deny", permissionDecisionReason: "use rabt run" } });
-  assert.deepEqual(await handlers.get("tool_call")(bash, context), { block: true, reason: "use rabt run" });
+  output({ hookSpecificOutput: { permissionDecision: "deny", permissionDecisionReason: "use roundabout run" } });
+  assert.deepEqual(await handlers.get("tool_call")(bash, context), { block: true, reason: "use roundabout run" });
   assert.equal(input().event, "omp-pre-tool-use");
   assert.equal(input().input.tool_name, "Bash");
-  output({ hookSpecificOutput: { updatedInput: { command: "rabt run -s m -- cargo build" } } });
+  output({ hookSpecificOutput: { updatedInput: { command: "roundabout run -s m -- cargo build" } } });
   const result = await handlers.get("tool_call")({ ...bash, input: { ...bash.input, cwd: "/project" } }, context);
   assert.equal(input().input.cwd, "/project");
-  assert.equal(result.input.command, "rabt run -s m -- cargo build");
+  assert.equal(result.input.command, "roundabout run -s m -- cargo build");
   assert.equal(result.input.async, true);
   assert.deepEqual(result.input.env, { KEEP: "yes", ROUNDABOUT_SESSION_ID: "omp-session" });
 });
@@ -60,7 +60,7 @@ test("fails open for malformed output, nonzero exits and missing CLI", async () 
   output({ hookSpecificOutput: { permissionDecision: "deny" } });
   process.env.ROUNDABOUT_TEST_EXIT = "1";
   assert.equal((await handlers.get("tool_call")(bash, context)).block, undefined);
-  process.env.ROUNDABOUT_CLI = join(temporary, "missing-rabt");
+  process.env.ROUNDABOUT_CLI = join(temporary, "missing-roundabout");
   assert.equal((await handlers.get("tool_call")(bash, context)).block, undefined);
 });
 
@@ -80,7 +80,7 @@ test("maps artifact policies and bounds advisory continuations", async () => {
 });
 
 test("the CLI tracks OMP sessions ahead of inherited agent identities", () => {
-  const rabt = process.env.ROUNDABOUT_TEST_RABT;
+  const roundabout = process.env.ROUNDABOUT_TEST_RABT;
   const config = join(temporary, "config.toml");
   writeFileSync(config, '[queue]\nlinger = "1s"\n');
   const env = {
@@ -93,7 +93,7 @@ test("the CLI tracks OMP sessions ahead of inherited agent identities", () => {
     CODEX_THREAD_ID: "inherited-codex",
   };
   function run(args, payload) {
-    const result = spawnSync(rabt, args, { env, input: payload, encoding: "utf8", timeout: 10000 });
+    const result = spawnSync(roundabout, args, { env, input: payload, encoding: "utf8", timeout: 10000 });
     assert.equal(result.status, 0, result.stderr);
     return result.stdout;
   }

Modified file: tests/systemd.rs+5 additions−5 deletions@@ -18,7 +18,7 @@ fn gated_command(program: &str, arguments: &[&str]) -> (Child, OwnedFd) {
     let read = unsafe { OwnedFd::from_raw_fd(descriptors[0]) };
     let write = unsafe { OwnedFd::from_raw_fd(descriptors[1]) };
     let descriptor = read.as_raw_fd();
-    let mut command = Command::new(env!("CARGO_BIN_EXE_rabt"));
+    let mut command = Command::new(env!("CARGO_BIN_EXE_roundabout"));
     command
         .args(["__roundabout_exec", &descriptor.to_string(), program])
         .args(arguments)
@@ -39,7 +39,7 @@ fn gated_command(program: &str, arguments: &[&str]) -> (Child, OwnedFd) {
 
 #[test]
 fn command_waits_for_scope_setup() {
-    let (mut child, gate) = gated_command(env!("CARGO_BIN_EXE_rabt"), &["--version"]);
+    let (mut child, gate) = gated_command(env!("CARGO_BIN_EXE_roundabout"), &["--version"]);
     let mut output = libc::pollfd {
         fd: child.stdout.as_ref().unwrap().as_raw_fd(),
         events: libc::POLLIN,
@@ -53,13 +53,13 @@ fn command_waits_for_scope_setup() {
     assert!(
         String::from_utf8(output.stdout)
             .unwrap()
-            .starts_with("rabt ")
+            .starts_with("roundabout ")
     );
 }
 
 #[test]
 fn failed_scope_setup_never_executes_the_command() {
-    let (child, gate) = gated_command(env!("CARGO_BIN_EXE_rabt"), &["--version"]);
+    let (child, gate) = gated_command(env!("CARGO_BIN_EXE_roundabout"), &["--version"]);
     drop(gate);
     let output = child.wait_with_output().unwrap();
     assert_eq!(output.status.code(), Some(1));
@@ -118,7 +118,7 @@ fn transient_scope_enforces_the_grant() {
         "[overrun]\nram = \"throttle\"\n[queue]\nlinger = \"0s\"\n",
     )
     .unwrap();
-    let output = Command::new(env!("CARGO_BIN_EXE_rabt"))
+    let output = Command::new(env!("CARGO_BIN_EXE_roundabout"))
         .args([
             "run", "--ram", "64M", "--disk", "0", "--cores", "1", "--time", "5s", "--exact", "--",
         ])

roundabout

Commit fdad58f8133a

Commit `fdad58f8133a`