Enforce strict clippy lint policy

Cargo.toml

@@ -12,3 +12,15 @@ edition = "2024"
 authors = ["Balavignesh"]
 license = "MIT"
 repository = "https://github.com/SBALAVIGNESH123/OmniKV"
+
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+
+[workspace.lints.rust]
+dead_code = "warn"
+unused_imports = "warn"
+unused_mut = "warn"
+unused_variables = "warn"
+mismatched_lifetime_syntaxes = "warn"

crates/omnikv-engine/Cargo.toml

@@ -15,6 +15,9 @@ path = "src/lib.rs"
 default = []
 failpoints = []
 
+[lints]
+workspace = true
+
 [dependencies]
 memmap2 = "0.9.11"
 tokio = { version = "1.52.1", features = ["full", "macros"] }

crates/omnikv-engine/benches/omni_bench.rs

@@ -7,6 +7,16 @@
 //!   cargo bench -p omnikv-engine --bench omni_bench
 //!   cargo bench -p omnikv-engine --bench omni_bench -- --soak 600   # 10-min soak
 
+#![expect(
+    clippy::cast_possible_truncation,
+    clippy::cast_precision_loss,
+    clippy::cast_sign_loss,
+    clippy::doc_markdown,
+    clippy::too_many_lines,
+    clippy::uninlined_format_args,
+    reason = "Benchmark harness keeps readable numeric reporting and CLI output; strict clippy findings are tracked separately from production engine code."
+)]
+
 use omni_engine::{OmniKV, WriteBatch};
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};

crates/omnikv-engine/benches/scan_buffer_pool.rs

@@ -8,6 +8,12 @@
 //!   cargo bench -p omnikv-engine --bench scan_buffer_pool
 //!   cargo bench -p omnikv-engine --bench scan_buffer_pool -- --rows 20000 --rounds 20
 
+#![expect(
+    clippy::cast_precision_loss,
+    clippy::doc_markdown,
+    reason = "Scan benchmark keeps CLI docs and throughput math simple for before/after comparisons."
+)]
+
 use omni_engine::{OmniKV, WriteBatch};
 use std::time::{Duration, Instant};
 use tempfile::TempDir;

crates/omnikv-engine/benches/volcano_dispatch.rs

@@ -7,6 +7,13 @@
 //!   cargo bench -p omnikv-engine --bench volcano_dispatch
 //!   cargo bench -p omnikv-engine --bench volcano_dispatch -- --rows 200000 --rounds 5
 
