@mrciphersmith/keryx 0.3.3 → 0.3.6

package/src/gdskills/bundled/stacks/rust/governance/scout.json

@@ -0,0 +1,32 @@
+[
+  {
+    "query": "Use when cargo build/cargo clippy fails, or Cargo.toml/Cargo.lock are out of sync -- resolves dependency/edition/MSRV mismatches, borrow-checker and lifetime errors, trait-bound errors, clippy failures, and a failing cargo test, with the smallest root-cause fix.",
+    "decision": "fork",
+    "topMatch": "go/go-build-fix",
+    "recordedAt": "2026-09-25T18:06:22.209Z",
+    "skillName": "rust-build-fix",
+    "justification": "top match go/go-build-fix is the same build-fix category but for a different language's own toolchain (go build/vet vs. cargo build/clippy/borrow-checker errors), not a substitute; a Rust-scoped fork is warranted since Go's build-fix has no visibility into Rust's own trait-bound/borrow-checker/cargo failure modes."
+  },
+  {
+    "query": "Use when reviewing a Rust change for ownership, panic, and safety risks -- unwrap/expect on fallible input, unnecessary clone as a borrow-checker workaround, unjustified or oversized unsafe blocks, blocking calls in async fn, unchecked arithmetic/indexing on untrusted data, and error types that lose their source. Read-only, no edits.",
+    "decision": "create",
+    "topMatch": "angular/angular-code-review",
+    "recordedAt": "2026-09-25T18:06:22.532Z",
+    "skillName": "rust-code-review"
+  },
+  {
+    "query": "Use when implementing or extending a feature in a Rust crate -- Cargo.toml/edition/workspace layout, ownership and borrowing, Result/Option error handling with the ? operator, thiserror/anyhow conventions, trait and generic design, and avoiding blocking calls in async fn.",
+    "decision": "create",
+    "topMatch": "rust/rust-build-fix",
+    "recordedAt": "2026-09-25T18:06:22.848Z",
+    "skillName": "rust-implementation"
+  },
+  {
+    "query": "Use when a Rust crate's own test suite needs writing, extending, or fixing with cargo test -- #[cfg(test)] unit tests, tests/ integration tests, multi-case assertions built as a Vec of structs, #[tokio::test] async tests joined properly, proptest/quickcheck property-based checks on a Rust struct or enum, and criterion benchmarks.",
+    "decision": "create",
+    "topMatch": "rust/rust-implementation",
+    "recordedAt": "2026-09-25T18:06:23.160Z",
+    "skillName": "rust-testing",
+    "justification": "top match go/go-testing is the same test-authoring category but for a different language's own idiom (table-driven Go subtests vs. Rust's #[cfg(test)] modules, proptest, criterion benchmarks), not a substitute; a Rust-scoped fork is warranted since Go's testing skill has no Rust-specific guidance."
+  }
+]

package/src/gdskills/bundled/stacks/rust/pack.json

@@ -0,0 +1,42 @@
+{
+  "id": "rust",
+  "family": "language",
+  "modules": ["rust-rules", "rust-skills"],
+  "detectionMarkers": ["rust"],
+  "provenance": {
+    "origin": "authored",
+    "sourceRef": "flow 335, Wave 4 batch 3"
+  },
+  "stability": "experimental",
+  "skills": {
+    "implement": ["rust-implementation"],
+    "test": ["rust-testing"],
+    "review": ["rust-code-review"],
+    "build-fix": ["rust-build-fix"],
+    "migrate": []
+  },
+  "agentProfile": {
+    "displayName": "Rust",
+    "auditFocus": [
+      "an .unwrap()/.expect() on a Result or Option built from untrusted or fallible external input (a network response, a file read, a parsed argument) instead of propagating with ?",
+      "an unsafe block with no # Safety doc comment stating the invariants the caller must uphold, or one wider than the specific operation that requires it",
+      "a borrow-checker conflict worked around with an unnecessary .clone() instead of restructuring ownership, splitting borrows, or using a reference",
+      "a blocking call (std::thread::sleep, a synchronous file/network read, a std::sync::Mutex held across an .await) inside an async fn instead of the async equivalent or spawn_blocking",
+      "an integer operation on untrusted input with no overflow/bounds check (raw arithmetic or indexing instead of checked_add/get/saturating_* where the value could be attacker-influenced)",
+      "a custom error type that loses the underlying cause instead of using #[source]/#[from] (thiserror) or .context() (anyhow) to preserve it"
+    ],
+    "buildCommands": [
+      "cargo build --all-targets",
+      "cargo clippy --all-targets -- -D warnings",
+      "cargo fmt --check",
+      "cargo test"
+    ],
+    "fixGuardrails": [
+      "Never silence a clippy finding with a blanket #[allow(clippy::all)] or a lint-level allow instead of fixing the root cause.",
+      "Never add .unwrap()/.expect() to make a type error or a Result mismatch disappear; propagate with ? or handle the error explicitly.",
+      "Never bump the edition or MSRV in Cargo.toml just to make an error disappear without understanding why it changed.",
+      "Never delete or skip a failing test to reach a green build.",
+      "Never widen an unsafe block or drop a # Safety comment to silence a compiler or clippy complaint about it."
+    ]
+  }
+}

