Claude Runtime Hooks, Enforceable TDD, Modified Ralph Loops, and More This release is about one thing.
Enforcement.

Mault 0.7.5 pushes deeper into runtime verification, deterministic setup, and AI-native development workflows. If AI is generating more of your code, the system verifying that code must operate at the same speed.

Here is what shipped.

Mault Core 0.7.5 (Free)

Claude Code Runtime Hooks

We introduced enforceable TDD hooks for Claude Code. An agent can no longer edit a source file without a corresponding test. This is not advisory logic or linting feedback. It is runtime enforcement.

For Cursor, Copilot, Windsurf, and Augment, we provide structured testing rule configurations today. Full runtime enforcement for non-Claude agents is coming to Mault Pro. The direction is clear. If code changes, tests must exist. That requirement is enforced at the moment of change, not later in CI.

Specialized Agentic Setup (Steps 1–3)

Mault now enables your AI coder to configure Git, environment security, and Docker correctly in under fifteen minutes. This is not scaffolding for demos. It is the same production configuration we use internally at Mault.

Each step includes built-in verification loops inspired by the Ralph Loop protocol. Every configuration action produces proof-of-completion receipts and handshake GitHub Issues. Scripts validate real filesystem state instead of assuming success based on output alone.

There are no manual checks. There are no symbolic green confirmations. The system verifies that what was intended actually exists.

mault.yaml Auditing

Your project rulebook receives the same enforcement treatment.

Verification checks now catch hallucinated paths and invalid configuration before detectors even execute. Temporary canary files confirm that every declared rule resolves against actual project structure. This eliminates false positives caused by AI-generated configuration errors and ensures that governance rules are grounded in real repository state.

Mault Pro 0.7.5

Step 4: CI Pipeline

The CI workflow we use on Mault’s own codebase is now available to you. It is designed specifically for agentic workflows where AI writes a meaningful portion of the code and verification becomes more critical than ever.

With a single prompt, the system sets up a full CI pipeline complete with built-in verification loops, proof-of-completion receipts, and a handshake GitHub Issue and pull request. The pipeline does not simply exist. It is validated against repository state and confirmed through recorded artifacts.

It configures. It verifies. It proves.

Step 5: TDD Framework

This is where enforcement deepens.

CodeLens detectors now alert when an agent skips writing a test and instruct it precisely which test type is required based on a structured testing pyramid. Automatic test layer routing enforces boundaries across unit, integration, behavioral, adapter, and event flow layers. Tests are not treated as interchangeable. They are categorized and validated according to system role.

Test Impact Analysis improves local development speed by running only the relevant subset of tests instead of the entire suite on every change. In CI, test layers are separated with an enforced coverage floor of 80 percent. A nine-check verification script produces a proof file and handshake receipt confirming that the framework is configured correctly.

Testing becomes structural rather than optional.

Coming Soon: Mault Pro Roadmap

The pattern continues in upcoming releases.

Step 6 introduces pre-commit hook verification loops with proof-of-completion receipts. Step 7 adds structural governance with AST-level enforcement and CI sharding. Step 8 expands into observability and production monitoring configuration for AI-maintained codebases.

Cross-IDE enforcement is also expanding. Runtime test gates are coming for Cursor, Windsurf, and Augment. Not just advisory rules, but actual enforcement at the moment of change.

Coming Soon: Open Source Mault Core

We are open-sourcing Mault Core.

Fifteen detectors.
The Mault Panel.
AI-ready prompts with built-in verification scripting.

All free.

More details will follow, but the goal is simple. Enforcement should not be gated behind access. The ecosystem benefits when structural verification becomes standard.

The Pattern Behind Everything

Every step in 0.7.5 follows the same model.

One prompt initiates the change.
Your AI coder performs the work.
A verification script checks real system state.
A proof file confirms completion.

This is physics, not policy.

Mault 0.7.5 moves enforcement closer to runtime, closer to repository state, and closer to production certainty. As AI writes more of your software, verification must become stricter and more automated.

This release makes that possible.