+#![expect(
+    clippy::cast_precision_loss,
+    clippy::doc_markdown,
+    clippy::missing_const_for_fn,
+    reason = "Dispatch benchmark favors readable throughput math and CLI documentation over style-only rewrites."
+)]
+
 use omni_engine::sql::{AggFunc, CmpOp, SelectColumn, SqlValue, WhereExpr};
 use omni_engine::sql_exec::Row;
 use omni_engine::volcano::{

crates/omnikv-engine/src/lib.rs

@@ -1,8 +1,62 @@
-#![allow(dead_code)]
-#![allow(unused_imports)]
-#![allow(unused_variables)]
-#![allow(unused_mut)]
-#![allow(mismatched_lifetime_syntaxes)]
+#![expect(
+    dead_code,
+    unused_imports,
+    unused_variables,
+    reason = "Legacy modules still expose staged database features and compatibility shims; issue #64 makes this debt explicit instead of hiding it behind broad allow attributes."
+)]
+#![expect(
+    clippy::assigning_clones,
+    clippy::bool_to_int_with_if,
+    clippy::branches_sharing_code,
+    clippy::cast_lossless,
+    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    clippy::cast_sign_loss,
+    clippy::collapsible_else_if,
+    clippy::collection_is_never_read,
+    clippy::derive_partial_eq_without_eq,
+    clippy::doc_markdown,
+    clippy::explicit_iter_loop,
+    clippy::format_collect,
+    clippy::format_push_string,
+    clippy::if_not_else,
+    clippy::ignored_unit_patterns,
+    clippy::items_after_statements,
+    clippy::manual_let_else,
+    clippy::manual_string_new,
+    clippy::map_unwrap_or,
+    clippy::match_same_arms,
+    clippy::match_wildcard_for_single_variants,
+    clippy::missing_const_for_fn,
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::must_use_candidate,
+    clippy::needless_collect,
+    clippy::needless_continue,
+    clippy::needless_pass_by_value,
+    clippy::non_std_lazy_statics,
+    clippy::option_if_let_else,
+    clippy::or_fun_call,
+    clippy::redundant_clone,
+    clippy::redundant_closure_for_method_calls,
+    clippy::redundant_else,
+    clippy::self_only_used_in_recursion,
+    clippy::semicolon_if_nothing_returned,
+    clippy::significant_drop_tightening,
+    clippy::single_char_pattern,
+    clippy::single_match_else,
+    clippy::suboptimal_flops,
+    clippy::too_long_first_doc_paragraph,
+    clippy::too_many_lines,
+    clippy::uninlined_format_args,
+    clippy::unnecessary_wraps,
+    clippy::unreadable_literal,
+    clippy::unused_self,
+    clippy::use_self,
+    clippy::used_underscore_binding,
+    reason = "Strict clippy::pedantic and clippy::nursery are now enabled. These legacy findings are documented debt to burn down in focused follow-up PRs while preventing new undocumented lint categories."
+)]
 
 pub mod storage {
     pub mod core;

crates/omnikv-engine/src/query/optimizer.rs

@@ -9,11 +9,12 @@
 //!
 //! The optimizer produces a `QueryPlan` tree that the executor walks.
 
-#![allow(dead_code)]
-
 use crate::catalog::Catalog;
 use crate::secondary_index::{IndexCatalog, IndexDefinition};
-use crate::sql::*;
+use crate::sql::{
+    CmpOp, FromClause, JoinType, OrderByItem, SelectColumn, SqlStatement, SqlValue, WhereExpr,
+    parse_sql,
+};
 use std::fmt;
 use std::sync::Arc;
 

crates/omnikv-engine/src/query/plan_exec.rs

@@ -3,12 +3,10 @@
 //! Executes queries using the optimizer's physical plan tree instead of
 //! the old hardcoded scan-filter-sort pipeline.
 
-#![allow(dead_code)]
-
 use crate::OmniKV;
 use crate::catalog::{Catalog, TableDef};
-use crate::optimizer::*;
-use crate::sql::*;
+use crate::optimizer::{AccessMethod, PlanNode};
+use crate::sql::{AggFunc, CmpOp, JoinType, OrderByItem, SelectColumn, WhereExpr};
 use crate::sql_exec::Row;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};

crates/omnikv-engine/src/query/sql.rs

@@ -6,7 +6,10 @@
 use crate::catalog::ColumnType;
 
 #[derive(Debug, Clone, PartialEq)]
-#[allow(clippy::large_enum_variant)]
+#[expect(
+    clippy::large_enum_variant,
+    reason = "SQL statement variants intentionally keep owned AST payloads for parser simplicity; boxing the largest variant needs a separate API-impact review."
+)]
 pub enum SqlStatement {
     CreateTable {
         name: String,

crates/omnikv-engine/src/query/sql_exec.rs

@@ -4,7 +4,10 @@
 //! GROUP BY aggregation, and ORDER BY sorting.
 
 use crate::catalog::{Catalog, Column, ColumnType, TableDef};
-use crate::sql::*;
+use crate::sql::{
+    AggFunc, CmpOp, FromClause, JoinType, OrderByItem, SelectColumn, SetOpType, SqlColumnDef,
+    SqlStatement, SqlValue, WhereExpr, WindowFuncType,
+};
 use crate::{OmniKV, WriteBatch};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -402,7 +405,10 @@ impl SqlExecutor {
             .collect()
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(
+        clippy::too_many_arguments,
+        reason = "The SELECT executor mirrors SQL clauses explicitly; refactoring into an execution context is planned separately to avoid query semantics churn."
+    )]
     fn exec_select(
         &self,
         columns: &[SelectColumn],
@@ -674,7 +680,10 @@ impl SqlExecutor {
         })
     }
 
-    #[allow(clippy::too_many_arguments)]
+    #[expect(
+        clippy::too_many_arguments,
+        reason = "Join execution keeps the parsed join shape explicit; collapsing into a context struct is a later planner cleanup."
+    )]
     fn execute_join(
         &self,
         left: &[Row],

crates/omnikv-engine/src/query/volcano.rs

@@ -22,12 +22,15 @@
 //! SeqScanIter::next()  ← reads one row at a time from storage
 //! ```
 
-#![allow(dead_code)]
+#![expect(
+    dead_code,
+    reason = "The streaming executor contains staged operator variants used by benchmark and planner work that is not fully wired into the public SQL path yet."
+)]
 
 use crate::OmniKV;
 use crate::catalog::{Catalog, TableDef};
