tribunal-kit 2.4.6 → 3.1.0

package/.agent/skills/rust-pro/SKILL.md

@@ -1,72 +1,293 @@
 ---
 name: rust-pro
-description: Master Rust 1.75+ with modern async patterns, advanced type system features, and production-ready systems programming. Expert in the latest Rust ecosystem including Tokio, axum, and cutting-edge crates. Use PROACTIVELY for Rust development, performance optimization, or systems programming.
+description: Master Rust 1.75+ with modern async patterns, ownership/borrowing, lifetimes, traits, error handling with thiserror/anyhow, async Tokio runtime, axum web framework, serde serialization, and systems programming. Use when building Rust services, CLI tools, WebAssembly, or performance-critical systems.
 allowed-tools: Read, Write, Edit, Glob, Grep
-version: 1.0.0
-last-updated: 2026-03-12
+version: 2.0.0
+last-updated: 2026-03-30
 applies-to-model: gemini-2.5-pro, claude-3-7-sonnet
 ---
 
-# Rust Development — Production Principles
-
-> Rust's compiler is not your enemy. It is the most thorough code reviewer you will ever have.
-> Learn to read its errors as design feedback, not roadblocks.
+# Rust Pro — Rust 1.75+ Systems Mastery
 
 ---
 
-## Ownership in Practice
+## Ownership & Borrowing
 
-The borrow checker enforces rules that prevent entire categories of bugs:
+### The Three Rules
 
 ```rust
-// Rule 1: Each value has exactly one owner
+// Rule 1: Each value has exactly ONE owner
 let s1 = String::from("hello");
-let s2 = s1;           // s1 is moved — no longer valid
-// println!("{}", s1); // ❌ compile error: value used after move
+let s2 = s1; // s1 is MOVED to s2 — s1 is no longer valid
+// println!("{s1}"); // ❌ compile error: value borrowed after move
+
+// Rule 2: You can have EITHER one mutable reference OR any number of immutable references
+let mut data = vec![1, 2, 3];
+let r1 = &data;     // ✅ immutable borrow
+let r2 = &data;     // ✅ second immutable borrow — fine
+// let r3 = &mut data; // ❌ compile error: cannot borrow as mutable while immutable borrows exist
+println!("{r1:?} {r2:?}");
+// r1 and r2 go out of scope here (NLL — Non-Lexical Lifetimes)
+let r3 = &mut data; // ✅ now fine — no immutable borrows active
+r3.push(4);
+
+// Rule 3: References must always be valid (no dangling pointers)
+// fn dangling() -> &String { // ❌ compile error
+//     let s = String::from("hello");
+//     &s // s is dropped at end of function — reference would dangle
+// }
+fn not_dangling() -> String {
+    String::from("hello") // ✅ return owned value
+}
+```
+
+### Common Ownership Patterns
+
+```rust
+// Clone when you need independent copies (has a cost — measure)
+let original = vec![1, 2, 3];
+let copy = original.clone(); // deep copy — both are independent
+
+// Rc<T> — shared ownership (single-threaded)
+use std::rc::Rc;
+let shared = Rc::new(vec![1, 2, 3]);
+let also_shared = Rc::clone(&shared); // cheap reference count increment
+// Both shared and also_shared point to the same data
+
+// Arc<T> — shared ownership (thread-safe)
+use std::sync::Arc;
+let thread_safe = Arc::new(vec![1, 2, 3]);
+let for_thread = Arc::clone(&thread_safe);
+std::thread::spawn(move || {
+    println!("{for_thread:?}");
+});
+
+// Cow<T> — Clone on Write (zero-copy when not modified)
+use std::borrow::Cow;
+fn process(input: &str) -> Cow<'_, str> {
+    if input.contains("bad") {
+        Cow::Owned(input.replace("bad", "good")) // allocated only if needed
+    } else {
+        Cow::Borrowed(input) // zero-copy
+    }
+}
+```
+
+---
+
+## Lifetimes
+
+```rust
+// Lifetime annotations tell the compiler how long references are valid
+// They DON'T change how long values live — they DESCRIBE existing relationships
+
+// ✅ Explicit lifetime: return value lives as long as the input
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    if x.len() > y.len() { x } else { y }
+}
 
-// Rule 2: Borrowing — multiple readers OR one writer
-let s = String::from("hello");
-let r1 = &s;          // immutable borrow — fine
-let r2 = &s;          // second immutable borrow — fine
-// let r3 = &mut s;   // ❌ can't borrow mutably while immutably borrowed
-println!("{} {}", r1, r2);
-let r3 = &mut s.clone(); // ✅ clone to get a new owned value
+// Struct with references (requires lifetime annotation)
+struct Config<'a> {
+    name: &'a str,
+    version: &'a str,
+}
+
+impl<'a> Config<'a> {
+    fn display(&self) -> String {
+        format!("{} v{}", self.name, self.version)
+    }
+}
+
+// 'static lifetime — lives for the entire program
+let s: &'static str = "I live forever"; // string literals are 'static
+// Owned types satisfy 'static (they own their data)
+fn takes_static(s: String) { /* String is 'static because it owns its data */ }
+
+// ❌ HALLUCINATION TRAP: Lifetime elision rules handle most cases
+// Don't add lifetimes unless the compiler asks for them
+// The compiler tells you exactly which annotations are needed
 ```
 
 ---
 
 ## Error Handling
 