package/src/gdskills/bundled/stacks/rust/rules/coding-style.mdc

@@ -0,0 +1,93 @@
+---
+extends: common
+paths: ["**/*.rs"]
+metadata:
+  origin: authored
+---
+
+# Rust coding style
+
+Narrows `core-common-rules`' stack-agnostic style rules to modern Rust
+(2021/2024 edition) idiom. Applies only to `*.rs` files — everything not
+Rust-specific still comes from the common rules this file `extends`.
+
+## Naming and structure
+
+- `snake_case` for functions, methods, variables, and modules;
+  `UpperCamelCase` for types, traits, and enum variants; `SCREAMING_SNAKE_CASE`
+  for constants and statics — `rustfmt`/`rustc` will warn on a mismatch.
+- A crate's public surface lives at the paths re-exported from `lib.rs`;
+  keep implementation details `pub(crate)` or private and re-export
+  deliberately, rather than making every module `pub` by default.
+- An identifier's name shrinks with its scope: a short-lived closure
+  parameter can be `x`, a `pub` function gets a full descriptive name.
+
+## Ownership, borrowing, and errors
+
+- Prefer borrowing (`&T`/`&mut T`) over taking ownership when the callee
+  does not need to keep the value; prefer `&str`/`&[T]` parameters over
+  `&String`/`&Vec<T>` so callers can pass either owned or borrowed data.
+- Resolve a borrow-checker conflict by restructuring ownership, splitting
+  the borrow, or shortening a borrow's lifetime — reach for `.clone()`
+  only when the value genuinely needs to be duplicated, and say why in a
+  comment when the clone is non-obvious; an unnecessary `.clone()` used
+  purely to silence the borrow checker is a cost paid on every call.
+- `Result<T, E>` for anything that can fail; propagate with the `?`
+  operator rather than a manual `match` that just re-returns `Err`.
+  `Option<T>` for genuine absence, not as a substitute for `Result` on an
+  operation that can fail for a reason worth naming.
+- Never call `.unwrap()`/`.expect()` on a `Result`/`Option` built from
+  fallible or untrusted input (a parsed argument, a network response, a
+  file read, a map lookup on external data) in production code without a
+  stated invariant that makes it truly infallible; prefer `?`, a `match`,
+  or a combinator (`unwrap_or`, `unwrap_or_else`, `ok_or`) that handles the
+  failure path.
+- Use `thiserror` to derive `std::error::Error` for a library's own error
+  enum (`#[error("...")]` per variant, `#[source]`/`#[from]` to preserve
+  the underlying cause); use `anyhow::Result`/`.context()`/`.with_context()`
+  in application/binary code that just needs to propagate and annotate
+  errors up to `main`, not to dictate a precise error type to its own
+  callers.
+
+## Traits and generics
+
+- Accept the narrowest trait bound a function actually needs (`AsRef<str>`
+  over `&String`, `Iterator<Item = T>` over `Vec<T>`) so callers keep
+  flexibility in what they pass.
+- Prefer returning a concrete type (`impl Trait` in return position) over
+  a boxed trait object (`Box<dyn Trait>`) unless runtime polymorphism
+  (a heterogeneous collection, a plugin-style callback list) is actually
+  needed — `impl Trait` avoids the allocation and indirection.
+- Derive `Debug`, `Clone`, `PartialEq`, etc. instead of hand-writing them
+  when the type's fields support it; hand-write only when the derived
+  behavior would be wrong for the type's invariants.
+
+## Iterators and control flow
+
+- Prefer an iterator chain (`.map`/`.filter`/`.fold`/`.collect`) over a
+  hand-rolled indexed loop when it expresses the transformation as clearly
+  — but do not force a chain that reads worse than a plain `for` loop just
+  to look idiomatic; readability wins over either style has priority.
+- Use pattern matching (`match`, `if let`, `let else`) to handle every
+  variant of an enum explicitly; avoid a catch-all `_ =>` arm on a `match`
+  over your own enum where a new variant should force every call site to
+  be revisited.
+
+## Async conventions (when the crate uses async)
+
+- `async fn` for I/O-bound work; never call a blocking operation
+  (`std::thread::sleep`, a synchronous file/socket read, a `std::sync`
+  primitive held across an `.await` point) inside an `async fn` running on
+  a multi-threaded executor — use the async equivalent (`tokio::time::sleep`,
+  `tokio::fs`, `tokio::sync::Mutex`) or `tokio::task::spawn_blocking` for
+  genuinely CPU-bound or blocking work.
+- Keep a `Mutex` guard's scope as short as possible and never hold one
+  across an `.await`; prefer `tokio::sync::Mutex` when the lock itself
+  must be held across an await point, `std::sync::Mutex` when it never is.
+
+## Formatting and lints
+
+- Format with `rustfmt` (`cargo fmt`) before finishing a change; do not
+  hand-format around a formatter that is already configured.
+- Run `cargo clippy -- -D warnings` and fix findings at the root cause
+  rather than adding a blanket `#[allow(...)]`.

