fix: resolve all clippy warnings for v1.0.0 release

89 warnings fixed across 14 files:
- Remove unused imports (backpressure, drain, llm)
- Remove unnecessary mut (registry)
- Remove unneeded return (audit)
- Replace unwrap with expect (hot_reload)
- Allow clippy::unwrap_used on IR fmt::Write to String (infallible)
- Allow deprecated on intentional XOR demo usage (security)
- Derive Default instead of manual impl (ring_kernel codegen)
- Add doc comments to 57 undocumented struct fields across
  actor, backpressure, dlq, hot_reload, memory_pressure,
  registry, vector, llm, streaming modules

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mivertowski

crates/ringkernel-core/src/actor.rs

@@ -118,12 +118,16 @@ pub enum RestartPolicy {
     },
     /// Restart the failed actor and all its siblings (children of the same parent).
     OneForAll {
+        /// Maximum restart attempts within the time window.
         max_restarts: u32,
+        /// Time window for counting restarts.
         window: Duration,
     },
     /// Restart the failed actor and all actors that were started after it.
     RestForOne {
+        /// Maximum restart attempts within the time window.
         max_restarts: u32,
+        /// Time window for counting restarts.
         window: Duration,
     },
 }
@@ -537,7 +541,7 @@ impl ActorSupervisor {
                 });
             }
 
