Rust Quality Gate Protocol Skill

Rust Quality Gate Protocol

When to Invoke

Invoke this protocol when:

Any implementation task completes and code changes are ready to commit
User asks "check quality", "run tests", "run clippy", "is this ready", or "verify"
Before creating a pull request or merging to main
After modifying a shared library crate (trusty-common, trusty-mcp-core, trusty-embedder, trusty-symgraph)
After the rust-qa agent delivers a work product

The Three-Gate Sequence

Run gates in this exact order. Stop on first failure — do not proceed to the next gate.

Gate 1: Format Check (fastest — always run first)

cargo fmt --check

Pass: No output, exit code 0.

Fail: Lists files with formatting differences. Fix with:

cargo fmt

Then re-run cargo fmt --check to confirm clean.

Why first: Format failures are trivially fixable. Running it first avoids wasting clippy and test time on unformatted code.

Gate 2: Clippy Lint Gate

cargo clippy --workspace --all-targets -- -D warnings

Pass: No warnings emitted, exit code 0.

Fail: One or more error[clippy::] lines. Fix each warning the compiler reports. Common patterns:

# Check a single crate faster during iteration
cargo clippy -p trusty-search -- -D warnings

# Check with a specific feature enabled
cargo clippy -p trusty-common --features axum-server -- -D warnings

open-mpm exception: open-mpm has 142 pre-existing clippy errors at HEAD (tracked separately). These errors do not block other work. When running workspace-wide clippy and open-mpm fails, confirm whether the failures are confined to open-mpm only:

# Run clippy on everything except open-mpm to confirm other crates are clean
cargo clippy --workspace --all-targets -- -D warnings 2>&1 | grep -v "open-mpm"

If all errors are in open-mpm, treat the gate as passing for the purpose of non-open-mpm work.

Gate 3: Test Gate

Single-crate (fast — use during iteration):

cargo test -p <crate>

Workspace-wide (required before commit):

cargo test --workspace

With ignored integration tests (full validation):

cargo test -p <crate> -- --include-ignored
# or workspace-wide:
cargo test --workspace -- --include-ignored

Crate Name vs Directory Name

Cargo -p flags use the name field in Cargo.toml, not the directory name. Exceptions:

| Directory | Cargo flag | |---|---| | crates/trusty-git-analytics/ | -p tga | | crates/open-mpm/ | -p open-mpm |

All other crates: directory name = crate name (e.g. crates/trusty-search/ → -p trusty-search).

Reading Test Output

Cargo test output ends with a summary line:

test result: ok. 42 passed; 0 failed; 3 ignored; 0 measured; 0 filtered out

| Field | Meaning | |---|---| | passed | Tests that ran and succeeded | | failed | Tests that ran and failed — must be zero | | ignored | Tests tagged #[ignore] — skipped by default (ONNX/integration) | | measured | Benchmark results (bench mode only) |

#[ignore] tests: These are slow ONNX-backed or environment-dependent integration tests. They are intentionally skipped in the default gate. Run them with --include-ignored for full local validation before releases.

Evidence format required: Report the literal summary line, not "tests pass". Example of acceptable evidence:

test result: ok. 87 passed; 0 failed; 5 ignored; 0 measured; 0 filtered out; finished in 3.42s

Pre-existing vs New Failure Triage

If a gate fails, determine whether the failure existed before the current patch:

# Stash current changes
git stash

# Run the failing gate at clean HEAD
cargo test -p <crate>

# If it also fails at HEAD: pre-existing failure — do not block the patch
# If it passes at HEAD: the patch introduced the regression — must fix

# Restore patch
git stash pop

Report: "Failure is pre-existing at HEAD — not introduced by this change" or "Failure is new — introduced by this patch."

Single-Crate vs Workspace Scope

| Scope | Command | When | |---|---|---| | Single crate | cargo test -p <crate> | Fast iteration during implementation | | Single crate (check only) | cargo check -p <crate> | Fastest — confirms compilation, no test run | | Single crate + features | cargo test -p trusty-common --features axum-server | When feature flag needed | | Workspace | cargo test --workspace | Required before committing any change | | Workspace + ignored | cargo test --workspace -- --include-ignored | Before tagging a release |

After Modifying a Shared Library Crate

When trusty-common, trusty-mcp-core, trusty-embedder, or trusty-symgraph changes:

Run cargo check (workspace-wide) first — catches compilation errors in all dependents immediately.
Run cargo test -p <lib> for the modified library.
Run cargo test -p <consumer> for each crate that imports the modified library.
Only commit after all dependent tests pass.

Gate Summary

cargo fmt --check          → Gate 1 (format)  — fix: cargo fmt
cargo clippy --workspace   → Gate 2 (lint)    — fix: address each warning
cargo test -p <crate>      → Gate 3 (tests)   — fix: repair failing tests

All three must be green before a PR is mergeable. Evidence must include the literal output from each gate.

Anti-Patterns

Running tests before format and clippy — wastes time if format fails.
Reporting "tests pass" without showing the result summary line.
Treating ignored count as failures — they are intentionally skipped.
Blocking work on open-mpm clippy errors that are pre-existing at HEAD.
Using cargo build as a substitute for cargo test — build success does not validate behavior.
Running cargo test workspace-wide without confirming crate name aliases (e.g., use -p tga not -p trusty-git-analytics).

Agent Skills: Rust Quality Gate Protocol

Install this agent skill to your local

Skill Files