diff --git a/crates/vykar-core/src/app/scheduler.rs b/crates/vykar-core/src/app/scheduler.rs
index d5579ba..15eb5a4 100644
--- a/crates/vykar-core/src/app/scheduler.rs
+++ b/crates/vykar-core/src/app/scheduler.rs
@@ -366,13 +366,13 @@ mod tests {
         let fast = sched(true, Some("1s"), false);
         let slow = sched(true, Some("1h"), false);
         let (plan, errors) = SchedulePlan::new(&[&slow, &fast], false);
-        assert!(errors.is_empty());
+        assert_eq!(errors.len(), 0);
 
         let fast_at = plan.next_run(1).unwrap();
         assert_eq!(plan.next_wake(), Some(fast_at));
 
         // Before the fast slot nothing is due; after it only the fast repo is.
-        assert!(plan.due(SystemTime::now()).is_empty());
+        assert_eq!(plan.due(SystemTime::now()).len(), 0);
         assert_eq!(plan.due(fast_at), vec![1]);
     }
 
@@ -381,7 +381,7 @@ mod tests {
         let off = sched(false, Some("1h"), false);
         let on = sched(true, Some("1h"), false);
         let (plan, errors) = SchedulePlan::new(&[&off, &on], false);
-        assert!(errors.is_empty());
+        assert_eq!(errors.len(), 0);
         assert!(plan.next_run(0).is_none());
         assert!(plan.next_run(1).is_some());
         assert_eq!(plan.next_wake(), plan.next_run(1));
@@ -396,7 +396,7 @@ mod tests {
         assert_eq!(honored.due(SystemTime::now()), vec![0]);
 
         let (ignored, _) = SchedulePlan::new(&[&startup, &plain], false);
-        assert!(ignored.due(SystemTime::now()).is_empty());
+        assert_eq!(ignored.due(SystemTime::now()).len(), 0);
     }
 
     #[test]
@@ -421,10 +421,10 @@ mod tests {
 
         let future_before = plan.next_run(1).unwrap();
         let errors = plan.reschedule_overdue(&[&overdue, &future], SystemTime::now());
-        assert!(errors.is_empty());
+        assert_eq!(errors.len(), 0);
 
         assert_eq!(plan.next_run(1), Some(future_before));
-        assert!(plan.due(SystemTime::now()).is_empty());
+        assert_eq!(plan.due(SystemTime::now()).len(), 0);
     }
 
     #[test]
@@ -450,10 +450,10 @@ mod tests {
     fn plan_all_disabled_has_no_wake() {
         let off = sched(false, None, false);
         let (plan, errors) = SchedulePlan::new(&[&off, &off], true);
-        assert!(errors.is_empty());
+        assert_eq!(errors.len(), 0);
         assert_eq!(plan.len(), 2);
         assert!(plan.next_wake().is_none());
-        assert!(plan.due(SystemTime::now()).is_empty());
+        assert_eq!(plan.due(SystemTime::now()).len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/app/views.rs b/crates/vykar-core/src/app/views.rs
index f908415..82a8941 100644
--- a/crates/vykar-core/src/app/views.rs
+++ b/crates/vykar-core/src/app/views.rs
@@ -305,7 +305,7 @@ mod tests {
             (row.nfiles, row.size_bytes, row.added_bytes),
             (None, None, None)
         );
-        assert!(row.source_paths.is_empty());
+        assert_eq!(row.source_paths.len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/commands/backup/command_dump.rs b/crates/vykar-core/src/commands/backup/command_dump.rs
index 06bc1c0..630cc11 100644
--- a/crates/vykar-core/src/commands/backup/command_dump.rs
+++ b/crates/vykar-core/src/commands/backup/command_dump.rs
@@ -398,7 +398,7 @@ mod tests {
             &mut None,
         )
         .unwrap();
-        assert!(!refs.is_empty());
+        assert_ne!(refs.len(), 0);
         assert!(total_size > 0);
     }
 
@@ -443,7 +443,7 @@ mod tests {
             &mut None,
         )
         .unwrap();
-        assert!(refs.is_empty());
+        assert_eq!(refs.len(), 0);
         assert_eq!(total_size, 0);
     }
 
diff --git a/crates/vykar-core/src/commands/backup/commit.rs b/crates/vykar-core/src/commands/backup/commit.rs
index b832f90..f76a44a 100644
--- a/crates/vykar-core/src/commands/backup/commit.rs
+++ b/crates/vykar-core/src/commands/backup/commit.rs
@@ -165,7 +165,7 @@ mod tests {
         );
         // On the error path, nothing should have been attributed to stats
         // or written into `item.chunks`.
-        assert!(item.chunks.is_empty());
+        assert_eq!(item.chunks.len(), 0);
         assert_eq!(stats.nfiles, 0);
         assert_eq!(stats.original_size, 0);
         assert_eq!(stats.compressed_size, 0);
diff --git a/crates/vykar-core/src/commands/backup/mod.rs b/crates/vykar-core/src/commands/backup/mod.rs
index d17acd9..9c4a3cd 100644
--- a/crates/vykar-core/src/commands/backup/mod.rs
+++ b/crates/vykar-core/src/commands/backup/mod.rs
@@ -1074,7 +1074,7 @@ mod tests {
 
     #[test]
     fn dataless_summary_silent_when_nothing_skipped() {
-        assert!(dataless_warnings(0, 0).is_empty());
+        assert_eq!(dataless_warnings(0, 0).len(), 0);
     }
 
     fn dataless_metadata(size: u64, mtime_ns: i64) -> fs::MetadataSummary {
diff --git a/crates/vykar-core/src/commands/backup/source.rs b/crates/vykar-core/src/commands/backup/source.rs
index e534166..871a8e4 100644
--- a/crates/vykar-core/src/commands/backup/source.rs
+++ b/crates/vykar-core/src/commands/backup/source.rs
@@ -572,7 +572,7 @@ mod tests {
         let resolved = result.unwrap();
         match resolved.policy {
             RootEmission::EmitRoot { prefix } => {
-                assert!(!prefix.is_empty(), "prefix should not be empty");
+                assert_ne!(prefix, "", "prefix should not be empty");
                 assert!(!prefix.contains("/./"), "got: {prefix}");
                 assert!(!prefix.contains("/../"), "got: {prefix}");
                 assert!(!prefix.starts_with('/'), "got: {prefix}");
@@ -596,7 +596,7 @@ mod tests {
         let resolved = result.unwrap();
         match resolved.policy {
             RootEmission::EmitRoot { prefix } => {
-                assert!(!prefix.is_empty());
+                assert_ne!(prefix, "");
                 assert!(!prefix.contains(".."), "got: {prefix}");
             }
             _ => panic!("expected EmitRoot"),
@@ -734,7 +734,7 @@ mod tests {
         assert_ne!(prefix, "..", "got: {prefix}");
         // With the current sanitizing fallback, `/..` produces an empty
         // prefix so resolve() can surface a clean error.
-        assert!(prefix.is_empty(), "got: {prefix}");
+        assert_eq!(prefix, "", "got: {prefix}");
     }
 
     #[test]
diff --git a/crates/vykar-core/src/commands/backup/walk/inode_walk.rs b/crates/vykar-core/src/commands/backup/walk/inode_walk.rs
index fc91f7c..bf8566c 100644
--- a/crates/vykar-core/src/commands/backup/walk/inode_walk.rs
+++ b/crates/vykar-core/src/commands/backup/walk/inode_walk.rs
@@ -1266,7 +1266,7 @@ mod tests {
                 _ => None,
             })
             .collect();
-        assert!(!entries.is_empty());
+        assert_ne!(entries.len(), 0);
 
         // Root entry emitted first; under the new multi-path prefix scheme,
         // the prefix is the full absolute configured path with leading `/`
diff --git a/crates/vykar-core/src/commands/check/repair_apply.rs b/crates/vykar-core/src/commands/check/repair_apply.rs
index c32a142..46bd215 100644
--- a/crates/vykar-core/src/commands/check/repair_apply.rs
+++ b/crates/vykar-core/src/commands/check/repair_apply.rs
@@ -566,7 +566,7 @@ mod tests {
 
         let (applied, errors) =
             execute_repair(&mut repo, &plan, &scan.issues, &HashMap::new()).unwrap();
-        assert!(errors.is_empty(), "{errors:?}");
+        assert_eq!(errors.len(), 0, "{errors:?}");
         assert!(applied
             .iter()
             .any(|a| matches!(a, RepairAction::RestoreKeyCopy { .. })));
diff --git a/crates/vykar-core/src/commands/compact.rs b/crates/vykar-core/src/commands/compact.rs
index 0cb4a78..0c72070 100644
--- a/crates/vykar-core/src/commands/compact.rs
+++ b/crates/vykar-core/src/commands/compact.rs
@@ -701,7 +701,7 @@ mod repack_chunk_tests {
 
     #[test]
     fn empty_input_yields_no_batches() {
-        assert!(chunk_repack_operations(vec![]).is_empty());
+        assert_eq!(chunk_repack_operations(vec![]).len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/commands/diff.rs b/crates/vykar-core/src/commands/diff.rs
index 65accbd..f51988b 100644
--- a/crates/vykar-core/src/commands/diff.rs
+++ b/crates/vykar-core/src/commands/diff.rs
@@ -294,7 +294,7 @@ mod tests {
             ],
         );
 
-        assert!(entries.is_empty());
+        assert_eq!(entries.len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/commands/restore/finalize.rs b/crates/vykar-core/src/commands/restore/finalize.rs
index 2187ec2..6f72e1c 100644
--- a/crates/vykar-core/src/commands/restore/finalize.rs
+++ b/crates/vykar-core/src/commands/restore/finalize.rs
@@ -1696,7 +1696,7 @@ mod tests {
             #[cfg(not(unix))]
             let _ = (i, meta);
         }
-        assert!(stats.warnings.is_empty(), "{:?}", stats.warnings);
+        assert_eq!(stats.warnings.len(), 0, "{:?}", stats.warnings);
     }
 
     /// Warnings respect the global budget: every file yields exactly one chown
diff --git a/crates/vykar-core/src/commands/restore/mod.rs b/crates/vykar-core/src/commands/restore/mod.rs
index 159851e..32b5c90 100644
--- a/crates/vykar-core/src/commands/restore/mod.rs
+++ b/crates/vykar-core/src/commands/restore/mod.rs
@@ -427,7 +427,7 @@ where
             Ok(())
         },
     )
-    .map_err(&cleanup)?;
+    .map_err(cleanup)?;
 
     drop(items_stream);
     repo.clear_chunk_index();
@@ -437,7 +437,7 @@ where
     // security-sensitive lchown, and a `rename` never disturbs a symlink's own
     // metadata.
     finalize::apply_symlink_metadata(&plan_out.symlinks, restore_as_root, &mut stats, shutdown)
-        .map_err(&cleanup)?;
+        .map_err(cleanup)?;
 
     // Relink hard-link group members now that every representative is written
     // and still in `temp_root` — both link operands share the temp filesystem,
@@ -457,7 +457,7 @@ where
         &mut stats,
         shutdown,
     )
-    .map_err(&cleanup)?;
+    .map_err(cleanup)?;
 
     // Phase 5a: rename temp subtrees into the final destination.  All file
     // metadata is already on the inodes, so the rename has no observable TOCTOU
@@ -478,7 +478,7 @@ where
     // poll the flag.
     #[cfg(test)]
     fault_pre_publish_shutdown(&temp_root, shutdown);
-    check_interrupted(shutdown).map_err(&cleanup)?;
+    check_interrupted(shutdown).map_err(cleanup)?;
     finalize::move_temp_to_dest(&temp_root, &dest_root)?;
 
     // Directory metadata (F1/F2: chown → xattrs → mode → mtime, deepest-first)
diff --git a/crates/vykar-core/src/commands/restore/plan.rs b/crates/vykar-core/src/commands/restore/plan.rs
index 35bcbf4..80bb476 100644
--- a/crates/vykar-core/src/commands/restore/plan.rs
+++ b/crates/vykar-core/src/commands/restore/plan.rs
@@ -905,7 +905,7 @@ mod tests {
         collect_all(&stream, dest, |_| true, false, &mut stats).unwrap();
 
         assert_eq!(stats.symlinks, 1);
-        assert!(stats.warnings.is_empty(), "got: {:?}", stats.warnings);
+        assert_eq!(stats.warnings.len(), 0, "got: {:?}", stats.warnings);
     }
 
     #[test]
@@ -1530,8 +1530,8 @@ mod tests {
             None,
             |files, chunks, verified, _stats| {
                 flush_calls += 1;
-                assert!(files.is_empty());
-                assert!(chunks.is_empty());
+                assert_eq!(files.len(), 0);
+                assert_eq!(chunks.len(), 0);
                 last_verified.clone_from(verified);
                 Ok(())
             },
diff --git a/crates/vykar-core/src/commands/util.rs b/crates/vykar-core/src/commands/util.rs
index b430f94..6a215d7 100644
--- a/crates/vykar-core/src/commands/util.rs
+++ b/crates/vykar-core/src/commands/util.rs
@@ -330,7 +330,8 @@ mod tests {
         assert_eq!(list.0[0].id, "sess1");
         assert_eq!(d.hostname, "host-a");
         assert_eq!(d.pid, 7);
-        assert!(!d.age.is_empty() && d.age != "unknown");
+        assert_ne!(d.age, "");
+        assert_ne!(d.age, "unknown");
         assert!(!list.has_malformed());
     }
 
diff --git a/crates/vykar-core/src/config/resolve/resolution.rs b/crates/vykar-core/src/config/resolve/resolution.rs
index d9e32a0..1f9ebd5 100644
--- a/crates/vykar-core/src/config/resolve/resolution.rs
+++ b/crates/vykar-core/src/config/resolve/resolution.rs
@@ -782,7 +782,7 @@ repositories: []
         fs::write(&path, yaml).unwrap();
 
         let result = load_and_resolve(&path).unwrap();
-        assert!(result.is_empty(), "expected empty vec for repositories: []");
+        assert_eq!(result.len(), 0, "expected empty vec for repositories: []");
     }
 
     #[test]
@@ -958,7 +958,7 @@ repositories:
         let sources = vec![make_test_source("docs")];
 
         let result = select_sources(&sources, &[]).unwrap();
-        assert!(result.is_empty());
+        assert_eq!(result.len(), 0);
     }
 }
 
@@ -990,7 +990,7 @@ hooks:
         assert_eq!(repos[0].global_hooks.get_hooks("before_backup").len(), 1);
         assert_eq!(repos[0].global_hooks.get_hooks("finally_backup").len(), 1);
         assert_eq!(repos[0].global_hooks.get_hooks("after").len(), 1);
-        assert!(repos[0].global_hooks.get_hooks("before").is_empty());
+        assert_eq!(repos[0].global_hooks.get_hooks("before").len(), 0);
     }
 
     #[test]
@@ -1004,8 +1004,8 @@ repositories:
         fs::write(&path, yaml).unwrap();
 
         let repos = load_and_resolve(&path).unwrap();
-        assert!(repos[0].global_hooks.is_empty());
-        assert!(repos[0].repo_hooks.is_empty());
+        assert_eq!(repos[0].global_hooks.hooks.len(), 0);
+        assert_eq!(repos[0].repo_hooks.hooks.len(), 0);
     }
 
     #[test]
@@ -1025,7 +1025,7 @@ repositories:
         fs::write(&path, yaml).unwrap();
 
         let repos = load_and_resolve(&path).unwrap();
-        assert!(repos[0].global_hooks.is_empty());
+        assert_eq!(repos[0].global_hooks.hooks.len(), 0);
         assert_eq!(repos[0].repo_hooks.get_hooks("before").len(), 1);
         assert_eq!(repos[0].repo_hooks.get_hooks("finally").len(), 1);
     }
@@ -1330,13 +1330,13 @@ sources:
         fs::write(&path, yaml).unwrap();
 
         let repos = load_and_resolve(&path).unwrap();
-        assert!(repos[0].config.exclude_if_present.is_empty());
+        assert_eq!(repos[0].config.exclude_if_present.len(), 0);
         assert!(!repos[0].config.one_file_system);
         assert!(!repos[0].config.git_ignore);
         assert!(repos[0].config.xattrs.enabled);
 
         let src = &repos[0].sources[0];
-        assert!(src.exclude_if_present.is_empty());
+        assert_eq!(src.exclude_if_present.len(), 0);
         assert!(!src.one_file_system);
         assert!(!src.git_ignore);
         assert!(src.xattrs_enabled);
@@ -1452,8 +1452,8 @@ sources:
         let hooks = &repos[0].sources[0].hooks;
         assert_eq!(hooks.before, vec!["echo single"]);
         assert_eq!(hooks.after, vec!["echo first", "echo second"]);
-        assert!(hooks.failed.is_empty());
-        assert!(hooks.finally.is_empty());
+        assert_eq!(hooks.failed.len(), 0);
+        assert_eq!(hooks.finally.len(), 0);
     }
 
     #[test]
@@ -1494,7 +1494,7 @@ repositories:
         fs::write(&path, yaml).unwrap();
 
         let repos = load_and_resolve(&path).unwrap();
-        assert!(repos[0].sources.is_empty());
+        assert_eq!(repos[0].sources.len(), 0);
     }
 
     #[test]
@@ -1815,7 +1815,7 @@ sources:
 
         let repos = load_and_resolve(&path).unwrap();
         let source = &repos[0].sources[0];
-        assert!(source.paths.is_empty());
+        assert_eq!(source.paths.len(), 0);
         assert_eq!(source.label, "databases");
         assert_eq!(source.command_dumps.len(), 1);
     }
diff --git a/crates/vykar-core/src/config/resolve/template.rs b/crates/vykar-core/src/config/resolve/template.rs
index d89d386..6c96af0 100644
--- a/crates/vykar-core/src/config/resolve/template.rs
+++ b/crates/vykar-core/src/config/resolve/template.rs
@@ -61,6 +61,6 @@ mod tests {
         // With repositories commented out, resolve_document should return an empty vec.
         let raw = parsed.unwrap();
         let result = resolve_document(raw).unwrap();
-        assert!(result.is_empty(), "expected empty vec for template config");
+        assert_eq!(result.len(), 0, "expected empty vec for template config");
     }
 }
