test: move inline tests into *_tests.rs files

AGENTS.md

@@ -30,7 +30,7 @@ crates/
         ├── call/           # `ToolCallOptions`, `ToolTimeout`
         ├── context/        # `ToolRunContext`
         └── naming/         # rendering a call for a human
-                            # each: mod.rs / types.rs / test.rs
+                            # each: mod.rs / types.rs / mod_tests.rs
 docs/
 ├── specs/              # behavior and architecture specifications
 ├── plans/              # test-first implementation plans
@@ -76,15 +76,17 @@ workspace = true
 Each feature area belongs in a focused module directory under a crate's `src/`.
 A module root explains the module, wires its pieces together, and exposes the
 smallest useful API. Move substantial type definitions into `types.rs` and put
-module-local unit tests in a dedicated `test.rs`, wired from the bottom of the
+module-local unit tests in a sibling `<module>_tests.rs`, wired from the bottom of the
 module root with:
 
 ```rust
 #[cfg(test)]
-mod test;
+#[path = "mod_tests.rs"]
+mod tests;
 ```
 
-Do not accumulate inline `mod tests` blocks in implementation files, and do not
+Do not write inline `mod tests` blocks in implementation files, do not name a test
+file `test.rs`, `tests.rs` or `<module>_test.rs`, and do not
 let a general-purpose `utils.rs` or `helpers.rs` grow — those are a symptom of a
 missing module. Prefer many small modules that each do one thing well over few
 broad ones.
@@ -168,7 +170,7 @@ releases are reproducible.
 
 ## Testing
 
-- Module-local unit tests live in `crates/<crate>/src/<feature>/test.rs` and may
+- Module-local unit tests live in `crates/<crate>/src/<feature>/mod_tests.rs` and may
   touch private items.
 - Integration tests live in `crates/<crate>/tests/` and exercise only the public
   API — they are the regression suite for the crate's contract.
@@ -197,7 +199,7 @@ Write documentation for the reader who has never seen the code.
 
 - Every public item gets a rustdoc comment. `missing_docs` is a warning that CI
   treats as an error.
-- Start every `mod.rs` and `test.rs` with a concise module-level `//!`
+- Start every `mod.rs` and `*_tests.rs` with a concise module-level `//!`
   description.
 - Each crate's `src/lib.rs` carries its crate-level overview: what the crate
   does, the primary entry points, and a short runnable example. It should also
@@ -287,3 +289,28 @@ For automated contributors specifically:
    credentials, and never paste them into a pull request or issue.
 7. **Ask only when blocked.** Make routine judgment calls yourself; escalate
    only irreversible decisions or genuine forks with no clear default.
+
+## Tests live in `*_tests.rs` files
+
+- Unit tests are never inline. Do not write a `#[cfg(test)] mod tests { ... }`
+  block in a source file. Put the tests in a sibling `<module>_tests.rs`
+  (`mod_tests.rs` beside a `mod.rs`, `lib_tests.rs` beside `lib.rs`) and declare
+  it at the bottom of the module:
+
+  ```rust
+  #[cfg(test)]
+  #[path = "foo_tests.rs"]
+  mod tests;
+  ```
+
+- The test file starts with `use super::*;` and carries no `#[cfg(test)]` of its
+  own. It is still a child module, so it reaches private items exactly as an
+  inline module did.
+- Name test files `<module>_tests.rs`; a second group for the same module is
+  `<module>_<topic>_tests.rs`. Never `test.rs`, `tests.rs` or `<module>_test.rs`.
+- Integration tests stay in the crate's `tests/` directory.
+- OpenHuman's `scripts/externalize-inline-tests.mjs <repo-root> --write` moves
+  inline test modules out mechanically; without `--write` it only reports.
+- Existing `test.rs` and `<module>_test.rs` files predate this rule. Rename each
+  to `<module>_tests.rs` (keep its `mod` name, add the `#[path]` attribute) the
+  next time you touch it.

crates/tinytools-agent/src/dialect/envelope.rs

