refactor: extract safety module into ironclaw_safety crate

[ilblackdragon]

Summary

• Extracts src/safety/ into a standalone crates/ironclaw_safety/ crate (prompt injection defense, input validation, secret leak detection, policy enforcement)
• SafetyConfig moves into the crate; env-var resolution stays in ironclaw's config module as a free function (resolve_safety_config())
• src/safety/mod.rs becomes a thin pub use ironclaw_safety::* re-export — all existing crate::safety::* imports keep working
• CLAUDE.md updated with guidance to migrate imports to ironclaw_safety when touching files

The safety module was a leaf dependency with no async, no database, and no ironclaw traits — only pure computation with pattern matching. External deps: regex, aho-corasick, serde_json, url, thiserror, tracing.

Test plan

• cargo check passes
• cargo clippy -p ironclaw_safety --all-targets — zero warnings
• cargo test -p ironclaw_safety — all 81 tests pass
• cargo test -p ironclaw --lib -- safety — re-export works
• Verify open PRs touching src/safety/ (fix: built-in time tool call failure #755, fix(safety): stop XML-escaping tool output content in wrap_for_llm #645, LLM-as-Judge semantic tool call evaluation #614, feat(worker): harden reasoning streams and sanitize job event payloads #461, feat(agent): add in-memory reasoning summaries and /reasoning surface #460) resolve conflicts cleanly

🤖 Generated with Claude Code

[gemini-code-assist]

Summary of Changes

Hello, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request significantly refactors the project's architecture by isolating the safety-related functionalities into a dedicated Rust crate. This move enhances modularity, making the safety components more independent and reusable, as they consist primarily of pure computation without direct dependencies on ironclaw's core traits or I/O. The change aims to improve the overall maintainability and clarity of the codebase by separating concerns, while carefully managing the transition to ensure existing code remains functional.

Highlights

• Module Extraction: The src/safety/ module has been extracted into a new, standalone crates/ironclaw_safety/ crate, encompassing prompt injection defense, input validation, secret leak detection, and policy enforcement.
• Configuration Migration: The SafetyConfig struct has been moved into the new ironclaw_safety crate, with its environment variable resolution logic (resolve_safety_config()) remaining in ironclaw's config module.
• Backward Compatibility: The original src/safety/mod.rs now acts as a thin pub use ironclaw_safety::* re-export, ensuring that all existing crate::safety::* imports continue to function without immediate changes.
• Documentation Update: The CLAUDE.md file has been updated to include guidance for migrating imports to ironclaw_safety when modifying relevant files.

Changelog

• CLAUDE.md
  • Added a new section 'Extracted Crates' to document the ironclaw_safety crate.
  • Updated the project structure diagram to include the new crates/ironclaw_safety directory.
  • Modified the description of src/safety/ to reflect its new role as a re-export shim.
• Cargo.lock
  • Added ironclaw_safety to the list of project dependencies.
  • Included the package definition for ironclaw_safety with its version and dependencies.
• Cargo.toml
  • Added crates/ironclaw_safety to the workspace members.
  • Declared ironclaw_safety as a local path dependency under the [dependencies] section.
• crates/ironclaw_safety/Cargo.toml
  • Created a new Cargo manifest file for the ironclaw_safety crate, defining its metadata and dependencies.
• crates/ironclaw_safety/src/credential_detect.rs
  • Renamed from src/safety/credential_detect.rs.
• crates/ironclaw_safety/src/leak_detector.rs
  • Renamed from src/safety/leak_detector.rs.
  • Updated internal use crate::safety::leak_detector paths to use crate::leak_detector.
• crates/ironclaw_safety/src/lib.rs
  • Added the core safety logic, including the SafetyLayer struct and related components, to the new crate.
  • Exported modules like credential_detect, leak_detector, policy, sanitizer, and validator.
  • Defined SafetyConfig and SafetyLayer structs and their implementations.
• crates/ironclaw_safety/src/policy.rs
  • Renamed from src/safety/policy.rs.
• crates/ironclaw_safety/src/sanitizer.rs
  • Renamed from src/safety/sanitizer.rs.
  • Updated internal use crate::safety::Severity to use crate::Severity.
• crates/ironclaw_safety/src/validator.rs
  • Renamed from src/safety/validator.rs.
• src/config/mod.rs
  • Imported resolve_safety_config from self::safety.
  • Updated the Config::resolve method to call resolve_safety_config() instead of SafetyConfig::resolve().
• src/config/safety.rs
  • Removed the local SafetyConfig struct definition.
  • Replaced the local SafetyConfig with pub use ironclaw_safety::SafetyConfig;.
  • Converted the SafetyConfig::resolve() method into a free function resolve_safety_config() that returns ironclaw_safety::SafetyConfig.
• src/safety/mod.rs
  • Simplified the file to re-export all public items from the ironclaw_safety crate using pub use ironclaw_safety::*;.
  • Removed all original module declarations and use statements.

Activity

• The author confirmed that cargo check passes successfully.
• The ironclaw_safety crate passed cargo clippy with zero warnings across all targets.
• All 81 tests within the ironclaw_safety crate passed.
• The re-export mechanism was verified to be working correctly by running cargo test -p ironclaw --lib -- safety.
• The author plans to verify that open pull requests touching the original src/safety/ directory resolve conflicts cleanly with these changes.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[Copilot]

Pull request overview

Extracts the src/safety/ module into a standalone crates/ironclaw_safety/ crate, replacing the original module with a thin pub use ironclaw_safety::* re-export shim. The SafetyConfig struct moves to the new crate while env-var resolution remains in the main crate.

Changes:

• New crates/ironclaw_safety/ crate with all safety submodules (sanitizer, validator, policy, leak_detector, credential_detect)
• src/safety/mod.rs reduced to a re-export shim; src/config/safety.rs updated to use a free function for config resolution
• CLAUDE.md and Cargo workspace updated with guidance and dependency wiring

Reviewed changes

Copilot reviewed 9 out of 13 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
crates/ironclaw_safety/Cargo.toml	New crate manifest
crates/ironclaw_safety/src/lib.rs	Crate root with SafetyConfig, SafetyLayer, and re-exports
crates/ironclaw_safety/src/policy.rs	Moved policy module
crates/ironclaw_safety/src/sanitizer.rs	Updated import path
crates/ironclaw_safety/src/validator.rs	Moved validator module
crates/ironclaw_safety/src/credential_detect.rs	Moved credential detection module
crates/ironclaw_safety/src/leak_detector.rs	Updated import paths in tests
src/safety/mod.rs	Replaced with re-export shim
src/config/safety.rs	Changed from impl method to free function
src/config/mod.rs	Updated call site for config resolution
Cargo.toml	Added workspace member and dependency
Cargo.lock	Updated lockfile
CLAUDE.md	Added guidance for extracted crate

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[gemini-code-assist]

Code Review

This pull request is a well-executed refactoring that extracts the safety module into a new ironclaw_safety crate. The changes are clean, and the use of a re-export shim in src/safety/mod.rs ensures backward compatibility, which is a great approach for a change of this scale. The new crate structure improves modularity and separation of concerns. I have one minor suggestion to improve the performance of XML attribute escaping by avoiding multiple string allocations, aligning with our guidelines on minimizing heap allocations for performance.

[gemini-code-assist]

The current implementation of escape_xml_attr with chained replace calls can be inefficient, as each call might allocate a new String if the character to be replaced is found. A more performant approach is to iterate over the string's characters once and build the new escaped string in a single pass. This avoids intermediate string allocations.

fn escape_xml_attr(s: &str) -> String {
    // Pre-allocating with the original string's length is a good starting point.
    let mut escaped = String::with_capacity(s.len());
    for c in s.chars() {
        match c {
            '&' => escaped.push_str("&"),
            '"' => escaped.push_str("""),
            '<' => escaped.push_str("&lt;"),
            '>' => escaped.push_str("&gt;"),
            _ => escaped.push(c),
        }
    }
    escaped
}

References

1. To improve performance, avoid unnecessary heap allocations. When processing string parts, build the result in a single pass to prevent intermediate string allocations.

[ilblackdragon]

Fixed in b78c336 — rewrote to single-pass char iteration with String::with_capacity. O(n) with no intermediate allocations.

[Copilot]

Pull request overview

Copilot reviewed 67 out of 77 changed files in this pull request and generated no new comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.