rustfmt the RLM code

The chutes-rlm crate was written without a compiler in the loop and never went
through rustfmt; this brings it and the new core modules in line with the
workspace style so the next diff is about behaviour rather than whitespace.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: fstandhartinger

codex-rs/chutes-rlm/src/harness.rs

@@ -110,7 +110,12 @@ pub enum HarnessError {
          and are capped at {cap} bytes. Shorten it, or make it a skill instead — skill bodies are \
          only loaded when you ask for them."
     )]
-    TooLarge { kind: &'static str, name: String, actual: usize, cap: usize },
+    TooLarge {
+        kind: &'static str,
+        name: String,
+        actual: usize,
+        cap: usize,
+    },
 }
 
 /// A two-layer harness store. Project entries shadow global ones by name.
@@ -122,7 +127,10 @@ pub struct Harness {
 
 impl Harness {
     pub fn new(global_root: PathBuf, project_root: Option<PathBuf>) -> Self {
-        Self { global_root, project_root }
+        Self {
+            global_root,
+            project_root,
+        }
     }
 
     fn root(&self, scope: Scope) -> Option<&Path> {
@@ -279,15 +287,22 @@ impl Harness {
         )
     }
 
-    pub fn delete(&self, kind: Kind, name: &str, scope: Option<Scope>) -> Result<bool, HarnessError> {
+    pub fn delete(
+        &self,
+        kind: Kind,
+        name: &str,
+        scope: Option<Scope>,
+    ) -> Result<bool, HarnessError> {
         validate_name(name)?;
         let scopes = match scope {
             Some(s) => vec![s],
             None => vec![Scope::Project, Scope::Global],
         };
         let mut removed = false;
         for s in scopes {
-            let Some(path) = self.path_for(kind, name, s) else { continue };
+            let Some(path) = self.path_for(kind, name, s) else {
+                continue;
+            };
             if !path.exists() {
                 continue;
             }

codex-rs/chutes-rlm/src/harness_tests.rs

@@ -5,7 +5,10 @@ use tempfile::TempDir;
 fn harness() -> (TempDir, TempDir, Harness) {
     let global = TempDir::new().unwrap();
     let project = TempDir::new().unwrap();
-    let h = Harness::new(global.path().to_path_buf(), Some(project.path().to_path_buf()));
+    let h = Harness::new(
+        global.path().to_path_buf(),
+        Some(project.path().to_path_buf()),
+    );
     (global, project, h)
 }
 
@@ -16,18 +19,34 @@ fn no_meta() -> BTreeMap<String, String> {
 #[test]
 fn create_then_get_round_trips() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Memory, "flaky-test", "retry three times", "", Scope::Global, &no_meta())
-        .unwrap();
-    let got = h.get(Kind::Memory, "flaky-test").expect("entry should exist");
+    h.create(
+        Kind::Memory,
+        "flaky-test",
+        "retry three times",
+        "",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
+    let got = h
+        .get(Kind::Memory, "flaky-test")
+        .expect("entry should exist");
     assert_eq!(got.body.trim(), "retry three times");
     assert_eq!(got.scope, Scope::Global);
 }
 
 #[test]
 fn description_survives_front_matter() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Skill, "release", "1. bump\n2. tag", "cut a release", Scope::Global, &no_meta())
-        .unwrap();
+    h.create(
+        Kind::Skill,
+        "release",
+        "1. bump\n2. tag",
+        "cut a release",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
     let got = h.get(Kind::Skill, "release").unwrap();
     assert_eq!(got.description, "cut a release");
     assert_eq!(got.body.trim(), "1. bump\n2. tag");
@@ -36,8 +55,24 @@ fn description_survives_front_matter() {
 #[test]
 fn project_shadows_global_by_name() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Note, "style", "global style", "", Scope::Global, &no_meta()).unwrap();
-    h.create(Kind::Note, "style", "project style", "", Scope::Project, &no_meta()).unwrap();
+    h.create(
+        Kind::Note,
+        "style",
+        "global style",
+        "",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
+    h.create(
+        Kind::Note,
+        "style",
+        "project style",
+        "",
+        Scope::Project,
+        &no_meta(),
+    )
+    .unwrap();
 
     let got = h.get(Kind::Note, "style").unwrap();
     assert_eq!(got.body.trim(), "project style");
@@ -51,18 +86,30 @@ fn project_shadows_global_by_name() {
 #[test]
 fn list_covers_every_kind() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Note, "n", "n", "", Scope::Global, &no_meta()).unwrap();
-    h.create(Kind::Memory, "m", "m", "", Scope::Global, &no_meta()).unwrap();
-    h.create(Kind::Skill, "s", "s", "d", Scope::Global, &no_meta()).unwrap();
-    h.create(Kind::Subagent, "a", "a", "d", Scope::Global, &no_meta()).unwrap();
+    h.create(Kind::Note, "n", "n", "", Scope::Global, &no_meta())
+        .unwrap();
+    h.create(Kind::Memory, "m", "m", "", Scope::Global, &no_meta())
+        .unwrap();
+    h.create(Kind::Skill, "s", "s", "d", Scope::Global, &no_meta())
+        .unwrap();
+    h.create(Kind::Subagent, "a", "a", "d", Scope::Global, &no_meta())
+        .unwrap();
     assert_eq!(h.list(None).len(), 4);
     assert_eq!(h.list(Some(Kind::Skill)).len(), 1);
 }
 
 #[test]
 fn update_preserves_scope_and_description() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Note, "n", "one", "the note", Scope::Project, &no_meta()).unwrap();
+    h.create(
+        Kind::Note,
+        "n",
+        "one",
+        "the note",
+        Scope::Project,
+        &no_meta(),
+    )
+    .unwrap();
     let updated = h.update(Kind::Note, "n", Some("two"), None).unwrap();
     assert_eq!(updated.body.trim(), "two");
     assert_eq!(updated.description, "the note");
@@ -73,13 +120,26 @@ fn update_preserves_scope_and_description() {
 fn delete_removes_the_whole_skill_directory() {
     let (_g, _p, h) = harness();
     let e = h
-        .create(Kind::Skill, "release", "body", "d", Scope::Global, &no_meta())
+        .create(
+            Kind::Skill,
+            "release",
+            "body",
+            "d",
+            Scope::Global,
+            &no_meta(),
+        )
         .unwrap();
-    let dir = std::path::Path::new(&e.path).parent().unwrap().to_path_buf();
+    let dir = std::path::Path::new(&e.path)
+        .parent()
+        .unwrap()
+        .to_path_buf();
     std::fs::write(dir.join("helper.sh"), "echo hi").unwrap();
 
     assert!(h.delete(Kind::Skill, "release", None).unwrap());
-    assert!(!dir.exists(), "an emptied skill dir would still show up in listings");
+    assert!(
+        !dir.exists(),
+        "an emptied skill dir would still show up in listings"
+    );
     assert!(h.get(Kind::Skill, "release").is_none());
 }
 
@@ -98,7 +158,10 @@ fn oversized_note_is_refused_with_an_actionable_message() {
         .expect_err("a note over the cap must be refused, not truncated");
     let msg = err.to_string();
     assert!(msg.contains("every request"), "{msg}");
-    assert!(msg.contains("skill"), "the error should point at the cheaper alternative: {msg}");
+    assert!(
+        msg.contains("skill"),
+        "the error should point at the cheaper alternative: {msg}"
+    );
 }
 
 #[test]
@@ -114,7 +177,8 @@ fn names_cannot_escape_the_harness_directory() {
     let (_g, _p, h) = harness();
     for bad in ["../escape", "a/b", "..", ".", "", "with space"] {
         assert!(
-            h.create(Kind::Note, bad, "x", "", Scope::Global, &no_meta()).is_err(),
+            h.create(Kind::Note, bad, "x", "", Scope::Global, &no_meta())
+                .is_err(),
             "{bad:?} should be rejected as a harness entry name"
         );
     }
@@ -123,8 +187,15 @@ fn names_cannot_escape_the_harness_directory() {
 #[test]
 fn front_matter_values_cannot_forge_extra_keys() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Skill, "s", "body", "line one\ndescription: injected", Scope::Global, &no_meta())
-        .unwrap();
+    h.create(
+        Kind::Skill,
+        "s",
+        "body",
+        "line one\ndescription: injected",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
     let got = h.get(Kind::Skill, "s").unwrap();
     assert_eq!(got.description, "line one description: injected");
     assert_eq!(got.body.trim(), "body");
@@ -139,8 +210,24 @@ fn empty_harness_renders_nothing() {
 #[test]
 fn render_inlines_notes_and_memories_but_only_indexes_skills() {
     let (_g, _p, h) = harness();
-    h.create(Kind::Note, "style", "prefer small diffs", "", Scope::Global, &no_meta()).unwrap();
-    h.create(Kind::Memory, "flaky", "retry test_net 3x", "", Scope::Global, &no_meta()).unwrap();
+    h.create(
+        Kind::Note,
+        "style",
+        "prefer small diffs",
+        "",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
+    h.create(
+        Kind::Memory,
+        "flaky",
+        "retry test_net 3x",
+        "",
+        Scope::Global,
+        &no_meta(),
+    )
+    .unwrap();
     h.create(
         Kind::Skill,
         "release",
@@ -167,11 +254,21 @@ fn render_stops_inlining_once_the_budget_is_spent() {
     let chunk = "y".repeat(MAX_INLINE_BYTES - 1);
     // 12 near-cap memories comfortably exceed the 32 KiB total budget.
     for i in 0..12 {
-        h.create(Kind::Memory, &format!("m{i}"), &chunk, "", Scope::Global, &no_meta())
-            .unwrap();
+        h.create(
+            Kind::Memory,
+            &format!("m{i}"),
+            &chunk,
+            "",
+            Scope::Global,
+            &no_meta(),
+        )
+        .unwrap();
     }
     let block = h.render_prompt_block().unwrap();
-    assert!(block.contains("budget is full"), "over-budget entries should say so: {block}");
+    assert!(
+        block.contains("budget is full"),
+        "over-budget entries should say so: {block}"
+    );
     assert!(
         block.len() < MAX_INLINE_TOTAL_BYTES * 2,
         "the rendered block must stay bounded, got {} bytes",