-Rust has no exceptions. Errors are values. Design for them explicitly.
+### The `?` Operator & Result
 
 ```rust
+use std::fs;
 use std::io;
+
+// ✅ Propagate errors with ?
+fn read_config(path: &str) -> Result<Config, io::Error> {
+    let content = fs::read_to_string(path)?; // returns early on error
+    let config: Config = serde_json::from_str(&content)?;
+    Ok(config)
+}
+
+// ❌ HALLUCINATION TRAP: NEVER use .unwrap() in production code
+// .unwrap() panics on error — crashes the entire program
+// ❌ let file = File::open("config.json").unwrap();
+// ✅ let file = File::open("config.json")?;
+// ✅ let file = File::open("config.json").unwrap_or_default();
+// ✅ let file = File::open("config.json").map_err(|e| AppError::Io(e))?;
+```
+
+### thiserror (Library Errors)
+
+```rust
+// thiserror — for library code (structured error types)
 use thiserror::Error;
 
-// Define domain errors with thiserror
-#[derive(Error, Debug)]
+#[derive(Debug, Error)]
 pub enum AppError {
-    #[error("User {0} not found")]
-    UserNotFound(String),
-    
     #[error("Database error: {0}")]
     Database(#[from] sqlx::Error),
-    
+
+    #[error("Validation error: {field} — {message}")]
+    Validation { field: String, message: String },
+
+    #[error("Not found: {0}")]
+    NotFound(String),
+
+    #[error("Unauthorized")]
+    Unauthorized,
+
     #[error("IO error: {0}")]
-    Io(#[from] io::Error),
+    Io(#[from] std::io::Error),
+
+    #[error("JSON error: {0}")]
+    Json(#[from] serde_json::Error),
 }
 
-// Return Result in every function that can fail
-async fn get_user(id: &str) -> Result<User, AppError> {
-    let user = db.find_user(id).await?;  // the `?` operator propagates errors
-    user.ok_or_else(|| AppError::UserNotFound(id.to_string()))
+// #[from] auto-implements From<sqlx::Error> for AppError
+// So sqlx errors can be propagated with ? automatically
+```
+
+### anyhow (Application Errors)
+
+```rust
+// anyhow — for application code (quick error propagation)
+use anyhow::{Context, Result, bail, ensure};
+
+fn load_config(path: &str) -> Result<Config> {
+    let content = fs::read_to_string(path)
+        .context(format!("Failed to read config from {path}"))?;
+
+    let config: Config = serde_json::from_str(&content)
+        .context("Invalid JSON in config file")?;
+
+    ensure!(config.port > 0, "Port must be positive, got {}", config.port);
+
+    if config.name.is_empty() {
+        bail!("Config name cannot be empty");
+    }
+
+    Ok(config)
+}
+
+// Use thiserror for libraries, anyhow for applications
+// ❌ HALLUCINATION TRAP: Don't use anyhow in library crates
+// Libraries should expose structured error types (thiserror)
+// anyhow erases type information — callers can't match on specific errors
+```
+
+---
+
+## Traits
+
+### Defining & Implementing
+
+```rust
+trait Summarizable {
+    fn summary(&self) -> String;
+
+    // Default implementation
+    fn preview(&self) -> String {
+        let s = self.summary();
+        if s.len() > 50 {
+            format!("{}...", &s[..50])
+        } else {
+            s
+        }
+    }
 }
 
-// In main or handlers: match on the error
-match get_user("123").await {
-    Ok(user) => println!("Found: {}", user.name),
-    Err(AppError::UserNotFound(id)) => eprintln!("No user: {}", id),
-    Err(e) => eprintln!("Unexpected error: {}", e),
+struct Article {
+    title: String,
+    body: String,
+    author: String,
+}
+
+impl Summarizable for Article {
+    fn summary(&self) -> String {
+        format!("{} by {} — {}", self.title, self.author, &self.body[..100.min(self.body.len())])
+    }
+}
+
+// Trait bounds
+fn notify(item: &impl Summarizable) {
+    println!("Breaking: {}", item.summary());
+}
+
+// Equivalent with generics (more flexible)
+fn notify_generic<T: Summarizable + std::fmt::Display>(item: &T) {
+    println!("Breaking: {}", item.summary());
+}
+
+// where clause (cleaner for complex bounds)
+fn process<T, U>(t: &T, u: &U) -> String
+where
+    T: Summarizable + Clone,
+    U: std::fmt::Debug + Send,
+{
+    format!("{} — {:?}", t.summary(), u)
+}
+
+// Return impl Trait (hide concrete type)
+fn make_summarizer() -> impl Summarizable {
+    Article { title: "News".into(), body: "Content".into(), author: "Author".into() }
+}
+```
+
+### Common Standard Traits
+
+```rust
+// Derive common traits
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+// Display — for user-facing output
+use std::fmt;
+impl fmt::Display for Point {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "({}, {})", self.x, self.y)
+    }
+}
+
+// From/Into — type conversion
+impl From<(i32, i32)> for Point {
+    fn from((x, y): (i32, i32)) -> Self {
+        Point { x, y }
+    }
+}
+let p: Point = (10, 20).into(); // uses From automatically
+
+// Iterator
+struct Counter { count: u32, max: u32 }
+impl Iterator for Counter {
+    type Item = u32;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.count < self.max {
+            self.count += 1;
+            Some(self.count)
+        } else {
+            None
+        }
+    }
 }
 ```
 