diff --git a/crates/vykar-core/src/index/mod.rs b/crates/vykar-core/src/index/mod.rs
index 46fd543..d5884c5 100644
--- a/crates/vykar-core/src/index/mod.rs
+++ b/crates/vykar-core/src/index/mod.rs
@@ -512,7 +512,7 @@ mod tests {
     #[test]
     fn pending_journal_round_trip() {
         let mut journal = PendingIndexJournal::new();
-        assert!(journal.is_empty());
+        assert_eq!(journal.len(), 0);
         assert_eq!(journal.len(), 0);
 
         let pack1 = make_pack_id(1);
@@ -543,7 +543,7 @@ mod tests {
         );
 
         assert_eq!(journal.len(), 2);
-        assert!(!journal.is_empty());
+        assert_ne!(journal.len(), 0);
 
         // Serialize → deserialize round-trip
         let wire = journal.to_wire();
@@ -604,7 +604,7 @@ mod tests {
 
         let reconciled = delta.reconcile(&fresh).unwrap();
         // new_entries should be empty (converted to bump)
-        assert!(reconciled.new_entries.is_empty());
+        assert_eq!(reconciled.new_entries.len(), 0);
         // refcount_bumps should have chunk_a with count=1
         assert_eq!(reconciled.refcount_bumps.get(&chunk_a), Some(&1));
     }
@@ -636,7 +636,7 @@ mod tests {
         delta.bump_refcount(&chunk_a);
 
         let reconciled = delta.reconcile(&fresh).unwrap();
-        assert!(reconciled.new_entries.is_empty());
+        assert_eq!(reconciled.new_entries.len(), 0);
         assert_eq!(reconciled.refcount_bumps.get(&chunk_a), Some(&1));
     }
 
@@ -699,8 +699,8 @@ mod tests {
         let mut delta = IndexDelta::new();
         delta.add_new_entry(make_chunk_id(1), 100, make_pack_id(1), 0, 1);
         delta.rollback(cp);
-        assert!(delta.new_entries.is_empty());
-        assert!(delta.refcount_bumps.is_empty());
+        assert_eq!(delta.new_entries.len(), 0);
+        assert_eq!(delta.refcount_bumps.len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/limits.rs b/crates/vykar-core/src/limits.rs
index 283b7d1..a30e696 100644
--- a/crates/vykar-core/src/limits.rs
+++ b/crates/vykar-core/src/limits.rs
@@ -429,7 +429,7 @@ mod tests {
         let response = wrapped
             .server_verify_packs(&plan)
             .expect("verify forwarded");
-        assert!(response.results.is_empty());
+        assert_eq!(response.results.len(), 0);
         wrapped.server_init().expect("init forwarded");
 
         assert_eq!(verify_calls.load(Ordering::SeqCst), 1);
diff --git a/crates/vykar-core/src/repo/file_cache.rs b/crates/vykar-core/src/repo/file_cache.rs
index 5386327..8062c0a 100644
--- a/crates/vykar-core/src/repo/file_cache.rs
+++ b/crates/vykar-core/src/repo/file_cache.rs
@@ -1334,7 +1334,7 @@ mod tests {
     #[test]
     fn empty_cache() {
         let cache = FileCache::new();
-        assert!(cache.is_empty());
+        assert_eq!(cache.len(), 0);
         assert_eq!(cache.len(), 0);
     }
 
@@ -1496,7 +1496,7 @@ mod tests {
             section.anchor_snapshot_id,
             SnapshotId::from_bytes([0x42; 32])
         );
-        assert!(cache.sections.is_empty());
+        assert_eq!(cache.sections.len(), 0);
     }
 
     #[test]
@@ -1509,7 +1509,7 @@ mod tests {
 
         let taken = cache.take_active_sections();
         assert_eq!(taken.len(), 2);
-        assert!(cache.sections.is_empty());
+        assert_eq!(cache.sections.len(), 0);
     }
 
     #[test]
@@ -1576,7 +1576,7 @@ mod tests {
         let old = OldFileCache { entries };
         let plaintext = rmp_serde::to_vec(&old).unwrap();
         let decoded = FileCache::decode_from_plaintext(&plaintext).unwrap();
-        assert!(decoded.is_empty());
+        assert_eq!(decoded.len(), 0);
     }
 
     #[test]
@@ -1586,7 +1586,7 @@ mod tests {
         let mut blob = vec![FORMAT_VERSION_BYTE];
         blob.extend_from_slice(b"\xFF\xFE\xFD not a zstd frame");
         let decoded = FileCache::decode_from_plaintext(&blob).unwrap();
-        assert!(decoded.is_empty());
+        assert_eq!(decoded.len(), 0);
     }
 
     #[test]
@@ -1594,7 +1594,7 @@ mod tests {
         let garbage = vec![0xFF, 0xFE, 0xFD];
         let result = FileCache::decode_from_plaintext(&garbage);
         assert!(result.is_ok());
-        assert!(result.unwrap().is_empty());
+        assert_eq!(result.unwrap().len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-core/src/repo/write_session.rs b/crates/vykar-core/src/repo/write_session.rs
index f95f538..7af6b30 100644
--- a/crates/vykar-core/src/repo/write_session.rs
+++ b/crates/vykar-core/src/repo/write_session.rs
@@ -827,8 +827,8 @@ mod tests {
             recovery.recovered_chunks, 0,
             "should skip active session's journal"
         );
-        assert!(recovery.recovered_sessions.is_empty());
-        assert!(ws.recovered_index_keys.is_empty());
+        assert_eq!(recovery.recovered_sessions.len(), 0);
+        assert_eq!(ws.recovered_index_keys.len(), 0);
     }
 
     #[test]
@@ -855,8 +855,8 @@ mod tests {
             recovery.recovered_chunks, 0,
             "should skip session with unknown marker state"
         );
-        assert!(recovery.recovered_sessions.is_empty());
-        assert!(ws.recovered_index_keys.is_empty());
+        assert_eq!(recovery.recovered_sessions.len(), 0);
+        assert_eq!(ws.recovered_index_keys.len(), 0);
     }
 
     #[test]
@@ -992,6 +992,6 @@ mod tests {
             storage.exists(&stale_json).unwrap(),
             "stale .json must not be deleted by cleanup"
         );
-        assert!(ws.recovered_index_keys.is_empty(), "keys should be drained");
+        assert_eq!(ws.recovered_index_keys.len(), 0, "keys should be drained");
     }
 }
diff --git a/crates/vykar-core/src/tests/app_ops.rs b/crates/vykar-core/src/tests/app_ops.rs
index 54b429a..6820534 100644
--- a/crates/vykar-core/src/tests/app_ops.rs
+++ b/crates/vykar-core/src/tests/app_ops.rs
@@ -35,5 +35,5 @@ fn run_backup_selection_returns_created_source_report() {
     assert_eq!(report.created[0].source_label, "src-a");
     assert_eq!(report.created[0].source_paths.len(), 1);
     assert!(report.created[0].stats.nfiles > 0);
-    assert!(!report.created[0].snapshot_name.is_empty());
+    assert_ne!(report.created[0].snapshot_name, "");
 }
diff --git a/crates/vykar-core/src/tests/check_command.rs b/crates/vykar-core/src/tests/check_command.rs
index 07f1564..af429ad 100644
--- a/crates/vykar-core/src/tests/check_command.rs
+++ b/crates/vykar-core/src/tests/check_command.rs
@@ -64,13 +64,13 @@ fn check_verify_data_flag_controls_data_verification_counters() {
     backup_single_source(&config, &source_dir, "src-a", "snap-check-verify");
 
     let without_verify = commands::check::run(&config, None, false, false).unwrap();
-    assert!(without_verify.errors.is_empty());
+    assert_eq!(without_verify.errors.len(), 0);
     assert_eq!(without_verify.chunks_data_verified, 0);
     assert!(without_verify.chunks_existence_checked > 0);
     assert!(without_verify.packs_existence_checked > 0);
 
     let with_verify = commands::check::run(&config, None, true, false).unwrap();
-    assert!(with_verify.errors.is_empty());
+    assert_eq!(with_verify.errors.len(), 0);
     assert!(with_verify.chunks_data_verified > 0);
     assert!(with_verify.chunks_existence_checked > 0);
     assert!(with_verify.packs_existence_checked > 0);
@@ -111,7 +111,7 @@ fn sampled_check_preserves_local_fallback_counters() {
                 None,
             )
             .unwrap();
-            assert!(result.errors.is_empty());
+            assert_eq!(result.errors.len(), 0);
             assert_eq!(result.snapshots_checked, 1);
             assert_eq!(result.packs_existence_checked, packs.len().div_ceil(2));
             assert!(result.chunks_existence_checked > 0);
@@ -224,8 +224,8 @@ fn check_with_progress_emits_phase_events() {
         None,
     )
     .unwrap();
-    assert!(result.errors.is_empty());
-    assert!(!events.is_empty());
+    assert_eq!(result.errors.len(), 0);
+    assert_ne!(events.len(), 0);
     assert!(events.iter().any(|e| matches!(
         e,
         commands::check::CheckProgressEvent::SnapshotStarted { .. }
@@ -257,7 +257,7 @@ fn check_deduplicates_pack_existence_checks() {
     backup_single_source(&config, &source_dir, "src-dedup", "snap-dedup");
 
     let result = commands::check::run(&config, None, false, false).unwrap();
-    assert!(result.errors.is_empty());
+    assert_eq!(result.errors.len(), 0);
     assert!(result.chunks_existence_checked > 0);
     assert!(result.packs_existence_checked > 0);
     // Multiple chunks should share packs, so packs checked < chunks checked
@@ -386,7 +386,7 @@ fn test_process_verify_response_duplicate_keys() {
     );
     assert_eq!(result.packs_passed, 1);
     assert_eq!(result.chunks_verified, 5, "chunks counted only once");
-    assert!(errors.is_empty());
+    assert_eq!(errors.len(), 0);
 }
 
 #[test]
@@ -654,7 +654,7 @@ fn check_reports_items_affected_by_missing_pack() {
     for impact in &result.item_impacts {
         assert_eq!(impact.snapshot_id, snapshot_id);
         assert_eq!(impact.snapshot_name, "snap-impact");
-        assert!(!impact.affected_chunks.is_empty());
+        assert_ne!(impact.affected_chunks.len(), 0);
         // Every chunk in this impact must point at the deleted pack.
         for (_chunk_id, pack_id) in &impact.affected_chunks {
             assert_eq!(*pack_id, deleted_pack);
@@ -705,7 +705,7 @@ fn check_repair_dry_run_includes_item_impact() {
 
     let (deleted_pack, expected_items) = pick_data_only_pack(&repo_dir);
     std::fs::remove_file(repo_dir.join(deleted_pack.storage_key())).unwrap();
-    assert!(!expected_items.is_empty());
+    assert_ne!(expected_items.len(), 0);
 
     let result =
         commands::check::run_with_repair(&config, None, false, RepairMode::PlanOnly, None, None)
@@ -730,7 +730,7 @@ fn check_repair_dry_run_includes_item_impact() {
             .collect::<Vec<_>>()
     );
     // No repair was applied (PlanOnly mode).
-    assert!(result.applied.is_empty());
+    assert_eq!(result.applied.len(), 0);
 }
 
 // ---------------------------------------------------------------------------
@@ -759,7 +759,7 @@ fn repair_drops_items_via_missing_pack_keeps_snapshot() {
     backup_single_source(&config, &source_dir, "src-drop", "snap-drop");
 
     let (deleted_pack, expected_items) = pick_data_only_pack(&repo_dir);
-    assert!(!expected_items.is_empty());
+    assert_ne!(expected_items.len(), 0);
     // Only run the test when *some* but not *all* items would be dropped —
     // otherwise the planner would correctly fall back to whole-snapshot.
     assert!(
@@ -903,7 +903,8 @@ fn repair_dry_run_emits_drop_items_from_snapshot() {
     backup_single_source(&config, &source_dir, "src-pln", "snap-pln");
 
     let (deleted_pack, expected_items) = pick_data_only_pack(&repo_dir);
-    assert!(!expected_items.is_empty() && expected_items.len() < 3);
+    assert_ne!(expected_items.len(), 0);
+    assert!(expected_items.len() < 3);
     std::fs::remove_file(repo_dir.join(deleted_pack.storage_key())).unwrap();
 
     let result =
@@ -939,7 +940,7 @@ fn repair_dry_run_emits_drop_items_from_snapshot() {
         }
     }
     // PlanOnly should not have applied anything.
-    assert!(result.applied.is_empty());
+    assert_eq!(result.applied.len(), 0);
 }
 
 /// Two snapshots reference distinct file data; dropping items from one must
@@ -970,7 +971,7 @@ fn repair_drops_items_rebuilds_refcounts() {
     backup_single_source(&config, &source_b, "src-b", "snap-b");
 
     let (deleted_pack, expected_items) = pick_data_only_pack(&repo_dir);
-    assert!(!expected_items.is_empty());
+    assert_ne!(expected_items.len(), 0);
     // Filter to the snapshot we actually want to mutate. The picker may pick
     // any data-only pack; require the affected items to all be in snap-a so
     // the test asserts hold.
@@ -1503,7 +1504,7 @@ fn interrupted_check_does_not_record_full_check() {
     let control =
         commands::check::run_with_progress(&config, None, false, false, None, 100, true, None)
             .unwrap();
-    assert!(control.errors.is_empty(), "control run must be clean");
+    assert_eq!(control.errors.len(), 0, "control run must be clean");
     assert_eq!(
         check_state_files(&control_cache).len(),
         1,
diff --git a/crates/vykar-core/src/tests/chunker.rs b/crates/vykar-core/src/tests/chunker.rs
index 708e16b..ae26b60 100644
--- a/crates/vykar-core/src/tests/chunker.rs
+++ b/crates/vykar-core/src/tests/chunker.rs
@@ -70,7 +70,7 @@ fn small_data_single_chunk() {
 fn empty_data_no_chunks() {
     let config = test_config();
     let chunks = chunk_data(b"", &config);
-    assert!(chunks.is_empty());
+    assert_eq!(chunks.len(), 0);
 }
 
 #[test]
diff --git a/crates/vykar-core/src/tests/coalesced_read.rs b/crates/vykar-core/src/tests/coalesced_read.rs
index b7ee75d..bbbbabf 100644
--- a/crates/vykar-core/src/tests/coalesced_read.rs
+++ b/crates/vykar-core/src/tests/coalesced_read.rs
@@ -228,7 +228,7 @@ fn empty_input_is_noop() {
     repo.read_chunks_coalesced_into(&[], &mut out, None)
         .unwrap();
 
-    assert!(out.is_empty());
+    assert_eq!(out.len(), 0);
     assert_eq!(log.get_range_count(), 0);
 }
 
@@ -456,5 +456,5 @@ fn pre_cancelled_coalesced_read_issues_no_request() {
         "expected Interrupted, got: {err}"
     );
     assert_eq!(reads.load(Ordering::Relaxed), 0, "expected no range reads");
-    assert!(out.is_empty(), "nothing may be emitted");
+    assert_eq!(out.len(), 0, "nothing may be emitted");
 }
diff --git a/crates/vykar-core/src/tests/delete.rs b/crates/vykar-core/src/tests/delete.rs
index d100590..fbecab6 100644
--- a/crates/vykar-core/src/tests/delete.rs
+++ b/crates/vykar-core/src/tests/delete.rs
@@ -35,7 +35,7 @@ fn delete_dry_run_reports_impact_without_mutation() {
 
     let result = commands::delete::run(&config, None, &["snap-delete-dry"], true, None).unwrap();
     assert_eq!(result.stats.len(), 1);
-    assert!(result.warnings.is_empty());
+    assert_eq!(result.warnings.len(), 0);
     let stats = &result.stats[0];
     assert_eq!(stats.snapshot_name, "snap-delete-dry");
     assert!(stats.chunks_deleted > 0);
@@ -69,7 +69,7 @@ fn delete_snapshot_removes_manifest_entry_and_chunk_refs() {
 
     let result = commands::delete::run(&config, None, &["snap-delete-live"], false, None).unwrap();
     assert_eq!(result.stats.len(), 1);
-    assert!(result.warnings.is_empty());
+    assert_eq!(result.warnings.len(), 0);
     let stats = &result.stats[0];
     assert_eq!(stats.snapshot_name, "snap-delete-live");
     assert!(stats.chunks_deleted > 0);
@@ -135,7 +135,7 @@ fn delete_multiple_snapshots_in_single_call() {
     // Delete first two in one call.
     let result = commands::delete::run(&config, None, &["snap-1", "snap-2"], false, None).unwrap();
     assert_eq!(result.stats.len(), 2);
-    assert!(result.warnings.is_empty());
+    assert_eq!(result.warnings.len(), 0);
     assert_eq!(result.stats[0].snapshot_name, "snap-1");
     assert_eq!(result.stats[1].snapshot_name, "snap-2");
 
@@ -144,7 +144,7 @@ fn delete_multiple_snapshots_in_single_call() {
     assert!(after.manifest().find_snapshot("snap-2").is_none());
     assert!(after.manifest().find_snapshot("snap-3").is_some());
     // snap-3 still has chunks
-    assert!(!after.chunk_index().is_empty());
+    assert_ne!(after.chunk_index().len(), 0);
     drop(after);
 
     // Restore snap-3 and verify its data is intact (catches over-decrement).
@@ -215,7 +215,7 @@ fn delete_deduplicates_snapshot_names() {
     let result =
         commands::delete::run(&config, None, &["snap-dup", "snap-dup"], false, None).unwrap();
     assert_eq!(result.stats.len(), 1);
-    assert!(result.warnings.is_empty());
+    assert_eq!(result.warnings.len(), 0);
     assert_eq!(result.stats[0].snapshot_name, "snap-dup");
 
     let after = open_local_repo(&repo_dir);
@@ -350,7 +350,7 @@ fn delete_single_snapshot_handles_empty_stats() {
 
     let result = commands::delete::run(&config, None, &["snap-wrapper"], false, None)
         .expect("delete must not fail after commit point");
-    assert!(result.stats.is_empty());
+    assert_eq!(result.stats.len(), 0);
     assert_eq!(result.warnings.len(), 1);
     assert!(result.warnings[0].contains("snap-wrapper"));
 }
diff --git a/crates/vykar-core/src/tests/delete_repo.rs b/crates/vykar-core/src/tests/delete_repo.rs
index a376f0c..4810f51 100644
--- a/crates/vykar-core/src/tests/delete_repo.rs
+++ b/crates/vykar-core/src/tests/delete_repo.rs
@@ -18,7 +18,7 @@ fn delete_repo_removes_local_directory() {
 
     let stats = commands::delete_repo::run(&config).unwrap();
     assert!(stats.keys_deleted > 0);
-    assert!(stats.unknown_entries.is_empty());
+    assert_eq!(stats.unknown_entries.len(), 0);
     assert!(stats.root_removed);
     assert!(!repo_dir.exists());
 }
@@ -101,7 +101,7 @@ fn delete_repo_handles_partial_repo() {
     // delete_repo should still succeed because packs/snapshots/keys remain
     let stats = commands::delete_repo::run(&config).unwrap();
     assert!(stats.keys_deleted > 0, "should have deleted remaining keys");
-    assert!(stats.unknown_entries.is_empty());
+    assert_eq!(stats.unknown_entries.len(), 0);
     assert!(stats.root_removed, "repo dir should be fully removed");
     assert!(!repo_dir.exists());
 }
@@ -165,7 +165,7 @@ fn delete_repo_deletes_all_nested_keys() {
 
     let stats = commands::delete_repo::run(&config).unwrap();
     assert_eq!(stats.keys_deleted, all_keys_before.len() as u64);
-    assert!(stats.unknown_entries.is_empty());
+    assert_eq!(stats.unknown_entries.len(), 0);
     assert!(stats.root_removed);
     assert!(!repo_dir.exists());
 }
diff --git a/crates/vykar-core/src/tests/hostname.rs b/crates/vykar-core/src/tests/hostname.rs
index 3ff66d7..4ab1455 100644
--- a/crates/vykar-core/src/tests/hostname.rs
+++ b/crates/vykar-core/src/tests/hostname.rs
@@ -45,6 +45,6 @@ fn backup_whitespace_hostname_falls_back_to_default() {
     let repo = helpers::open_local_repo(repo_dir.path());
     let entry = repo.manifest().find_snapshot("snap-ws").unwrap();
     // Should fall back to short_hostname(), not be whitespace
-    assert!(!entry.hostname.trim().is_empty());
+    assert_ne!(entry.hostname.trim(), "");
     assert!(!entry.hostname.contains('.') || entry.hostname == "unknown");
 }
diff --git a/crates/vykar-core/src/tests/index.rs b/crates/vykar-core/src/tests/index.rs
index b973826..7724445 100644
--- a/crates/vykar-core/src/tests/index.rs
+++ b/crates/vykar-core/src/tests/index.rs
@@ -14,7 +14,7 @@ fn dummy_pack_id() -> PackId {
 #[test]
 fn new_index_is_empty() {
     let index = ChunkIndex::new();
-    assert!(index.is_empty());
+    assert_eq!(index.len(), 0);
     assert_eq!(index.len(), 0);
 }
 
@@ -70,7 +70,7 @@ fn decrement_to_zero_removes_entry() {
     let result = index.decrement(&id);
     assert_eq!(result, Some((0, 100)));
     assert!(!index.contains(&id));
-    assert!(index.is_empty());
+    assert_eq!(index.len(), 0);
 }
 
 #[test]
diff --git a/crates/vykar-core/src/tests/item.rs b/crates/vykar-core/src/tests/item.rs
index b30a5e5..c9bfb2f 100644
--- a/crates/vykar-core/src/tests/item.rs
+++ b/crates/vykar-core/src/tests/item.rs
@@ -88,7 +88,7 @@ fn item_serde_roundtrip_directory() {
     let deserialized: Item = rmp_serde::from_slice(&serialized).unwrap();
     assert_eq!(deserialized.path, "home/user");
     assert_eq!(deserialized.entry_type, ItemType::Directory);
-    assert!(deserialized.chunks.is_empty());
+    assert_eq!(deserialized.chunks.len(), 0);
 }
 
 #[test]
diff --git a/crates/vykar-core/src/tests/lock.rs b/crates/vykar-core/src/tests/lock.rs
index 25c2220..5ac39d5 100644
--- a/crates/vykar-core/src/tests/lock.rs
+++ b/crates/vykar-core/src/tests/lock.rs
@@ -378,7 +378,7 @@ fn cleanup_stale_sessions_preserves_active_index() {
         pid_always_alive,
     )
     .unwrap();
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(storage.exists("sessions/sess1.json").unwrap());
     assert!(
         storage.exists("sessions/sess1.index").unwrap(),
@@ -428,7 +428,7 @@ fn cleanup_stale_sessions_removes_orphaned_index() {
         pid_always_alive,
     )
     .unwrap();
-    assert!(cleaned.is_empty(), "no .json marker to report as cleaned");
+    assert_eq!(cleaned.len(), 0, "no .json marker to report as cleaned");
     assert!(
         !storage.exists("sessions/orphan.index").unwrap(),
         "orphaned .index should be deleted"
@@ -455,7 +455,7 @@ fn cleanup_stale_sessions_skips_non_json_files() {
         pid_always_alive,
     )
     .unwrap();
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(
         storage.exists("sessions/active.index").unwrap(),
         ".index should not be treated as unparseable .json"
@@ -495,7 +495,7 @@ fn cleanup_preserves_alive_local_session() {
 
     let cleaned =
         cleanup_stale_sessions(&storage, Duration::hours(72), "myhost", |_pid| true).unwrap();
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(storage.exists("sessions/local-alive.json").unwrap());
 }
 
@@ -551,7 +551,7 @@ fn cleanup_second_pass_removes_orphan_index_from_prior_run() {
         pid_always_alive,
     )
     .unwrap();
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(
         !storage.exists("sessions/prior.index").unwrap(),
         ".index should be deleted on second cleanup (grace period expired)"
@@ -613,7 +613,7 @@ fn cleanup_keeps_session_at_44_minutes() {
         pid_always_alive,
     )
     .unwrap();
-    assert!(cleaned.is_empty(), "44-min session must not be reaped");
+    assert_eq!(cleaned.len(), 0, "44-min session must not be reaped");
     assert!(storage.exists("sessions/fresh.json").unwrap());
 }
 
@@ -652,7 +652,7 @@ fn cleanup_preserves_malformed_marker() {
 
     // Malformed markers are not reported as "cleaned" and must NOT be
     // deleted — they fail-close maintenance until an operator clears them.
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(
         storage.exists("sessions/bad.json").unwrap(),
         "malformed .json must be preserved so maintenance surfaces it"
@@ -678,7 +678,7 @@ fn cleanup_preserves_marker_with_bad_timestamp() {
     )
     .unwrap();
 
-    assert!(cleaned.is_empty());
+    assert_eq!(cleaned.len(), 0);
     assert!(
         storage.exists("sessions/bad-ts.json").unwrap(),
         "marker with unparseable timestamp must survive cleanup"
diff --git a/crates/vykar-core/src/tests/manifest.rs b/crates/vykar-core/src/tests/manifest.rs
index 57488f9..b396c43 100644
--- a/crates/vykar-core/src/tests/manifest.rs
+++ b/crates/vykar-core/src/tests/manifest.rs
@@ -30,7 +30,7 @@ fn make_entry_at(name: &str, offset_secs: i64) -> SnapshotEntry {
 #[test]
 fn new_manifest_has_no_snapshots() {
     let m = Manifest::new();
-    assert!(m.snapshots.is_empty());
+    assert_eq!(m.snapshots.len(), 0);
     assert_eq!(m.version, 1);
 }
 
diff --git a/crates/vykar-core/src/tests/prune.rs b/crates/vykar-core/src/tests/prune.rs
index 49abf1a..be8ee40 100644
--- a/crates/vykar-core/src/tests/prune.rs
+++ b/crates/vykar-core/src/tests/prune.rs
@@ -98,7 +98,7 @@ fn empty_snapshots_returns_empty() {
         ..Default::default()
     };
     let results = apply_policy(&[], &policy, Utc::now()).unwrap();
-    assert!(results.is_empty());
+    assert_eq!(results.len(), 0);
 }
 
 fn snap_at(name: &str, time: DateTime<Utc>) -> SnapshotEntry {
diff --git a/crates/vykar-core/src/tests/prune_command.rs b/crates/vykar-core/src/tests/prune_command.rs
index c9e6190..ba27ad4 100644
--- a/crates/vykar-core/src/tests/prune_command.rs
+++ b/crates/vykar-core/src/tests/prune_command.rs
@@ -252,7 +252,7 @@ fn prune_phase3_refcount_failure_returns_warning_not_error() {
 
     // One snapshot was pruned (blob deleted) but its Phase 3 cleanup failed.
     assert_eq!(stats.pruned, 1);
-    assert!(!stats.warnings.is_empty(), "expected a Phase 3 warning");
+    assert_ne!(stats.warnings.len(), 0, "expected a Phase 3 warning");
     let combined = stats.warnings.join("\n");
     assert!(
         combined.contains("vykar check --repair"),
diff --git a/crates/vykar-core/src/tests/repo.rs b/crates/vykar-core/src/tests/repo.rs
index 210c441..4d0e66a 100644
--- a/crates/vykar-core/src/tests/repo.rs
+++ b/crates/vykar-core/src/tests/repo.rs
@@ -340,11 +340,12 @@ fn index_delta_is_empty() {
     use crate::index::IndexDelta;
 
     let empty = IndexDelta::new();
-    assert!(empty.is_empty());
+    assert_eq!(empty.new_entries.len(), 0);
+    assert_eq!(empty.refcount_bumps.len(), 0);
 
     let mut with_bump = IndexDelta::new();
     with_bump.bump_refcount(&vykar_types::chunk_id::ChunkId::from_bytes([0xAA; 32]));
-    assert!(!with_bump.is_empty());
+    assert_ne!(with_bump.refcount_bumps.len(), 0);
 }
 
 /// Compute the file cache path the same way `FileCache::cache_path` does.
@@ -372,7 +373,7 @@ fn deferred_hydration_survives_file_cache_save_error() {
     // Start a new write session and enable dedup mode (drops full index, activates deferred hydration path)
     repo.begin_write_session().unwrap();
     repo.enable_dedup_mode();
-    assert!(repo.chunk_index().is_empty());
+    assert_eq!(repo.chunk_index().len(), 0);
 
     // Mark file_cache dirty so save_state() will attempt file_cache.save()
     repo.mark_file_cache_dirty();
diff --git a/crates/vykar-core/tests/common/mod.rs b/crates/vykar-core/tests/common/mod.rs
index b2dde6f..81bbf65 100644
--- a/crates/vykar-core/tests/common/mod.rs
+++ b/crates/vykar-core/tests/common/mod.rs
@@ -245,7 +245,7 @@ pub fn exercise_pack_naming(
     );
 
     let deleted = commands::delete::run(config, passphrase, &["pn-a"], false, None).unwrap();
-    assert!(deleted.warnings.is_empty(), "{:?}", deleted.warnings);
+    assert_eq!(deleted.warnings.len(), 0, "{:?}", deleted.warnings);
 
     let compact = commands::compact::run(config, passphrase, 0.0, None, false, None).unwrap();
     assert!(
diff --git a/crates/vykar-core/tests/integration.rs b/crates/vykar-core/tests/integration.rs
index 18b045b..82a30d5 100644
--- a/crates/vykar-core/tests/integration.rs
+++ b/crates/vykar-core/tests/integration.rs
@@ -484,7 +484,7 @@ fn backup_deduplicates_identical_files_and_extracts_correctly() {
 
     let first_ids: Vec<_> = file_items[0].chunks.iter().map(|c| c.id).collect();
     let second_ids: Vec<_> = file_items[1].chunks.iter().map(|c| c.id).collect();
-    assert!(!first_ids.is_empty());
+    assert_ne!(first_ids.len(), 0);
     assert_eq!(first_ids, second_ids);
 
     for chunk_id in first_ids {
@@ -3005,9 +3005,9 @@ fn session_guard_blocks_maintenance() {
             let info = &list.0[0];
             assert_eq!(info.id, session_id);
             let d = info.details.as_ref().expect("parseable marker");
-            assert!(!d.hostname.is_empty(), "hostname should be populated");
+            assert_ne!(d.hostname, "", "hostname should be populated");
             assert!(d.pid > 0, "pid should be populated");
-            assert!(!d.age.is_empty(), "age should be populated");
+            assert_ne!(d.age, "", "age should be populated");
             assert!(!list.has_malformed());
         }
         other => panic!("expected ActiveSessions, got: {other}"),
@@ -3071,7 +3071,7 @@ fn maintenance_reaps_session_older_than_45_minutes() {
     // Sanity: listing sessions should now be empty.
     let storage = Box::new(LocalBackend::new(repo_dir.to_str().unwrap()).unwrap());
     let remaining = lock::list_sessions(storage.as_ref()).unwrap();
-    assert!(remaining.is_empty(), "no sessions should remain");
+    assert_eq!(remaining.len(), 0, "no sessions should remain");
 }
 
 #[test]
diff --git a/crates/vykar-core/tests/key_copies.rs b/crates/vykar-core/tests/key_copies.rs
index b2ce083..e8dfd33 100644
--- a/crates/vykar-core/tests/key_copies.rs
+++ b/crates/vykar-core/tests/key_copies.rs
@@ -654,7 +654,7 @@ fn unencrypted_repositories_skip_the_key_phase() {
     let result = commands::check::run(&config, None, false, false).unwrap();
     assert_eq!(result.key_files_checked, None);
     assert!(!repo_dir.join("keys").join("repokey").exists());
-    assert!(result.errors.is_empty(), "{:?}", result.errors);
+    assert_eq!(result.errors.len(), 0, "{:?}", result.errors);
 }
 
 // ---------------------------------------------------------------------------
@@ -757,7 +757,7 @@ fn a_contradicting_pin_beats_self_consistent_repository_data() {
 fn proving_a_key_never_writes_a_pin() {
     let fx = Fixture::new();
     fx.forget_pin();
-    assert!(fx.pin_files().is_empty());
+    assert_eq!(fx.pin_files().len(), 0);
 
     let foreign = {
         let encrypted = vykar_crypto::key::inspect_key_blob(&foreign_key_blob()).unwrap();
@@ -1003,7 +1003,7 @@ fn a_provable_genuine_key_still_wins_against_a_planted_copy() {
         .open_with(ATTACKER_PASS)
         .err()
         .expect("the planted key is not provable, so it must not open the repository");
-    assert!(!err.to_string().is_empty());
+    assert_ne!(err.to_string(), "");
 
     // No pin may have been created for the planted key.
     assert!(
diff --git a/crates/vykar-core/tests/lifecycle_integration.rs b/crates/vykar-core/tests/lifecycle_integration.rs
index ce154db..a0c4296 100644
--- a/crates/vykar-core/tests/lifecycle_integration.rs
+++ b/crates/vykar-core/tests/lifecycle_integration.rs
@@ -59,7 +59,7 @@ fn lifecycle_delete_compact_check_and_restore() {
     );
 
     let delete_result = commands::delete::run(&config, None, &["snap-v1"], false, None).unwrap();
-    assert!(delete_result.warnings.is_empty());
+    assert_eq!(delete_result.warnings.len(), 0);
     let stats = delete_result
         .stats
         .first()
@@ -178,7 +178,7 @@ fn prune_compact_check_and_restore_kept_snapshots() {
     );
 
     let check = commands::check::run(&config, None, true, false).unwrap();
-    assert!(check.errors.is_empty());
+    assert_eq!(check.errors.len(), 0);
 
     let repo = open_local_repo(&repo_dir, None);
     let names: Vec<_> = repo
@@ -257,7 +257,7 @@ fn run_encrypted_lifecycle(mode: EncryptionModeConfig, expected_mode: Encryption
     );
 
     let check = commands::check::run(&config, Some(passphrase), true, false).unwrap();
-    assert!(check.errors.is_empty());
+    assert_eq!(check.errors.len(), 0);
 
     let restore_dir = tmp.path().join("restore");
     commands::restore::run(
@@ -510,7 +510,7 @@ fn restore_loads_items_via_restore_cache_without_index() {
     )
     .unwrap();
 
-    assert!(!items.is_empty());
+    assert_ne!(items.len(), 0);
     assert!(items.iter().any(|i| i.path.contains("file.txt")));
 
     // The chunk index must still be empty — never loaded
diff --git a/crates/vykar-gui/src/autostart.rs b/crates/vykar-gui/src/autostart.rs
index 46d5831..310d1d1 100644
--- a/crates/vykar-gui/src/autostart.rs
+++ b/crates/vykar-gui/src/autostart.rs
@@ -66,7 +66,7 @@ mod tests {
     #[test]
     fn resolve_exe_path_fallback() {
         let get = |_: &str| Err(std::env::VarError::NotPresent);
-        assert!(!resolve_exe_path_with(get).unwrap().is_empty());
+        assert_ne!(resolve_exe_path_with(get).unwrap(), "");
     }
 
     #[test]
diff --git a/crates/vykar-gui/src/config_helpers.rs b/crates/vykar-gui/src/config_helpers.rs
index 34d78d0..127b6b0 100644
--- a/crates/vykar-gui/src/config_helpers.rs
+++ b/crates/vykar-gui/src/config_helpers.rs
@@ -208,7 +208,7 @@ mod tests {
         std::fs::write(&path, config::minimal_config_template()).unwrap();
 
         let repos = validate_config(&path).expect("empty config validates");
-        assert!(repos.is_empty());
+        assert_eq!(repos.len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-gui/src/file_tree/builder.rs b/crates/vykar-gui/src/file_tree/builder.rs
index 897eafa..31e4bb2 100644
--- a/crates/vykar-gui/src/file_tree/builder.rs
+++ b/crates/vykar-gui/src/file_tree/builder.rs
@@ -220,7 +220,7 @@ mod tests {
         assert_eq!(tree.roots.len(), 1);
         let root = &tree.arena[tree.roots[0]];
         assert_eq!(root.name, "adam");
-        assert!(root.item_paths.is_empty(), "root should be synthetic");
+        assert_eq!(root.item_paths.len(), 0, "root should be synthetic");
 
         let docs = find_node(&tree, "adam/Documents").unwrap();
         assert_eq!(docs.item_paths, vec!["Documents"]);
@@ -411,10 +411,10 @@ mod tests {
         assert!(root_names.contains(&"var"));
 
         let home = find_node(&tree, "home").unwrap();
-        assert!(home.item_paths.is_empty(), "home should be synthetic");
+        assert_eq!(home.item_paths.len(), 0, "home should be synthetic");
 
         let var = find_node(&tree, "var").unwrap();
-        assert!(var.item_paths.is_empty(), "var should be synthetic");
+        assert_eq!(var.item_paths.len(), 0, "var should be synthetic");
 
         let user = find_node(&tree, "home/user").unwrap();
         assert_eq!(user.item_paths, vec!["user"]);
diff --git a/crates/vykar-gui/src/repo_helpers.rs b/crates/vykar-gui/src/repo_helpers.rs
index 6b4a32f..87c8504 100644
--- a/crates/vykar-gui/src/repo_helpers.rs
+++ b/crates/vykar-gui/src/repo_helpers.rs
@@ -287,7 +287,7 @@ mod tests {
         );
         assert!(matches!(result, Err(VykarError::DecryptionFailed)));
         assert_eq!(calls.get(), 1, "configured passphrase is tried once");
-        assert!(cache.is_empty(), "failed passphrase must not be cached");
+        assert_eq!(cache.len(), 0, "failed passphrase must not be cached");
     }
 
     /// Regression guard for the retry loop's coupling to the error *type*.
@@ -487,7 +487,7 @@ mod tests {
             |_pass| unreachable!("f must not run when the prompt is dismissed"),
         );
         assert!(matches!(result, Ok(PassphraseRun::Canceled)));
-        assert!(cache.is_empty());
+        assert_eq!(cache.len(), 0);
     }
 
     #[test]
@@ -554,7 +554,7 @@ mod tests {
         );
         assert!(matches!(result, Err(VykarError::DecryptionFailed)));
         assert_eq!(calls.get(), 3, "should prompt exactly `attempts` times");
-        assert!(cache.is_empty());
+        assert_eq!(cache.len(), 0);
     }
 
     #[test]
@@ -574,6 +574,6 @@ mod tests {
             },
         );
         assert!(matches!(result, Ok(PassphraseRun::Ran("done"))));
-        assert!(cache.is_empty(), "None passphrase is never cached");
+        assert_eq!(cache.len(), 0, "None passphrase is never cached");
     }
 }
diff --git a/crates/vykar-gui/src/scheduler.rs b/crates/vykar-gui/src/scheduler.rs
index 47b9ed5..5b7f82c 100644
--- a/crates/vykar-gui/src/scheduler.rs
+++ b/crates/vykar-gui/src/scheduler.rs
@@ -261,7 +261,7 @@ mod tests {
                 .map(|(name, every, on)| ((*name).to_string(), sched(every, *on)))
                 .collect(),
         );
-        assert!(errors.is_empty(), "unexpected cadence errors: {errors:?}");
+        assert_eq!(errors.len(), 0, "unexpected cadence errors: {errors:?}");
         Arc::new(Mutex::new(state))
     }
 
diff --git a/crates/vykar-gui/src/worker/backup.rs b/crates/vykar-gui/src/worker/backup.rs
index 2ac174c..7b9d41b 100644
--- a/crates/vykar-gui/src/worker/backup.rs
+++ b/crates/vykar-gui/src/worker/backup.rs
@@ -414,7 +414,10 @@ mod tests {
     #[test]
     fn stale_name_selects_nothing() {
         let repos = two_repos();
-        assert!(select_repo_indices(&repos, Some(&["gone".to_string()])).is_empty());
-        assert!(select_repo_indices(&repos, Some(&[])).is_empty());
+        assert_eq!(
+            select_repo_indices(&repos, Some(&["gone".to_string()])).len(),
+            0
+        );
+        assert_eq!(select_repo_indices(&repos, Some(&[])).len(), 0);
     }
 }
diff --git a/crates/vykar-protocol/src/lib.rs b/crates/vykar-protocol/src/lib.rs
index 01799bf..9ec224e 100644
--- a/crates/vykar-protocol/src/lib.rs
+++ b/crates/vykar-protocol/src/lib.rs
@@ -470,7 +470,7 @@ mod tests {
         let plan: VerifyPacksPlanRequest = serde_json::from_str(json).unwrap();
         assert_eq!(plan.protocol_version(), 0);
         assert_eq!(plan.hash(), HashAlgorithm::Blake2b);
-        assert!(plan.packs.is_empty());
+        assert_eq!(plan.packs.len(), 0);
     }
 
     #[test]
diff --git a/crates/vykar-server/src/handlers/admin/repack.rs b/crates/vykar-server/src/handlers/admin/repack.rs
index 29b40eb..9dfcb56 100644
--- a/crates/vykar-server/src/handlers/admin/repack.rs
+++ b/crates/vykar-server/src/handlers/admin/repack.rs
@@ -822,7 +822,7 @@ mod tests {
         let op = &result["completed"][0];
         assert!(op["new_pack"].is_null());
         assert!(op["deleted"].as_bool().unwrap());
-        assert!(op["new_offsets"].as_array().unwrap().is_empty());
+        assert_eq!(op["new_offsets"].as_array().unwrap().len(), 0);
 
         assert!(!source_path.exists(), "source pack not deleted");
         assert!(
diff --git a/crates/vykar-server/src/handlers/admin/verify_structure.rs b/crates/vykar-server/src/handlers/admin/verify_structure.rs
index b5217f5..cfb31a6 100644
--- a/crates/vykar-server/src/handlers/admin/verify_structure.rs
+++ b/crates/vykar-server/src/handlers/admin/verify_structure.rs
@@ -142,7 +142,7 @@ mod tests {
         let json: serde_json::Value = serde_json::from_slice(&body_bytes(resp).await).unwrap();
 
         assert_eq!(json["ok"], true, "{json}");
-        assert!(json["errors"].as_array().unwrap().is_empty(), "{json}");
+        assert_eq!(json["errors"].as_array().unwrap().len(), 0, "{json}");
         assert_eq!(json["pack_count"], 1);
         assert_eq!(json["total_size"], pack_bytes.len() as u64);
         assert_eq!(json["temp_files"], 1);
diff --git a/crates/vykar-server/src/handlers/test_helpers.rs b/crates/vykar-server/src/handlers/test_helpers.rs
index acb9375..6fdfef3 100644
--- a/crates/vykar-server/src/handlers/test_helpers.rs
+++ b/crates/vykar-server/src/handlers/test_helpers.rs
@@ -125,7 +125,7 @@ pub fn assert_status(response: &axum::response::Response, expected: StatusCode)
 /// Recursively assert no server temp files remain under `dir`.
 pub fn assert_no_temp_files(dir: &std::path::Path) {
     let leftovers = temp_file_paths(dir);
-    assert!(leftovers.is_empty(), "leftover temp files: {leftovers:?}");
+    assert_eq!(leftovers.len(), 0, "leftover temp files: {leftovers:?}");
 }
 
 /// Recursively count server temp files (current `.tmp.*` and legacy
diff --git a/crates/vykar-server/src/state.rs b/crates/vykar-server/src/state.rs
index 0dae006..f239d7c 100644
--- a/crates/vykar-server/src/state.rs
+++ b/crates/vykar-server/src/state.rs
@@ -251,7 +251,7 @@ impl AppState {
             });
         }
         let used = self.quota_used();
-        let result = self.inner.quota_reserved.fetch_update(
+        let result = self.inner.quota_reserved.try_update(
             Ordering::Relaxed,
             Ordering::Relaxed,
             |reserved| {
@@ -275,11 +275,11 @@ impl AppState {
 
     /// Update quota usage after a delete.
     pub fn sub_quota_usage(&self, bytes: u64) {
-        // Use fetch_update for saturating subtraction
+        // Use try_update for saturating subtraction.
         let _ =
             self.inner
                 .quota_usage
-                .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |current| {
+                .try_update(Ordering::Relaxed, Ordering::Relaxed, |current| {
                     Some(current.saturating_sub(bytes))
                 });
     }
@@ -334,7 +334,7 @@ impl QuotaReservation {
             return Ok(());
         }
         let used = self.state.quota_used();
-        let result = self.state.inner.quota_reserved.fetch_update(
+        let result = self.state.inner.quota_reserved.try_update(
             Ordering::Relaxed,
             Ordering::Relaxed,
             |reserved| {
@@ -377,7 +377,7 @@ impl QuotaReservation {
 
     /// Release `bytes` from `quota_reserved`, saturating at zero.
     fn release_reserved(&self, bytes: u64) {
-        let _ = self.state.inner.quota_reserved.fetch_update(
+        let _ = self.state.inner.quota_reserved.try_update(
             Ordering::Relaxed,
             Ordering::Relaxed,
             |reserved| Some(reserved.saturating_sub(bytes)),
diff --git a/crates/vykar-storage/src/local_backend.rs b/crates/vykar-storage/src/local_backend.rs
index 5f25370..8d885e6 100644
--- a/crates/vykar-storage/src/local_backend.rs
+++ b/crates/vykar-storage/src/local_backend.rs
@@ -315,7 +315,7 @@ mod tests {
         let dir = tempfile::tempdir().unwrap();
         let backend = LocalBackend::new(dir.path().to_str().unwrap()).unwrap();
         let keys = backend.list("no_such_dir").unwrap();
-        assert!(keys.is_empty());
+        assert_eq!(keys, Vec::<String>::new());
     }
 
     #[test]