@@ -179,97 +179,5 @@ pub fn join_image_parts(parts: &[ContentPart]) -> String {
 
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
-mod tests {
-    use super::*;
-
-    fn call(id: &str) -> NativeToolCall {
-        NativeToolCall {
-            id: id.into(),
-            name: "shell".into(),
-            arguments: r#"{"command":"ls"}"#.into(),
-            extra_content: None,
-        }
-    }
-
-    #[test]
-    fn assistant_envelope_round_trips_byte_exact() {
-        let text = encode_assistant_envelope(Some("on it"), &[call("c1"), call("c2")], None);
-        let parsed = parse_canonical_assistant_envelope(&text).unwrap();
-        assert_eq!(parsed.content, "on it");
-        assert_eq!(parsed.tool_calls.len(), 2);
-        assert_eq!(
-            encode_assistant_envelope(Some(&parsed.content), &parsed.tool_calls, None),
-            text
-        );
-    }
-
-    #[test]
-    fn literal_envelope_shape_is_stable() {
-        // Compared as values: key order depends on whether a downstream build
-        // unifies serde_json's `preserve_order`, the shape does not.
-        let value = |text: String| serde_json::from_str::<Value>(&text).unwrap();
-        assert_eq!(
-            value(encode_assistant_envelope(Some("hi"), &[call("c1")], None)),
-            serde_json::json!({
-                "content": "hi",
-                "tool_calls": [{"id": "c1", "name": "shell", "arguments": "{\"command\":\"ls\"}"}]
-            })
-        );
-        assert_eq!(
-            value(encode_tool_envelope("c1", "ok")),
-            serde_json::json!({"tool_call_id": "c1", "content": "ok"})
-        );
-    }
-
-    #[test]
-    fn non_canonical_assistant_envelopes_stay_opaque() {
-        for text in [
-            encode_assistant_envelope(None, &[call("c1")], None),
-            encode_assistant_envelope(Some("x"), &[call("c1")], Some("because")),
-            r#"{"content":"x","tool_calls":[{"id":"c1","name":"n","arguments":"{}"}],"extra":1}"#
-                .to_string(),
-            "plain prose".to_string(),
-            r#"{"content":"x","tool_calls":[]}"#.to_string(),
-        ] {
-            assert!(
-                parse_canonical_assistant_envelope(&text).is_none(),
-                "{text}"
-            );
-        }
-    }
-
-    #[test]
-    fn tool_envelope_round_trips_and_rejects_extras() {
-        let text = encode_tool_envelope("c1", "result \"quoted\"");
-        assert_eq!(
-            parse_canonical_tool_envelope(&text),
-            Some(("c1".into(), "result \"quoted\"".into()))
-        );
-        assert!(
-            parse_canonical_tool_envelope(r#"{"tool_call_id":"c1","content":"a","name":"n"}"#)
-                .is_none()
-        );
-        assert!(parse_canonical_tool_envelope("bare").is_none());
-    }
-
-    #[test]
-    fn image_parts_split_and_join_exactly() {
-        for text in [
-            "just text",
-            "[OH_IMAGE:data:image/png;base64,AAAA]",
-            "look [OH_IMAGE:data:image/png;base64,AAAA] and [OH_IMAGE:https://x/y.png]\ndone",
-            "dangling [OH_IMAGE:data:no-close",
-            "",
-        ] {
-            assert_eq!(join_image_parts(&split_image_parts(text)), text);
-        }
-        assert_eq!(
-            split_image_parts("a[OH_IMAGE:u]b"),
-            vec![
-                ContentPart::Text("a".into()),
-                ContentPart::Image("u".into()),
-                ContentPart::Text("b".into())
-            ]
-        );
-    }
-}
+#[path = "envelope_tests.rs"]
+mod tests;

crates/tinytools-agent/src/dialect/envelope_tests.rs

@@ -0,0 +1,92 @@
+use super::*;
+
+fn call(id: &str) -> NativeToolCall {
+    NativeToolCall {
+        id: id.into(),
+        name: "shell".into(),
+        arguments: r#"{"command":"ls"}"#.into(),
+        extra_content: None,
+    }
+}
+
+#[test]
+fn assistant_envelope_round_trips_byte_exact() {
+    let text = encode_assistant_envelope(Some("on it"), &[call("c1"), call("c2")], None);
+    let parsed = parse_canonical_assistant_envelope(&text).unwrap();
+    assert_eq!(parsed.content, "on it");
+    assert_eq!(parsed.tool_calls.len(), 2);
+    assert_eq!(
+        encode_assistant_envelope(Some(&parsed.content), &parsed.tool_calls, None),
+        text
+    );
+}
+
+#[test]
+fn literal_envelope_shape_is_stable() {
+    // Compared as values: key order depends on whether a downstream build
+    // unifies serde_json's `preserve_order`, the shape does not.
+    let value = |text: String| serde_json::from_str::<Value>(&text).unwrap();
+    assert_eq!(
+        value(encode_assistant_envelope(Some("hi"), &[call("c1")], None)),
+        serde_json::json!({
+            "content": "hi",
+            "tool_calls": [{"id": "c1", "name": "shell", "arguments": "{\"command\":\"ls\"}"}]
+        })
+    );
+    assert_eq!(
+        value(encode_tool_envelope("c1", "ok")),
+        serde_json::json!({"tool_call_id": "c1", "content": "ok"})
+    );
+}
+
+#[test]
+fn non_canonical_assistant_envelopes_stay_opaque() {
+    for text in [
+        encode_assistant_envelope(None, &[call("c1")], None),
+        encode_assistant_envelope(Some("x"), &[call("c1")], Some("because")),
+        r#"{"content":"x","tool_calls":[{"id":"c1","name":"n","arguments":"{}"}],"extra":1}"#
+            .to_string(),
+        "plain prose".to_string(),
+        r#"{"content":"x","tool_calls":[]}"#.to_string(),
+    ] {
+        assert!(
+            parse_canonical_assistant_envelope(&text).is_none(),
+            "{text}"
+        );
+    }
+}
+
+#[test]
+fn tool_envelope_round_trips_and_rejects_extras() {
+    let text = encode_tool_envelope("c1", "result \"quoted\"");
+    assert_eq!(
+        parse_canonical_tool_envelope(&text),
+        Some(("c1".into(), "result \"quoted\"".into()))
+    );
+    assert!(
+        parse_canonical_tool_envelope(r#"{"tool_call_id":"c1","content":"a","name":"n"}"#)
+            .is_none()
+    );
+    assert!(parse_canonical_tool_envelope("bare").is_none());
+}
+
+#[test]
+fn image_parts_split_and_join_exactly() {
+    for text in [
+        "just text",
+        "[OH_IMAGE:data:image/png;base64,AAAA]",
+        "look [OH_IMAGE:data:image/png;base64,AAAA] and [OH_IMAGE:https://x/y.png]\ndone",
+        "dangling [OH_IMAGE:data:no-close",
+        "",
+    ] {
+        assert_eq!(join_image_parts(&split_image_parts(text)), text);
+    }
+    assert_eq!(
+        split_image_parts("a[OH_IMAGE:u]b"),
+        vec![
+            ContentPart::Text("a".into()),
+            ContentPart::Image("u".into()),
+            ContentPart::Text("b".into())
+        ]
+    );
+}

crates/tinytools-agent/src/dialect/test.rs

@@ -107,7 +107,7 @@ fn native_dialect_covers_non_object_values_fallback_and_protocol_metadata() {
 
     let (text, calls) = dialect.parse_response(&response("narrative only"));
     assert_eq!(text, "narrative only");
-    assert!(calls.is_empty());
+    assert_eq!(calls.len(), 0);
     let (text, calls) = dialect.parse_response(&response(
         "narrative <tool_call>{\"name\":\"lookup\",\"arguments\":{}}</tool_call>",
     ));
@@ -682,7 +682,7 @@ fn native_replay_drops_a_cycle_whose_results_do_not_cover_every_call() {
 
     // Adjacency is not enough: the provider rejects partial coverage the same
     // way it rejects no coverage, so both halves go.
-    assert!(NativeDialect.to_provider_messages(&history).is_empty());
+    assert_eq!(NativeDialect.to_provider_messages(&history).len(), 0);
 }
 
 #[test]
@@ -692,7 +692,7 @@ fn native_replay_drops_orphan_results() {
         "done".to_string(),
     )])];
 
-    assert!(NativeDialect.to_provider_messages(&history).is_empty());
+    assert_eq!(NativeDialect.to_provider_messages(&history).len(), 0);
 }
 
 #[test]