@@ -74,167 +295,329 @@ match get_user("123").await {
 
 ## Async with Tokio
 
+### Runtime Setup
+
 ```rust
-use tokio;
+// Cargo.toml
+// [dependencies]
+// tokio = { version = "1", features = ["full"] }
 
 #[tokio::main]
 async fn main() {
-    // Concurrent tasks — run independently
-    let (result_a, result_b) = tokio::join!(
-        fetch_user(1),
-        fetch_products()
+    let result = fetch_data("https://api.example.com/data").await;
+    println!("{result:?}");
+}
+
+// For library code — don't use #[tokio::main], let the caller choose the runtime
+pub async fn fetch_data(url: &str) -> Result<String> {
+    let response = reqwest::get(url).await?;
+    let body = response.text().await?;
+    Ok(body)
+}
+```
+
+### Concurrent Tasks
+
+```rust
+use tokio::task;
+
+// Spawn concurrent tasks
+async fn parallel_fetch() -> Result<(Users, Posts)> {
+    let users_handle = task::spawn(async { fetch_users().await });
+    let posts_handle = task::spawn(async { fetch_posts().await });
+
+    let users = users_handle.await??; // first ? for JoinError, second for app error
+    let posts = posts_handle.await??;
+
+    Ok((users, posts))
+}
+
+// tokio::join! — run concurrently, wait for all
+async fn fetch_all() -> Result<(Users, Posts, Analytics)> {
+    let (users, posts, analytics) = tokio::join!(
+        fetch_users(),
+        fetch_posts(),
+        fetch_analytics(),
     );
+    Ok((users?, posts?, analytics?))
+}
+
+// tokio::select! — race multiple futures, take first to complete
+async fn fetch_with_timeout(url: &str) -> Result<String> {
+    tokio::select! {
+        result = fetch_data(url) => result,
+        _ = tokio::time::sleep(Duration::from_secs(5)) => {
+            Err(anyhow!("Request timed out after 5s"))
+        }
+    }
+}
+
+// ❌ HALLUCINATION TRAP: tokio::spawn requires 'static + Send
+// You cannot spawn a task referencing local variables without Arc/clone
+// ❌ let data = &local_data;
+//    tokio::spawn(async { process(data) }); // ❌ data doesn't live long enough
+// ✅ let data = Arc::new(local_data);
+//    let data_clone = Arc::clone(&data);
+//    tokio::spawn(async move { process(&data_clone) });
+```
+
+### Channels
+
+```rust
+use tokio::sync::{mpsc, oneshot, broadcast};
 
-    // Spawn a background task
-    let handle = tokio::spawn(async {
-        background_work().await
+// mpsc — Multiple Producer, Single Consumer
+async fn worker_pattern() {
+    let (tx, mut rx) = mpsc::channel::<String>(32); // buffer size
+
+    tokio::spawn(async move {
+        tx.send("hello".to_string()).await.unwrap();
+        tx.send("world".to_string()).await.unwrap();
     });
 
-    // With timeout
-    use tokio::time::{timeout, Duration};
-    let result = timeout(Duration::from_secs(5), slow_operation()).await;
-    match result {
-        Ok(Ok(val)) => println!("Got: {}", val),
-        Ok(Err(e)) => eprintln!("Operation failed: {}", e),
-        Err(_) => eprintln!("Timed out"),
+    while let Some(msg) = rx.recv().await {
+        println!("Got: {msg}");
     }
 }
+
+// oneshot — single response (request/response pattern)
+async fn request_response() {
+    let (tx, rx) = oneshot::channel::<String>();
+
+    tokio::spawn(async move {
+        let result = expensive_computation().await;
+        tx.send(result).unwrap();
+    });
+
+    let response = rx.await.unwrap();
+}
+
+// Mutex (async-safe)
+use tokio::sync::Mutex;
+let shared_state = Arc::new(Mutex::new(Vec::new()));
+
+let state = Arc::clone(&shared_state);
+tokio::spawn(async move {
+    let mut guard = state.lock().await;
+    guard.push("item");
+}); // lock released when guard is dropped
 ```
 
 ---
 
-## HTTP Server with axum
+## Axum Web Framework
+
+### Basic Server
 
 ```rust
-use axum::{Router, routing::get, routing::post, Json, extract::State};
-use std::sync::Arc;
+use axum::{
+    extract::{Path, Query, State, Json},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::{get, post, delete},
+    Router,
+};
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone)]
 struct AppState {
-    db: Arc<Database>,
+    db: sqlx::PgPool,
 }
 
 #[tokio::main]
 async fn main() {
-    let state = AppState { db: Arc::new(Database::connect().await.unwrap()) };
+    let pool = sqlx::PgPool::connect("postgres://localhost/mydb").await.unwrap();
+    let state = AppState { db: pool };
 
     let app = Router::new()
         .route("/users", get(list_users).post(create_user))
-        .route("/users/:id", get(get_user))
+        .route("/users/{id}", get(get_user).delete(delete_user))
         .with_state(state);
 
-    axum::serve(
-        tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(),
-        app,
-    ).await.unwrap();
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
+    axum::serve(listener, app).await.unwrap();
 }
 
-async fn get_user(
-    State(state): State<AppState>,
-    axum::extract::Path(id): axum::extract::Path<String>,
-) -> Result<Json<User>, StatusCode> {
-    state.db.find_user(&id).await
-        .map(Json)
-        .map_err(|_| StatusCode::NOT_FOUND)
-}
+// ❌ HALLUCINATION TRAP: axum 0.7+ uses {id} not :id for path params
+// ❌ .route("/users/:id", ...)  ← old syntax
+// ✅ .route("/users/{id}", ...)  ← axum 0.7+
 ```
 
----
+### Handlers
 
-## Common Pitfalls
+```rust
+#[derive(Deserialize)]
+struct ListParams {
+    page: Option<u32>,
+    limit: Option<u32>,
+}
 
-| Pitfall | What Happens | Fix |
-|---|---|---|
-| `.clone()` everywhere | Hides ownership problems, creates heap allocations | Use references `&T` where ownership isn't needed |
-| `unwrap()` in production | Panics on None/Err — crashes the process | Use `?` or match and return proper errors |
-| Blocking in async | `std::thread::sleep` blocks the Tokio runtime | Use `tokio::time::sleep().await` |
-| `Arc<Mutex<T>>` contention | Mutex held across await points causes deadlocks | Hold locks for minimum duration, never across `.await` |
+async fn list_users(
+    State(state): State<AppState>,
+    Query(params): Query<ListParams>,
+) -> Result<Json<Vec<User>>, AppError> {
+    let page = params.page.unwrap_or(1);
+    let limit = params.limit.unwrap_or(20).min(100);
+    let offset = (page - 1) * limit;
+
+    let users = sqlx::query_as!(
+        User,
+        "SELECT id, name, email FROM users ORDER BY id LIMIT $1 OFFSET $2",
+        limit as i64,
+        offset as i64,
+    )
+    .fetch_all(&state.db)
+    .await?;
+
+    Ok(Json(users))
+}
 
----
+#[derive(Deserialize)]
+struct CreateUserPayload {
+    name: String,
+    email: String,
+}
 
-## Project Structure
+async fn create_user(
+    State(state): State<AppState>,
+    Json(payload): Json<CreateUserPayload>,
+) -> Result<(StatusCode, Json<User>), AppError> {
+    let user = sqlx::query_as!(
+        User,
+        "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id, name, email",
+        payload.name,
+        payload.email,
+    )
+    .fetch_one(&state.db)
+    .await?;
+
+    Ok((StatusCode::CREATED, Json(user)))
+}
 
+async fn get_user(
+    State(state): State<AppState>,
+    Path(id): Path<i32>,
+) -> Result<Json<User>, AppError> {
+    let user = sqlx::query_as!(User, "SELECT id, name, email FROM users WHERE id = $1", id)
+        .fetch_optional(&state.db)
+        .await?
+        .ok_or(AppError::NotFound(format!("User {id}")))?;
+
+    Ok(Json(user))
+}
 ```
-src/
-  main.rs         Entry point — thin, just wires up the server
-  lib.rs          Re-exports for library usage
-  handlers/       HTTP request handlers (thin — parse, call service, return response)
-  services/       Business logic (no HTTP awareness)
-  repositories/   Database queries
-  models/         Data structures and validation
-  errors.rs       Unified error type
-  config.rs       Settings loaded from environment
 
-Cargo.toml         Dependencies
-```
+### Error Handling in Axum
 
----
+```rust
+use axum::response::{IntoResponse, Response};
 
-## Essential Crates
+#[derive(Debug, thiserror::Error)]
+pub enum AppError {
+    #[error("Not found: {0}")]
+    NotFound(String),
+    #[error("Validation: {0}")]
+    Validation(String),
+    #[error("Database: {0}")]
+    Database(#[from] sqlx::Error),
+    #[error("Internal: {0}")]
+    Internal(#[from] anyhow::Error),
+}
 
-| Crate | Purpose |
-|---|---|
-| `tokio` | Async runtime |
-| `axum` | Web framework |
-| `sqlx` | Async SQL with compile-time query checking |
-| `serde` + `serde_json` | Serialization |
-| `thiserror` | Ergonomic error definitions |
-| `anyhow` | Error handling in binaries/scripts (not libraries) |
-| `tracing` | Structured async-aware logging |
-| `config` | Hierarchical configuration from env/files |
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        let (status, message) = match &self {
+            AppError::NotFound(msg) => (StatusCode::NOT_FOUND, msg.clone()),
+            AppError::Validation(msg) => (StatusCode::BAD_REQUEST, msg.clone()),
+            AppError::Database(e) => {
+                tracing::error!("DB error: {e}"); // log internal details
+                (StatusCode::INTERNAL_SERVER_ERROR, "Database error".to_string())
+            }
+            AppError::Internal(e) => {
+                tracing::error!("Internal error: {e}");
+                (StatusCode::INTERNAL_SERVER_ERROR, "Internal error".to_string())
+            }
+        };
+
+        (status, Json(serde_json::json!({ "error": message }))).into_response()
+    }
+}
+```
 
 ---
 
-## Output Format
-
-When this skill produces or reviews code, structure your output as follows:
+## Serde (Serialization)
 
-```
-━━━ Rust Pro Report ━━━━━━━━━━━━━━━━━━━━━━━━
-Skill:       Rust Pro
-Language:    [detected language / framework]
-Scope:       [N files · N functions]
-─────────────────────────────────────────────────
-✅ Passed:   [checks that passed, or "All clean"]
-⚠️  Warnings: [non-blocking issues, or "None"]
-❌ Blocked:  [blocking issues requiring fix, or "None"]
-─────────────────────────────────────────────────
-VBC status:  PENDING → VERIFIED
-Evidence:    [test output / lint pass / compile success]
-```
+```rust
+use serde::{Deserialize, Serialize};
 
-**VBC (Verification-Before-Completion) is mandatory.**
-Do not mark status as VERIFIED until concrete terminal evidence is provided.
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]  // JSON uses camelCase
+struct UserResponse {
+    user_id: i32,           // serialized as "userId"
+    full_name: String,      // serialized as "fullName"
+    email: String,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    phone: Option<String>,  // omitted from JSON if None
 
----
+    #[serde(default)]       // defaults to 0 if missing in input
+    login_count: u32,
 
-## 🏛️ Tribunal Integration (Anti-Hallucination)
+    #[serde(rename = "type")]  // rename for reserved keywords
+    user_type: String,
 
-**Slash command: `/tribunal-backend`**
-**Active reviewers: `logic` · `security` · `memory` · `type-safety`**
+    #[serde(skip)]          // never serialized/deserialized
+    internal_token: String,
+}
 