-use crate::optimizer::*;
-use crate::sql::*;
+use crate::optimizer::{AccessMethod, PlanNode};
+use crate::sql::{AggFunc, CmpOp, JoinType, OrderByItem, SelectColumn, WhereExpr};
 use crate::sql_exec::Row;
 use std::collections::HashMap;
 use std::sync::Arc;

crates/omnikv-engine/src/runtime/dist_txn.rs

@@ -482,7 +482,10 @@ struct PreparedState {
     /// The prepared write batch (ready to commit).
     batch: WriteBatch,
     /// Sequence at which this was prepared (for recovery).
-    #[allow(dead_code)]
+    #[expect(
+        dead_code,
+        reason = "Prepared sequence is retained for recovery/audit semantics even though the current participant tests do not read it directly yet."
+    )]
     prepare_seq: u64,
     /// When this was prepared.
     prepared_at: Instant,

crates/omnikv-engine/src/storage/core.rs

@@ -1,8 +1,7 @@
-#![allow(dead_code)]
-#![allow(unused_imports)]
-#![allow(unused_variables)]
-#![allow(unused_mut)]
-#![allow(mismatched_lifetime_syntaxes)]
+#![expect(
+    dead_code,
+    reason = "Storage core intentionally carries staged LSM, compaction, transaction, and compatibility paths while the module is being split into smaller production components."
+)]
 
 use crate::{metrics_prometheus, wal};
 use arc_swap::ArcSwap;

crates/omnikv-engine/tests/anomaly_demos.rs

@@ -4,6 +4,13 @@
 //! Each test sets up a scenario that would cause data corruption under
 //! weaker isolation levels, and verifies OmniKV detects and aborts it.
 
+#![expect(
+    clippy::doc_markdown,
+    clippy::or_fun_call,
+    clippy::uninlined_format_args,
+    reason = "Anomaly demos intentionally read like scenario walkthroughs with generated values and human-facing assertions."
+)]
+
 use omni_engine::transaction::TransactionManager;
 use omni_engine::{OmniKV, WriteBatch};
 use std::sync::Arc;

crates/omnikv-engine/tests/api_error_sanitization_tests.rs

@@ -1,3 +1,10 @@
+#![expect(
+    clippy::doc_markdown,
+    clippy::match_same_arms,
+    clippy::uninlined_format_args,
+    reason = "API sanitization tests keep explicit acceptable outcomes and readable diagnostic strings."
+)]
+
 use omni_engine::{OmniError, OmniKV};
 use tempfile::tempdir;
 

crates/omnikv-engine/tests/benchmarks.rs

@@ -11,6 +11,15 @@
 //! - Transaction commit throughput (txn/sec)
 //! - Batch write throughput (ops/sec)
 
+#![expect(
+    clippy::cast_precision_loss,
+    clippy::cast_sign_loss,
+    clippy::doc_markdown,
+    clippy::missing_const_for_fn,
+    clippy::uninlined_format_args,
+    reason = "Benchmark smoke tests prioritize stable, readable measurement code; strict clippy findings are documented as benchmark debt."
+)]
+
 use omni_engine::sql::{AggFunc, CmpOp, SelectColumn, SqlValue, WhereExpr};
 use omni_engine::sql_exec::Row;
 use omni_engine::transaction::TransactionManager;

crates/omnikv-engine/tests/concurrent_stress.rs