package/src/gdskills/bundled/stacks/rust/rules/patterns.mdc

@@ -0,0 +1,85 @@
+---
+extends: common
+paths: ["**/*.rs"]
+metadata:
+  origin: authored
+---
+
+# Rust patterns
+
+Narrows `core-common-rules`' stack-agnostic design guidance to idiomatic
+Rust design and its common anti-patterns. Applies only to `*.rs` files.
+
+## Crate and module layout
+
+- `src/lib.rs` (or `src/main.rs` for a binary) is the crate root; group
+  related functionality into modules under `src/`, each with a clear
+  single responsibility — a module that only holds shared types with no
+  behavior ("models", "types", "common") invites the same cross-module
+  coupling a Go "utils" package does.
+- A workspace (`[workspace]` in the root `Cargo.toml`) splits genuinely
+  independent crates (a library plus a CLI that depends on it, or several
+  services sharing a core crate) — do not default to a workspace for a
+  single-binary project that has no reason to publish separate crates.
+- Keep `pub` surface intentional: re-export the types callers need from
+  `lib.rs`, keep internal modules `pub(crate)` or private so the compiler
+  (not convention) enforces the boundary.
+
+## Error handling design
+
+- A library crate defines its own error enum with `thiserror`, one
+  variant per failure mode, `#[source]`/`#[from]` on any variant that
+  wraps another error so `source()` and `?`-based conversion both work —
+  never collapse distinct failure modes into a single `Other(String)`
+  variant that erases the caller's ability to match on what happened.
+- An application/binary crate uses `anyhow::Result` at its outer layers
+  and `.context("doing x")`/`.with_context(|| ...)` at each call to `?`
+  that crosses a meaningful boundary, so a failure's final error chain
+  reads as a story, not a single opaque message.
+- Never use a `Result<T, String>`/`Result<T, Box<dyn Error>>` as a
+  permanent design in a library — `Box<dyn Error>` is a reasonable
+  quick-prototype return type but forces every caller to string-match or
+  downcast; graduate to a concrete `thiserror` enum once the error shapes
+  stabilize.
+
+## Ownership-driven API design
+
+- Take `&self`/`&mut self`/`self` deliberately: `self` (by value) only
+  when the method consumes or transforms the value into something else
+  (a builder's terminal `.build()`), `&mut self` when it mutates in place,
+  `&self` otherwise.
+- The typestate/builder pattern (a `FooBuilder` with chained `with_x`
+  methods returning `Self`, a terminal `.build() -> Result<Foo, ...>`) for
+  a constructor with many optional parameters, instead of a boolean-heavy
+  positional signature.
+- Prefer newtypes (`struct UserId(u64);`) over a bare primitive when a
+  value has domain meaning distinct from its representation — the
+  compiler then rejects passing a `ProductId` where a `UserId` is
+  expected, which a bare `u64` parameter cannot.
+
+## Trait design
+
+- Define a trait at the point of abstraction a consumer actually needs
+  (an `impl Trait` argument or a generic bound), sized to the methods that
+  consumer calls — a trait with every method the concrete type happens to
+  have is not an abstraction, it is a restatement of the type.
+- Prefer generics (`fn process<T: Processor>(p: &T)`) for a hot path where
+  monomorphization's code-size cost is acceptable and static dispatch
+  matters; use `Box<dyn Trait>`/`&dyn Trait` when you need a heterogeneous
+  collection or a boundary (a plugin registry, a callback list) where the
+  concrete type varies at runtime.
+
+## Anti-patterns to flag
+
+- A `.clone()` inserted to make the borrow checker pass without
+  considering whether restructuring ownership or borrowing differently
+  would avoid the copy — flag any clone in a hot path with no comment
+  explaining why it is necessary.
+- Stringly-typed errors (`Err(format!("something went wrong: {e}"))`
+  returned as `Result<T, String>`) in a library crate instead of a
+  `thiserror`-derived enum a caller can match on.
+- A "god module" (`utils`, `helpers`, `common`) accumulating unrelated
+  free functions — split by what the code actually does, the same
+  anti-pattern flagged in Go/Python's own pattern rules.
+- `unwrap()`/`expect()` reached for as a shortcut past a type error during
+  development and never revisited before the change ships.

package/src/gdskills/bundled/stacks/rust/rules/security.mdc

@@ -0,0 +1,85 @@
+---
+extends: common
+paths: ["**/*.rs"]
+metadata:
+  origin: authored
+---
+
+# Rust security
+
+Narrows `core-common-rules`' stack-agnostic security rules to Rust-specific,
+OWASP-relevant risks and the safe standard-library/ecosystem API to use
+instead. `unsafe` and panic-on-untrusted-input risks can appear anywhere a
+crate touches attacker-influenced data, so this file stays broad rather
+than narrowing to a single subdirectory.
+
+## `unsafe` blocks
+
+- Every `unsafe` block carries a `# Safety` doc comment (on the block or
+  the function containing it) stating the exact invariants the caller or
+  the block itself must uphold for the operation to be sound — not a
+  generic "this is safe" note, but the specific precondition (pointer
+  validity, alignment, lifetime, no concurrent mutation) that makes it so.
+- Keep an `unsafe` block as small as possible — wrap only the operation
+  that actually requires it (a raw pointer deref, an FFI call, a
+  `mem::transmute`), not the surrounding safe code, so the audited surface
+  stays minimal.
+- Never widen an `unsafe` block or drop its `# Safety` comment to silence
+  a compiler or clippy complaint; if the invariant cannot be stated, the
+  code is not actually sound and needs a different approach.
+
+## Panics on untrusted input
+
+- Never call `.unwrap()`/`.expect()` on a `Result`/`Option` derived from
+  network input, file contents, CLI arguments, or any other
+  attacker-influenced source — a panic there is a denial-of-service vector
+  (the process/thread aborts) even when the underlying bug is minor.
+  Propagate with `?`, or handle explicitly.
+- Guard array/slice indexing on untrusted-derived indices with `.get(i)`
+  (returns `Option`) instead of `arr[i]` (panics out of bounds); guard
+  integer arithmetic on untrusted values with `checked_add`/`checked_mul`/
+  `saturating_*`/`wrapping_*` as the operation's semantics require, instead
+  of a bare `+`/`*` that panics on overflow in debug builds and silently
+  wraps in release builds — both are wrong for a value an attacker
+  influences.
+
+## FFI boundaries
+
+- Validate every value crossing an `extern "C"` boundary before trusting
+  it — a raw pointer from C is not guaranteed non-null, valid, or
+  correctly aligned; check before dereferencing, and document the
+  ownership/lifetime contract (who frees it, using what allocator) in the
+  function's `# Safety` comment.
+- Never let a Rust panic unwind across an `extern "C"` boundary — undefined
+  behavior in most toolchains; catch it with `std::panic::catch_unwind` at
+  the FFI edge and convert it to an error code instead.
+
+## Dependency and supply-chain hygiene
+
+- Run `cargo audit` (or the project's already-configured equivalent) when
+  introducing or updating a dependency, or when asked to check for known
+  vulnerabilities — it checks `Cargo.lock` against the RustSec advisory
+  database.
+- Pin dependency versions deliberately in `Cargo.toml`; avoid a bare `*`
+  or an overly wide range that lets an unreviewed major/minor bump in.
+
+## Deserialization
+
+- When deserializing untrusted input with `serde`, apply size/depth limits
+  appropriate to the format and deserializer (a bounded reader, a
+  recursion-depth guard, or the deserializer's own limit configuration
+  where it exposes one) — an unbounded deserialize of attacker-controlled
+  JSON/bincode/etc. is a memory-exhaustion or stack-overflow
+  (deeply-nested structures) vector.
+- Never derive `Deserialize` for a type and then trust its field values
+  as pre-validated — validate ranges/formats/invariants after
+  deserializing, the same as any other externally-sourced value.
+
+## Randomness and secrets
+
+- Use a CSPRNG (the `rand` crate's default `ThreadRng`/`OsRng`, or the
+  `getrandom`/`ring` crates) for anything security-sensitive — tokens,
+  session IDs, keys, nonces; a non-cryptographic PRNG seeded predictably
+  is unsuitable for secrets even when its API looks the same.
+- Never hard-code a credential, API key, or signing secret in source; load
+  it from environment/secret storage the project already uses.

package/src/gdskills/bundled/stacks/rust/rules/testing.mdc

@@ -0,0 +1,82 @@
+---
+extends: common
+paths: ["**/*.rs"]
+metadata:
+  origin: authored
+---
+
+# Rust testing
+
+Narrows `core-common-rules`' stack-agnostic testing rules to Rust's built-in
+`#[test]` framework and its common extensions. Applies only to `*.rs` files.
+
+## Layout and naming
+
+- Unit tests live in a `#[cfg(test)] mod tests { use super::*; ... }` block
+  at the bottom of the file they test, giving them access to private
+  items; integration tests (exercising only the crate's public API) live
+  under `tests/` at the crate root, one file per test binary.
+- Name a test function for the behavior it verifies
+  (`rejects_negative_amount`, not `test1` or `test_validate`); group
+  related cases as separate `#[test]` functions or, for many similar
+  inputs, a parameterized loop/table within one function.
+- Fixture/golden data a test reads lives under `tests/fixtures/` (or a
+  crate-local `testdata/` if the project already uses that convention) —
+  match whatever the crate already does rather than inventing a new one.
+
+## Test structure
+
+- Prefer a small table of cases (a `Vec` of a local struct, or a slice of
+  tuples) iterated in one `#[test]` function over many near-duplicate test
+  functions, when the cases share the same assertion shape — mirrors the
+  table-driven convention from other stacks, adapted to Rust's lack of a
+  built-in subtest runner.
+- Assert with `assert_eq!`/`assert!`/`assert_ne!` from `std`, or the
+  project's already-adopted assertion crate (`pretty_assertions`,
+  `assert_matches`) — do not introduce a new assertion library into a
+  crate that has not adopted one.
+- For a `Result`-returning function, assert the specific error variant
+  (`assert!(matches!(err, MyError::NotFound { .. }))` or
+  `assert_eq!(err, MyError::NotFound)` when the error implements
+  `PartialEq`) rather than only `assert!(result.is_err())`, which passes
+  for the wrong failure just as readily as the right one.
+
+## Async tests
+
+- `#[tokio::test]` (or the project's already-configured async test
+  attribute) for an `async fn` test body; never block a `#[test]`
+  function's thread on a future with a hand-rolled executor when the
+  project already depends on `tokio`.
+- Join spawned tasks with `.await` on their `JoinHandle`, or a channel,
+  before asserting — never synchronize with `std::thread::sleep`/
+  `tokio::time::sleep` to "give a spawned task time to finish"; that is
+  non-deterministic under load and flakes in CI exactly like a Go test
+  that sleeps instead of joining a goroutine.
+
+## Property-based and fuzz testing
+
+- Reach for `proptest` or `quickcheck` (whichever the crate already
+  depends on) for a function with a large, structured input space
+  (a parser, a serializer round-trip) instead of hand-writing dozens of
+  near-identical example-based cases.
+- `cargo fuzz` (built on `libFuzzer`) for a parser or decoder that touches
+  untrusted input formats directly; note in the report that fuzzing runs
+  separately from `cargo test` and is not part of the default CI test run
+  unless the project has wired it in.
+
+## Benchmarks
+
+- Use `criterion` (the de facto ecosystem standard) for a benchmark that
+  needs statistical rigor (warm-up, outlier detection, regression
+  comparison across runs) rather than the unstable built-in `#[bench]`
+  attribute, which requires nightly.
+
+## Running and determinism
+
+- Run `cargo test` (add `--all-features`/`--workspace` when the project's
+  CI does) before reporting tests as passing; a test relying on wall-clock
+  timing, real network access, or shared global state is a flake risk —
+  prefer a fake clock, a mock boundary, or `#[serial]` (from the `serial_test`
+  crate) for tests that must not run concurrently.
+- New behavior gets a new test in the same change; a bug fix gets a
+  regression test that fails before the fix and passes after.

package/src/gdskills/bundled/stacks/rust/skills/rust-build-fix/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: rust-build-fix
+description: "Use when cargo build/cargo clippy fails, or Cargo.toml/Cargo.lock are out of sync -- resolves dependency/edition/MSRV mismatches, borrow-checker and lifetime errors, trait-bound errors, clippy failures, and a failing cargo test, with the smallest root-cause fix."
+triggers:
+  - "cargo build is failing"
+  - "fix Cargo.toml Cargo.lock mismatch"
+  - "resolve this Rust borrow checker error"
+  - "cargo clippy is failing"
+  - "this Rust trait bound isn't satisfied"
+  - "cargo test is failing"
+metadata:
+  origin: authored
+  category: build-fix
+  version: "1.0.0"
+  compatible_harnesses: "claude,codex,cursor,zed,opencode"
+license: "MIT"
+---
+
+# Rust build fix (2021/2024 edition)
+
+Resolve a `cargo build`/`cargo clippy` failure, a `Cargo.toml`/`Cargo.lock`
+mismatch, a borrow-checker/lifetime error, an unsatisfied trait bound, or a
+failing `cargo test` — with the smallest change that fixes the actual root
+cause. `rules/coding-style.mdc` and `rules/security.mdc` govern what a
+"correct" fix looks like; this skill never reaches for a suppression
+instead of a fix.
+
+## Workflow
+
+### Step 1: Reproduce and classify
+
+```bash
+cargo build --all-targets
+cargo clippy --all-targets -- -D warnings
+```
+
+Read the exact error text (`rustc`'s diagnostics name the error code, e.g.
+`E0502`, `E0308`) and classify it:
+
+- **Compile error** (type mismatch, undefined item, wrong argument count).
+- **Borrow checker / lifetime** (`E0502` conflicting borrows, `E0499`
+  multiple mutable borrows, a lifetime that doesn't live long enough).
+- **Trait bound** (`the trait bound ... is not satisfied`, a missing
+  `impl` the code assumes exists).
+- **Dependency/edition/MSRV** (`Cargo.lock` stale against `Cargo.toml`,
+  a version conflict, a feature used past the declared `edition`/
+  `rust-version`).
+- **Clippy finding** (a lint from `cargo clippy`'s default set or the
+  project's configured groups).
+- **Test failure** (`cargo test` reports a failing assertion or panic).
+
+### Step 2: Fix by category
+
+**Dependency/edition/MSRV:** run `cargo update -p <crate>` for a targeted
+bump, or `cargo update` for a full re-resolve, when `Cargo.lock` is simply
+stale against `Cargo.toml`'s requirements. For a genuine version conflict,
+check `cargo tree -i <crate>` (what depends on the conflicting version)
+before bumping by hand. Only raise `edition`/`rust-version` in
+`Cargo.toml` when the code genuinely needs a feature that edition/MSRV
+introduces, and say so in the report — never to make an unrelated error
+disappear.
+
+**Borrow checker / lifetime:** read what the compiler's own suggestion
+proposes first (`rustc` usually names the exact conflicting borrows or
+missing lifetime). Prefer restructuring ownership, splitting a borrow, or
+shortening a lifetime over reaching for `.clone()`; a clone is an
+acceptable fix only when the value genuinely needs to be duplicated —
+say so in the report either way (`rules/patterns.mdc`).
+
+**Trait bound:** check whether the missing `impl` should exist on the
+type in question (derive it, or implement it) versus whether the calling
+code's generic bound is wider than it needs to be. Do not add a blanket
+bound or an unnecessary `Box<dyn Trait>` conversion just to make the
+compiler stop complaining without understanding which side is wrong.
+
+**Clippy finding:** fix the underlying issue the lint names (an
+unnecessary clone, a `.unwrap()` on fallible input, a needless
+collect). Never add `#[allow(clippy::...)]` or a blanket
+`#[allow(clippy::all)]` whose only purpose is to make the checker stop
+complaining without addressing what it found.
+
+**Test failure:** read the assertion output and the code path it
+exercises; fix the actual bug the test caught. Never delete, skip
+(`#[ignore]`), or loosen the assertion to reach a green build unless the
+test itself is proven wrong (say so explicitly in the report).
+
+### Step 3: Verify
+
+```bash
+cargo build --all-targets
+cargo clippy --all-targets -- -D warnings
+cargo fmt --check
+cargo test
+```
+
+All must exit 0 before reporting done.
+
+### Step 4: Report
+
+```
+Fixed: Cargo.lock stale against a version bump in Cargo.toml (ran `cargo update -p tokio`)
+  - Root cause: Cargo.lock predated a minor version bump in Cargo.toml
+  - cargo build/clippy -D warnings/fmt --check/test all pass
+```
+
+State the root cause in one sentence, not just "fixed the error."
+
+## Rules
+
+- Find and fix the smallest change that addresses the actual root cause —
+  never widen a fix beyond what the failure requires.
+- NEVER add `#[allow(clippy::...)]` (especially a blanket
+  `#[allow(clippy::all)]`) to silence a clippy finding instead of fixing
+  what it found.
+- NEVER raise `edition`/`rust-version` in `Cargo.toml`, or bump a major
+  dependency version, just to make an error disappear without
+  understanding why it changed.
+- NEVER reach for `.clone()`/`.unwrap()` purely to make the compiler stop
+  complaining without considering whether it addresses the actual error.
+- NEVER delete, skip (`#[ignore]`), or loosen an assertion to reach a
+  green `cargo test`.
+
+## Red Flags
+
+| Rationalization | Why it is wrong |
+|---|---|
+| "I'll add `#[allow(clippy::redundant_clone)]` here so the linter stops complaining" | Silences the finding without addressing whether the clone is actually needed; check the ownership shape instead. `redundant_clone` lives in clippy's `nursery` group (allow-by-default), so it only surfaces when that group is enabled -- but once it fires, suppressing it is the same mistake as suppressing any other clippy finding |
+| "Bumping the edition to 2024 makes this compile" | Changes the crate's declared minimum edition for every consumer to dodge one error; understand why the code needs 2024 first, or fix the code to work at the declared edition |
+| "This test is flaky, I'll add `#[ignore]` for now" | Hides a real bug or a real flake source instead of fixing the underlying issue; find the actual cause |
+| "I'll just `.clone()` past this borrow error" | A reflexive clone can mask an ownership design issue the compiler is correctly catching; read the compiler's own suggestion first |
+
+## Verification
+
+Do not report the fix done until all of the following hold:
+
+- `cargo build --all-targets`, `cargo clippy --all-targets -- -D warnings`,
+  `cargo fmt --check`, and `cargo test` all exit 0.
+- The change is the smallest one that addresses the stated root cause —
+  no unrelated files touched.
+- The report states the root cause in one sentence, not just "build now
+  passes."

package/src/gdskills/bundled/stacks/rust/skills/rust-build-fix/evals.json

@@ -0,0 +1,78 @@
+{
+  "triggers": {
+    "positive": [
+      "cargo build is failing with a trait bound not satisfied error",
+      "I bumped a dependency version and now cargo build complains the lockfile doesn't match Cargo.toml anymore, what do I do?",
+      "The compiler won't let me borrow `orders` as mutable twice at the same time in this function, how do I restructure it so it compiles?",
+      "cargo clippy is reporting a needless clone lint",
+      "This Rust code has a lifetime error that won't compile",
+      "cargo test is failing with a panic in the order crate, fix the build"
+    ],
+    "negative": [
+      "npm install is failing with a peer dependency conflict",
+      "go build is failing for this Go module",
+      "pip install is failing for this Python project",
+      "Implement a new Rust feature in the order crate",
+      "Review this Rust diff for unsafe blocks and unwrap panics",
+      "Write Rust tests for this function",
+      "Our CMake configure step is failing with a missing header error"
+    ]
+  },
+  "scenarios": [
+    {
+      "id": "lockfile-mismatch",
+      "prompt": "cargo build --locked fails saying Cargo.lock is out of date after I bumped a dependency version in Cargo.toml (this is the same command our CI runs). How do I fix it?",
+      "strictness": "high",
+      "expected_behavior": [
+        {
+          "grader": "judge",
+          "rubric": "A correct answer identifies that Cargo.lock is stale relative to Cargo.toml's requirements after the dependency bump and fixes it by running cargo update (or a targeted cargo update -p <crate>). For a genuine version conflict it checks cargo tree -i <crate> before bumping another dependency's version by hand, rather than routing around the error some other way.",
+          "pass_criteria": [
+            "Names `cargo update` or `cargo update -p <crate>`, run from the crate/workspace root, as the concrete command that resolves the stale Cargo.lock -- not merely 'sync the files' or 'run the tool that fixes this'.",
+            "States the root cause: Cargo.lock no longer matches what Cargo.toml now requires after the version bump, not just 'run this command' with no explanation.",
+            "Either names a concrete verification step afterward (`cargo build`/`cargo test`) or does not suggest skipping verification."
+          ],
+          "fail_criteria": [
+            "Recommends raising the `edition` or `rust-version` in Cargo.toml to make the error go away, or bumping another dependency's version by hand without checking what depends on it, as a substitute for running `cargo update`.",
+            "Recommends hand-editing the checksum/version lines in Cargo.lock directly instead of regenerating it with `cargo update`."
+          ]
+        }
+      ],
+      "calibration": {
+        "known_right": "This means Cargo.lock no longer matches what Cargo.toml now requires after you bumped the dependency version. The fix is `cargo update -p <crate-name>` (or a plain `cargo update` if you want everything re-resolved) run from the crate or workspace root -- it recomputes Cargo.lock against Cargo.toml's requirements, picking up the new version and resolving anything that needs to shift alongside it. If the bump pulls in a genuine version conflict rather than a simple stale-lock error, don't just bump another crate's version by hand -- run `cargo tree -i <conflicting-crate>` first to see what's actually pinning the conflicting version, so you understand the dependency shape before changing it. After `cargo update` finishes, re-run `cargo build` and `cargo test` to confirm everything is consistent again before considering this done. Avoid hand-editing the checksums or version lines in Cargo.lock directly; that file is generated and meant to be regenerated by tooling, not patched by hand.",
+        "known_wrong": "Honestly the fastest fix here is to bump the edition in Cargo.toml to \"2024\" -- that usually makes Cargo.lock errors like this go away without you needing to figure out what `cargo update` would even change. Just edit the `edition = \"2021\"` line and re-run the build; if it still complains, bump another dependency's version in Cargo.toml up a bit further too until the error clears. You don't really need to run `cargo tree` or dig into the dependency graph for a simple lockfile mismatch like this -- that's overkill for what's usually just a version string being out of date.",
+        "vague": "This is just a dependency sync issue -- make sure your Cargo files are consistent with each other again and the build should pass.",
+        "subtle_wrong": "Bump the dependency's version in Cargo.toml directly to match what your code now needs, then try `cargo build` again -- if Cargo.lock still complains about a missing checksum for that version, add the missing hash/version entry to Cargo.lock by hand so the two files line up. That gets you to a green build without having to run `cargo update` and re-resolve everything else it might touch."
+      }
+    },
+    {
+      "id": "no-clippy-allow-suppression",
+      "prompt": "cargo clippy (with the nursery group enabled) is flagging a redundant clone in my Rust code. How should I fix it?",
+      "strictness": "high",
+      "expected_behavior": [
+        {
+          "grader": "judge",
+          "rubric": "A correct answer fixes the actual redundant clone -- removes it and borrows instead, or restructures ownership so the clone isn't needed -- instead of suppressing the lint with #[allow(clippy::...)] (especially a blanket #[allow(clippy::all)]), and instead of keeping the clone with only a comment explaining it away when the lint indicates it is genuinely unnecessary.",
+          "pass_criteria": [
+            "Identifies that the clone is unnecessary and should be removed in favor of borrowing (a reference) or restructuring ownership, not kept.",
+            "Shows the concrete fix direction: pass a reference (e.g. `&value` or changing the parameter type to `&T`) instead of the owned clone, or an equivalent restructuring -- not merely a statement that the clone 'should be looked at'.",
+            "Does not rely on `#[allow(clippy::...)]` (or a blanket `#[allow(clippy::all)]`) as the fix for the flagged finding."
+          ],
+          "fail_criteria": [
+            "Recommends adding `#[allow(clippy::redundant_clone)]` or `#[allow(clippy::all)]` to silence the finding instead of removing the clone.",
+            "Keeps the clone unchanged and only adds a comment justifying it, when the lint's own message indicates the value can simply be borrowed instead."
+          ]
+        }
+      ],
+      "calibration": {
+        "known_right": "clippy's `redundant_clone` (part of the `nursery` group, allow-by-default, which is why it only shows up once that group is enabled) is telling you the value gets duplicated somewhere it could just be borrowed instead -- that usually means a function parameter or a call site is taking ownership (`T` or `.clone()`) where a reference (`&T`) would work just as well. Look at how the cloned value is used afterward: if the caller still needs its own copy and the callee only reads the value, change the callee's signature to accept `&T` and drop the `.clone()` at the call site. If the callee genuinely needs to own or mutate its own copy independent of the caller, the clone might be legitimate -- in that case leave it, but consider whether an owned move (transferring ownership instead of cloning) is possible if the caller doesn't need the value afterward either. Don't reach for `#[allow(clippy::redundant_clone)]` here -- that just tells the linter to stop looking, it doesn't address whether the clone was actually needed. Once you've fixed it, re-run `cargo clippy -- -D warnings` (with the nursery group enabled) to confirm the finding is actually resolved rather than merely hidden.",
+        "known_wrong": "The simplest fix is to just add `#[allow(clippy::redundant_clone)]` above the function -- that clone genuinely doesn't matter here for a value this small, and it stops clippy from flagging it every time CI runs. You don't need to touch the actual signature or figure out whether borrowing would work; the allow attribute is exactly what it's for. If clippy flags something similar nearby, you can add the same allow there too rather than working through each clone individually.",
+        "vague": "You should fix that clone properly instead of suppressing the finding -- make sure it's actually addressed before you call this done.",
+        "subtle_wrong": "That redundant_clone finding is easy to clear without touching the surrounding logic: leave the `.clone()` exactly where it is and add a comment above it explaining that it's there for simplicity, so future readers understand it's intentional. That way you're not silently ignoring clippy's feedback anymore, and you don't have to change the function's signature or verify that borrowing would actually work at every call site."
+      },
+      "anti_patterns": [
+        "#[allow(clippy"
+      ]
+    }
+  ]
+}