-### ❌ Forbidden AI Tropes in Rust
+// Enum serialization
+#[derive(Serialize, Deserialize)]
+#[serde(tag = "type", content = "data")]  // adjacently tagged
+enum Event {
+    #[serde(rename = "user_created")]
+    UserCreated { id: i32, name: String },
+    #[serde(rename = "user_deleted")]
+    UserDeleted { id: i32 },
+}
+// Serializes as: {"type": "user_created", "data": {"id": 1, "name": "Alice"}}
+```
 
-1. **`unwrap()`/`expect()` in production code** — hiding errors instead of propagating them with `?`.
-2. **`.clone()` everywhere** — blindly copying data instead of reasoning about lifetimes and borrows.
-3. **`Arc<Mutex<T>>` overuse** — wrapping everything in locks instead of passing ownership or using channels.
-4. **Blocking the Tokio runtime** — using `std::thread::sleep` or sync I/O inside an `async` function.
-5. **Over-complex trait bounds** — creating massive generic trait puzzles instead of concrete types when generics aren't needed.
+---
 
-### ✅ Pre-Flight Self-Audit
+## Iterator Patterns
 
-Review these questions before generating Rust code:
-```
-✅ Did I properly propagate errors using `Result` and the `?` operator?
-✅ Is the Tokio runtime safe from being blocked by my code?
-✅ Did I avoid unnecessary `.clone()` calls by borrowing (`&T`) appropriately?
-✅ Are my error types properly implemented (e.g., using `thiserror`)?
-✅ Did I keep the lock durations on Mutexes as short as possible and never across `.await` points?
+```rust
+let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+// Chain operations (lazy — no allocation until collect)
+let result: Vec<i32> = numbers.iter()
+    .filter(|&&n| n % 2 == 0)    // keep even
+    .map(|&n| n * n)              // square
+    .take(3)                      // first 3
+    .collect();                   // [4, 16, 36]
+
+// fold (reduce)
+let sum: i32 = numbers.iter().fold(0, |acc, &n| acc + n);
+
+// find / position
+let first_even = numbers.iter().find(|&&n| n % 2 == 0); // Some(&2)
+let pos = numbers.iter().position(|&n| n > 5);           // Some(5)
+
+// chunk / window
+let chunks: Vec<&[i32]> = numbers.chunks(3).collect();
+// [[1,2,3], [4,5,6], [7,8,9], [10]]
+
+let windows: Vec<&[i32]> = numbers.windows(3).collect();
+// [[1,2,3], [2,3,4], [3,4,5], ...]
+
+// Collecting into HashMap
+use std::collections::HashMap;
+let word_counts: HashMap<&str, usize> = words.iter()
+    .fold(HashMap::new(), |mut map, word| {
+        *map.entry(word.as_str()).or_insert(0) += 1;
+        map
+    });
 ```
 
-### 🛑 Verification-Before-Completion (VBC) Protocol
 
-**CRITICAL:** You must follow a strict "evidence-based closeout" state machine.
-- ❌ **Forbidden:** Concluding your work because the logic seems sound or assuming `cargo check` is enough for complex runtime logic.
-- ✅ **Required:** You are explicitly forbidden from completing your Rust task without providing **concrete terminal evidence** that `cargo test` passes or the binary runs successfully (`cargo run`) without panics. The Borrow Checker passing is step one; runtime verification is mandatory before completion.