crates/tinytools-agent/src/parse/protected/test.rs

@@ -9,15 +9,15 @@ fn a_fence_indented_more_than_three_spaces_is_not_a_fence() {
     // indented code block, not a fence, so it must not open a protected
     // range even though it carries a language tag.
     let text = "    ```rust\nfn main() {}\n    ```\n";
-    assert!(fence_ranges(text).is_empty());
+    assert_eq!(fence_ranges(text).len(), 0);
 }
 
 #[test]
 fn a_two_backtick_run_is_not_a_fence() {
     // A fence needs at least three backticks (or tildes); shorter runs are
     // inline code spans, not fence delimiters.
     let text = "``json\n{\"a\":1}\n``\n";
-    assert!(fence_ranges(text).is_empty());
+    assert_eq!(fence_ranges(text).len(), 0);
 }
 
 #[test]

crates/tinytools-agent/src/parse/test/bare_json.rs

@@ -19,7 +19,7 @@ fn a_wire_message_with_tool_calls_array_parses() {
 #[test]
 fn a_bare_object_with_canonical_arguments_parses() {
     let (text, calls) = parse(r#"{"name":"echo","arguments":{"value":"hi"}}"#);
-    assert!(text.is_empty());
+    assert_eq!(text.len(), 0);
     assert_eq!(calls.len(), 1);
 }
 
@@ -54,7 +54,7 @@ fn llama_bare_object_with_mismatched_quotes_is_repaired() {
         outcome.calls[0].arguments,
         serde_json::json!({ "city": "Paris" })
     );
-    assert!(outcome.text.is_empty());
+    assert_eq!(outcome.text.len(), 0);
 }
 
 #[test]
@@ -104,7 +104,7 @@ fn parse_options_default_matches_new_and_allows_bare_json() {
 fn bare_json_can_be_disabled() {
     let options = ParseOptions::new().without_bare_json();
     let outcome = crate::parse::parse_text(r#"{"name":"echo","arguments":{}}"#, &options);
-    assert!(outcome.calls.is_empty());
+    assert_eq!(outcome.calls.len(), 0);
 }
 
 #[test]

crates/tinytools-agent/src/parse/test/element.rs

@@ -93,7 +93,7 @@ fn an_element_without_a_registry_is_left_alone() {
 fn ordinary_markup_is_not_a_call() {
     let outcome = parse("<div><p>x</p></div>");
     assert!(outcome.calls.is_empty(), "{:?}", outcome.calls);
-    assert!(outcome.diagnostics.is_empty());
+    assert_eq!(outcome.diagnostics.len(), 0);
     assert_eq!(outcome.text, "<div><p>x</p></div>");
 }
 
@@ -102,7 +102,7 @@ fn prose_inside_a_known_tool_tag_is_left_alone() {
     let text = "<todo>remember to <todos>ship</todos> it</todo>";
     let outcome = parse(text);
     assert!(outcome.calls.is_empty(), "{:?}", outcome.calls);
-    assert!(outcome.diagnostics.is_empty());
+    assert_eq!(outcome.diagnostics.len(), 0);
     assert_eq!(outcome.text, text);
 }
 

crates/tinytools-agent/src/parse/test/engine.rs

@@ -39,8 +39,8 @@ fn fence_ranges_cover_languages_and_unclosed_fences() {
     assert_eq!(ranges.len(), 2);
     assert_eq!(&text[ranges[0].clone()], "```rust\nx\n```");
     assert_eq!(ranges[1].end, text.len());
-    assert!(fence_ranges("```\nplain\n```").is_empty());
-    assert!(fence_ranges("```tool_call\n{}\n```").is_empty());
+    assert_eq!(fence_ranges("```\nplain\n```").len(), 0);
+    assert_eq!(fence_ranges("```tool_call\n{}\n```").len(), 0);
 }
 
 // ── A call tag on the fence line itself ────────────────────────────────────
@@ -250,8 +250,8 @@ fn json_scanners_cover_common_edge_cases() {
         values,
         vec![serde_json::json!({ "a": 1 }), serde_json::json!([1, 2])]
     );
-    assert!(extract_json_values("").is_empty());
-    assert!(extract_json_values("{not json} [still bad]").is_empty());
+    assert_eq!(extract_json_values("").len(), 0);
+    assert_eq!(extract_json_values("{not json} [still bad]").len(), 0);
 
     assert_eq!(
         find_json_end("  {\"a\":\"}\"}tail"),