-            RestartPolicy::OneForOne { max_restarts, .. } => {
+            RestartPolicy::OneForOne { .. } => {
                 // Restart only the failed actor
                 match self.restart_actor(failed_id, config) {
                     Ok(new_id) => {
@@ -666,35 +670,56 @@ pub enum SupervisionAction {
     /// Actor marked as failed.
     MarkedFailed(ActorId),
     /// Actor was restarted.
-    Restarted { old_id: ActorId, new_id: ActorId },
+    Restarted {
+        /// The original actor ID before restart.
+        old_id: ActorId,
+        /// The new actor ID after restart.
+        new_id: ActorId,
+    },
     /// A sibling was destroyed (OneForAll/RestForOne).
     DestroyedSibling(ActorId),
     /// All siblings destroyed, parent needs to re-create them.
-    AllSiblingsDestroyed { parent: ActorId },
+    AllSiblingsDestroyed {
+        /// Parent actor that owns the destroyed siblings.
+        parent: ActorId,
+    },
     /// Failure escalated to parent supervisor.
-    Escalated { failed: ActorId, escalated_to: Option<ActorId> },
+    Escalated {
+        /// Actor that failed.
+        failed: ActorId,
+        /// Parent supervisor the failure was escalated to.
+        escalated_to: Option<ActorId>,
+    },
 }
 
 /// Errors from actor lifecycle operations.
 #[derive(Debug, Clone)]
 pub enum ActorError {
     /// No available actor slots in the pool.
     PoolExhausted {
+        /// Total pool capacity.
         capacity: u32,
+        /// Number of currently active actors.
         active: u32,
     },
     /// Invalid actor ID.
     InvalidId(ActorId),
     /// Invalid state transition.
     InvalidStateTransition {
+        /// Actor that attempted the invalid transition.
         actor: ActorId,
+        /// Current state of the actor.
         from: ActorState,
+        /// Attempted target state.
         to: ActorState,
     },
     /// Actor has exceeded its maximum restart budget.
     MaxRestartsExceeded {
+        /// Actor that exceeded its restart budget.
         actor: ActorId,
+        /// Number of restarts attempted.
         restarts: u32,
+        /// Maximum allowed restarts.
         max: u32,
     },
 }

crates/ringkernel-core/src/audit.rs

@@ -1481,11 +1481,11 @@ impl AuditSink for CloudWatchSink {
     fn flush(&self) -> std::io::Result<()> {
         #[cfg(feature = "cloudwatch")]
         {
-            return self.flush_to_cloudwatch();
+            self.flush_to_cloudwatch()
         }
         #[cfg(not(feature = "cloudwatch"))]
         {
-            return self.flush_stub();
+            self.flush_stub()
         }
     }
 

crates/ringkernel-core/src/backpressure.rs

@@ -25,7 +25,6 @@
 //! ```
 
 use std::sync::atomic::{AtomicI64, AtomicU64, Ordering};
-use std::time::Instant;
 
 /// Flow control configuration for a K2K channel.
 #[derive(Debug, Clone)]
@@ -60,7 +59,10 @@ pub enum OverflowPolicy {
     /// Block the producer until credits are available.
     Block,
     /// Buffer messages locally (up to buffer_limit).
-    Buffer { limit: u32 },
+    Buffer {
+        /// Maximum number of messages to buffer.
+        limit: u32,
+    },
     /// Drop the message and route to dead letter queue.
     DropToDlq,
     /// Drop the message silently (with metric increment).
@@ -210,13 +212,21 @@ impl FlowController {
 /// Snapshot of flow control metrics (non-atomic, for reporting).
 #[derive(Debug, Clone)]
 pub struct FlowMetricsSnapshot {
+    /// Credits currently available to the producer.
     pub credits_available: i64,
+    /// Total credits granted since creation.
     pub credits_granted: u64,
+    /// Total credits consumed since creation.
     pub credits_consumed: u64,
+    /// Number of backpressure events triggered.
     pub backpressure_events: u64,
+    /// Number of messages routed to the dead letter queue.
     pub dlq_routed: u64,
+    /// Number of messages silently dropped.
     pub dropped: u64,
+    /// Number of high water mark signals emitted.
     pub high_water_signals: u64,
+    /// Number of low water mark signals emitted.
     pub low_water_signals: u64,
 }
 

crates/ringkernel-core/src/dlq.rs

@@ -17,17 +17,37 @@ use crate::runtime::KernelId;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DeadLetterReason {
     /// Message processing failed after max retries.
-    MaxRetriesExceeded { retries: u32, max: u32 },
+    MaxRetriesExceeded {
+        /// Number of retries attempted.
+        retries: u32,
+        /// Maximum retries allowed.
+        max: u32,
+    },
     /// Destination actor not found.
-    ActorNotFound { actor_name: String },
+    ActorNotFound {
+        /// Name of the actor that was not found.
+        actor_name: String,
+    },
     /// Queue was full and overflow policy is DropToDlq.
-    QueueFull { queue_capacity: usize },
+    QueueFull {
+        /// Capacity of the full queue.
+        queue_capacity: usize,
+    },
     /// Message TTL expired before delivery.
-    TtlExpired { age: Duration },
+    TtlExpired {
+        /// Age of the message when it expired.
+        age: Duration,
+    },
     /// Actor was destroyed while message was in-flight.
-    ActorDestroyed { actor_id: String },
+    ActorDestroyed {
+        /// ID of the destroyed actor.
+        actor_id: String,
+    },
     /// Explicit rejection by the actor's message handler.
-    Rejected { reason: String },
+    Rejected {
+        /// Reason for rejection.
+        reason: String,
+    },
 }
 
 impl std::fmt::Display for DeadLetterReason {

crates/ringkernel-core/src/drain.rs

@@ -8,7 +8,7 @@
 
 use std::time::{Duration, Instant};
 
-use crate::actor::{ActorId, ActorState, ActorSupervisor};
+use crate::actor::{ActorId, ActorSupervisor};
 
 /// Shutdown phase.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/ringkernel-core/src/hot_reload.rs

@@ -176,7 +176,10 @@ impl HotReloadConfig {
         };
 
         // Apply the change
-        self.entries.get_mut(key).unwrap().value = new_value;
+        self.entries
+            .get_mut(key)
+            .expect("config entry must exist after contains_key check")
+            .value = new_value;
 
         // Audit trail
         self.changes.push(change);
@@ -232,8 +235,11 @@ pub enum ConfigUpdateError {
     NotReloadable(String),
     /// Value type doesn't match registered type.
     TypeMismatch {
+        /// Configuration key with the type mismatch.
         key: String,
+        /// Expected type name.
         expected: String,
+        /// Actual type name provided.
         got: String,
     },
     /// Custom validation failed.

crates/ringkernel-core/src/memory_pressure.rs

@@ -142,9 +142,17 @@ pub enum AllocationResult {
     /// Allocation granted, within soft limit.
     Granted,
     /// Allocation granted, but soft limit exceeded (warning).
-    GrantedWithWarning { usage_fraction: f64 },
+    GrantedWithWarning {
+        /// Fraction of memory budget currently in use (0.0 to 1.0).
+        usage_fraction: f64,
+    },
     /// Allocation denied — would exceed hard limit.
-    Denied { requested: u64, available: u64 },
+    Denied {
+        /// Number of bytes requested.
+        requested: u64,
+        /// Number of bytes available.
+        available: u64,
+    },
 }
 
 /// Global memory pressure monitor for all actors.

crates/ringkernel-core/src/registry.rs

@@ -46,18 +46,25 @@ pub struct RegistryEntry {
 pub enum RegistryEvent {
     /// A new actor was registered.
     Registered {
+        /// Symbolic name of the registered actor.
         name: String,
+        /// Kernel ID assigned to the actor.
         kernel_id: KernelId,
     },
     /// An actor was deregistered.
     Deregistered {
+        /// Symbolic name of the deregistered actor.
         name: String,
+        /// Kernel ID that was removed.
         kernel_id: KernelId,
     },
     /// An actor's registration was updated.
     Updated {
+        /// Symbolic name of the updated actor.
         name: String,
+        /// Previous kernel ID.
         old_kernel_id: KernelId,
+        /// New kernel ID.
         new_kernel_id: KernelId,
     },
 }
@@ -287,10 +294,10 @@ impl Default for ActorRegistry {
 /// `**` matches any characters including `/`.
 /// `?` matches a single character.
 fn wildcard_match(pattern: &str, text: &str) -> bool {
-    let mut p = pattern.chars().peekable();
-    let mut t = text.chars().peekable();
+    let p = pattern.chars().collect::<Vec<_>>();
+    let t = text.chars().collect::<Vec<_>>();
 
-    wildcard_match_recursive(&mut p.collect::<Vec<_>>(), &mut t.collect::<Vec<_>>(), 0, 0)
+    wildcard_match_recursive(&p, &t, 0, 0)
 }
 
 fn wildcard_match_recursive(pattern: &[char], text: &[char], pi: usize, ti: usize) -> bool {

crates/ringkernel-core/src/security.rs

@@ -404,6 +404,7 @@ pub struct MemoryEncryption {
 
 impl MemoryEncryption {
     /// Create a new memory encryption manager.
+    #[allow(deprecated)]
     pub fn new(config: EncryptionConfig) -> Self {
         let key_id = 1;
         let active_key = EncryptionKey::new(key_id, config.algorithm);
@@ -682,6 +683,7 @@ impl MemoryEncryption {
     }
 
     /// Rotate encryption keys.
+    #[allow(deprecated)]
     pub fn rotate_keys(&self) {
         let mut active = self.active_key.write().expect("active_key lock poisoned");
         let mut previous = self.previous_keys.write().expect("previous_keys lock poisoned");

crates/ringkernel-core/src/vector.rs

@@ -247,9 +247,17 @@ fn dot_product(a: &[f32], b: &[f32]) -> f32 {
 #[derive(Debug, Clone)]
 pub enum VectorStoreError {
     /// Vector dimension doesn't match store configuration.
-    DimensionMismatch { expected: usize, got: usize },
+    DimensionMismatch {
+        /// Expected vector dimension.
+        expected: usize,
+        /// Actual vector dimension provided.
+        got: usize,
+    },
     /// Store is full.
-    CapacityExceeded { capacity: usize },
+    CapacityExceeded {
+        /// Maximum capacity of the vector store.
+        capacity: usize,
+    },
     /// Vector not found.
     NotFound(u64),
 }