@@ -3,6 +3,12 @@
 //! These tests prove correctness under REAL parallel thread contention —
 //! not simulated single-threaded scenarios.
 
+#![expect(
+    clippy::or_fun_call,
+    clippy::uninlined_format_args,
+    reason = "Stress tests favor scenario clarity and repeated generated keys over style-only rewrites."
+)]
+
 use omni_engine::transaction::TransactionManager;
 use omni_engine::{OmniKV, WriteBatch};
 use std::sync::Arc;

crates/omnikv-engine/tests/config_tests.rs

@@ -1,4 +1,8 @@
-#![allow(clippy::field_reassign_with_default)]
+#![expect(
+    clippy::field_reassign_with_default,
+    clippy::redundant_closure_for_method_calls,
+    reason = "Config tests intentionally mutate defaults one field at a time to isolate validation failures."
+)]
 use std::sync::Mutex;
 
 use omni_engine::config::{

crates/omnikv-engine/tests/crash_consistency.rs

@@ -1,3 +1,7 @@
+#![expect(
+    clippy::doc_markdown,
+    reason = "Crash consistency test documentation names engine files and recovery concepts directly for operator readability."
+)]
 //! Crash-consistency tests — these tests drive the **real OmniKV engine**.
 //!
 //! Every test:

crates/omnikv-engine/tests/debug_compaction.rs

@@ -1,3 +1,8 @@
+#![expect(
+    clippy::uninlined_format_args,
+    reason = "Debug reproduction test keeps compact diagnostic formatting."
+)]
+
 use omni_engine::{OmniKV, WriteBatch};
 #[test]
 fn test_debug_compaction() {

crates/omnikv-engine/tests/debug_compaction_200.rs

@@ -1,3 +1,8 @@
+#![expect(
+    clippy::uninlined_format_args,
+    reason = "Debug reproduction test keeps compact diagnostic formatting."
+)]
+
 use omni_engine::{OmniKV, WriteBatch};
 #[test]
 fn test_debug_compaction_200() {

crates/omnikv-engine/tests/debug_reopen.rs

@@ -1,3 +1,8 @@
+#![expect(
+    clippy::uninlined_format_args,
+    reason = "Debug reproduction test keeps compact diagnostic formatting."
+)]
+
 use omni_engine::{OmniKV, WriteBatch};
 #[test]
 fn test_debug_reopen() {

crates/omnikv-engine/tests/durability_evidence.rs

@@ -1,3 +1,10 @@
+#![expect(
+    clippy::cast_possible_truncation,
+    clippy::cast_sign_loss,
+    clippy::doc_markdown,
+    clippy::uninlined_format_args,
+    reason = "Durability evidence tests use generated crash-case data and compact diagnostic output to keep failure scenarios auditable."
+)]
 /// Phase 3 — Durability Evidence Test Suite
 ///
 /// These tests prove OmniKV survives real failure scenarios:

crates/omnikv-engine/tests/operations.rs

@@ -1,3 +1,10 @@
+#![expect(
+    clippy::doc_markdown,
+    clippy::redundant_clone,
+    clippy::stable_sort_primitive,
+    clippy::uninlined_format_args,
+    reason = "Operations tests keep scenario setup readable and deterministic; strict style findings are documented separately from correctness checks."
+)]
 // ═══════════════════════════════════════════════════════════════════════════
 // Operations & Edge Case Tests — Gaps #32 through #47
 // ═══════════════════════════════════════════════════════════════════════════

crates/omnikv-engine/tests/ops_maturity.rs

@@ -3,6 +3,13 @@
 //! Tests for configuration, diagnostics, metrics, health, rate limiting,
 //! group commit, graceful shutdown, and crash recovery.
 
+#![expect(
+    clippy::float_cmp,
+    clippy::significant_drop_tightening,
+    clippy::uninlined_format_args,
+    reason = "Operational maturity tests keep lock/diagnostic scopes explicit and scenario output readable."
+)]
+
 use omni_engine::hardening::{GroupCommitEngine, RateLimiter};
 use omni_engine::metrics_prometheus;
 use omni_engine::ops::{DiagnosticReport, LogFormat, OmniConfig};