Pluralize: catch adjective + plural cases, revert guaranteed-multi sites

Tightened the manual sweep with `\{[a-zA-Z_]+\} [a-z]+ [a-zA-Z][-a-zA-Z]+s\b` (count + adjective + plural). Real bugs the original `\{var\} \plural` regex missed got fixed; sites where the count is guaranteed > 1 got reverted with `// allowed-pluralize-noun: <reason>` markers so the source reads cleanly.

Fixed (count could be 1):
- `event_loop.rs`: `{event_count} live events` / `{event_count} replay + {live_count} live events` / `{new_file_count} new files, {} new dirs across {} affected dirs`.
- `manager.rs`: `~{gap} pending FSEvents`.
- `reconciler.rs`: `{total} buffered events`.
- `writer.rs`: `{free} free pages` + the breakdown loop (carries singular+plural per entry; `{count} {name}` over already-plural names was a real bug).
- `commands/settings.rs`: `{n} log files`.
- `smb.rs`: `{n_conflicts} conflicting files` (test).
- `font-metrics/index.ts`, `shortcuts-store.ts`, `DualPaneExplorer.svelte`, `TransferProgressDialog.svelte`: same shape.

Reverted (count guaranteed > 1) with `// allowed-pluralize-noun`:
- `MAX_PENDING_RESCANS` / `MAX_BUFFER_CAPACITY` / `MAX_USER_NOTE_CHARS` (constants).
- `chars().count()` after `> MAX_USER_NOTE_CHARS` validation.
- `validationIntervalDays` (const = 7) and `serverInvalidRetryCount` (guarded by `>= 3`) in the license dialog.
- The dedup line in `event_loop.rs` (only fires when `event_count >= 2`).
- The stress-test storm log + panic (storm fires many by design).
- `font-metrics/index.ts` `widthCount` (Unicode-range scan yields thousands).
- `settings-store.ts` registry-defaults count.

Author: vdavid

apps/desktop/src-tauri/src/commands/error_reporter.rs

@@ -6,7 +6,6 @@
 use crate::error_reporter::{
     self, BundleKind, BundleManifest, BundleScope, FLOW_A_BUNDLE_CAP_MB, settings_defaults::SettingValue,
 };
-use crate::pluralize::pluralize;
 use serde::Serialize;
 use std::collections::HashMap;
 
@@ -125,9 +124,9 @@ pub async fn save_error_report_to_disk(app: tauri::AppHandle, user_note: Option<
 fn validate_user_note(user_note: Option<String>) -> Result<Option<String>, String> {
     match user_note {
         Some(n) if n.chars().count() > MAX_USER_NOTE_CHARS => Err(format!(
-            "User note is too long ({}). Maximum is {}.",
-            pluralize(n.chars().count() as u64, "char"),
-            pluralize(MAX_USER_NOTE_CHARS as u64, "char"),
+            // allowed-pluralize-noun: both counts are guaranteed > MAX_USER_NOTE_CHARS (100_000).
+            "User note is too long ({} chars). Maximum is {MAX_USER_NOTE_CHARS} chars.",
+            n.chars().count(),
         )),
         other => Ok(other),
     }

apps/desktop/src-tauri/src/commands/settings.rs

@@ -102,7 +102,8 @@ pub fn set_max_log_storage_mb(value: u64) -> Result<(), String> {
             Ok(0) => {}
             Ok(n) => log::info!(
                 target: "cmdr_lib::logging",
-                "Eager-pruned {n} log files after cap change ({value} MB → keep {new_keep}).",
+                "Eager-pruned {} after cap change ({value} MB → keep {new_keep}).",
+                crate::pluralize::pluralize(n as u64, "log file"),
             ),
             Err(err) => return Err(format!("Failed to eager-prune log files: {err}")),
         }

apps/desktop/src-tauri/src/file_system/volume/smb.rs

@@ -4482,7 +4482,10 @@ mod tests {
             std::fs::write(&path, &buf).expect("write source");
         }
 
-        log::info!("regression: pre-uploading {n_conflicts} conflicting files to {unique_prefix}");
+        log::info!(
+            "regression: pre-uploading {} to {unique_prefix}",
+            crate::pluralize::pluralize(n_conflicts as u64, "conflicting file")
+        );
         for i in 0..n_conflicts {
             let name = format!("f_{i:04}.bin");
             let dest_abs = dest_dir_abs.join(&name);

apps/desktop/src-tauri/src/indexing/event_loop.rs

@@ -16,7 +16,7 @@ use super::scanner;
 use super::store::{self, IndexStore};
 use super::watcher;
 use super::writer::{IndexWriter, WriteMessage};
-use crate::pluralize::{pluralize, pluralize_with};
+use crate::pluralize::pluralize;
 
 // ── Live event loop ──────────────────────────────────────────────────
 
@@ -216,8 +216,9 @@ pub(super) async fn run_live_event_loop(
                             &volume_id,
                             RescanReason::WatcherChannelOverflow,
                             format!(
-                                "The filesystem watcher's event channel overflowed after \
-                                 {event_count} live events. Some file changes were lost."
+                                "The filesystem watcher's event channel overflowed after {}. \
+                                 Some file changes were lost.",
+                                pluralize(event_count, "live event")
                             ),
                         );
                         // Drain and discard remaining events: they're a partial
@@ -719,9 +720,9 @@ pub(super) async fn run_replay_event_loop(
     // ── Phase 2: After HistoryDone ───────────────────────────────────
 
     if deduped_total < event_count {
+        // allowed-pluralize-noun: dedup only kicks in when event_count >= 2.
         log::info!(
-            "Replay: deduplicated {event_count} raw events to {deduped_total} unique \
-             ({:.0}% reduction)",
+            "Replay: deduplicated {event_count} raw events to {deduped_total} unique ({:.0}% reduction)",
             (1.0 - deduped_total as f64 / event_count.max(1) as f64) * 100.0,
         );
     }
@@ -827,9 +828,9 @@ pub(super) async fn run_replay_event_loop(
             &volume_id,
             RescanReason::TooManySubdirRescans,
             format!(
-                "Replay accumulated more than {} needing full \
-                 rescans. This typically means a major filesystem reorganization happened.",
-                pluralize_with(MAX_PENDING_RESCANS as u64, "directory", "directories")
+                // allowed-pluralize-noun: MAX_PENDING_RESCANS is the const 1_000.
+                "Replay accumulated more than {MAX_PENDING_RESCANS} directories needing full \
+                 rescans. This typically means a major filesystem reorganization happened."
             ),
         );
         if let Some(tx) = fallback_tx.take() {
@@ -894,9 +895,10 @@ pub(super) async fn run_replay_event_loop(
                             &volume_id,
                             RescanReason::WatcherChannelOverflow,
                             format!(
-                                "The filesystem watcher's event channel overflowed after \
-                                 {event_count} replay + {live_count} live events. Some file \
-                                 changes were lost."
+                                "The filesystem watcher's event channel overflowed after {} + {}. \
+                                 Some file changes were lost.",
+                                pluralize(event_count, "replay event"),
+                                pluralize(live_count, "live event"),
                             ),
                         );
                         if let Some(tx) = fallback_tx.take() {
@@ -918,7 +920,11 @@ pub(super) async fn run_replay_event_loop(
         }
     }
 
-    log::info!("Replay event loop: stopped ({event_count} replay + {live_count} live events)");
+    log::info!(
+        "Replay event loop: stopped ({} + {})",
+        pluralize(event_count, "replay event"),
+        pluralize(live_count, "live event"),
+    );
     Ok(())
 }
 
@@ -1247,10 +1253,10 @@ fn verify_affected_dirs(affected_paths: &HashSet<String>, writer: &IndexWriter)
 
     if stale_count > 0 || new_file_count > 0 || !new_dir_paths.is_empty() {
         log::debug!(
-            "Replay verification: {stale_count} stale, {new_file_count} new files, \
-             {} new dirs across {} affected dirs",
-            new_dir_paths.len(),
-            affected_paths.len(),
+            "Replay verification: {stale_count} stale, {}, {} across {}",
+            pluralize(new_file_count, "new file"),
+            pluralize(new_dir_paths.len() as u64, "new dir"),
+            pluralize(affected_paths.len() as u64, "affected dir"),
         );
     }
 

apps/desktop/src-tauri/src/indexing/manager.rs

@@ -183,7 +183,7 @@ impl IndexManager {
                 let gap = current_id.saturating_sub(since_event_id);
                 DEBUG_STATS.set_phase(
                     ActivityPhase::Replaying,
-                    &format!("app launch, ~{gap} pending FSEvents"),
+                    &format!("app launch, ~{}", pluralize(gap, "pending FSEvent")),
                 );
                 log::info!("Replay: watcher started (since_event_id={since_event_id}, current={current_id})");
             }

apps/desktop/src-tauri/src/indexing/reconciler.rs

@@ -147,9 +147,9 @@ impl EventReconciler {
         }
         if self.buffer.len() >= MAX_BUFFER_CAPACITY {
             log::warn!(
-                "Reconciler: buffer cap reached ({}). \
-                 Dropping further events; a full rescan will run after the current scan.",
-                pluralize(MAX_BUFFER_CAPACITY as u64, "event")
+                // allowed-pluralize-noun: MAX_BUFFER_CAPACITY is the const 500_000.
+                "Reconciler: buffer cap reached ({MAX_BUFFER_CAPACITY} events). \
+                 Dropping further events; a full rescan will run after the current scan."
             );
             self.buffer_overflow = true;
             self.buffer.clear();
@@ -180,7 +180,10 @@ impl EventReconciler {
         let mut last_event_id = scan_start_event_id;
         let mut affected_paths: Vec<String> = Vec::new();
 
-        log::info!("Reconciler: replaying {total} buffered events (scan_start_event_id={scan_start_event_id})");
+        log::info!(
+            "Reconciler: replaying {} (scan_start_event_id={scan_start_event_id})",
+            pluralize(total as u64, "buffered event")
+        );
 
         for event in &self.buffer {
             // Skip events that the scan already covered

apps/desktop/src-tauri/src/indexing/stress_tests_concurrency.rs

@@ -961,6 +961,7 @@ fn test_listings_complete_under_reconciler_load_and_rapid_navigation() {
     checkpoint_handle.join().expect("checkpoint thread panicked");
 
     let total_events = events_fired.load(Ordering::Relaxed);
+    // allowed-pluralize-noun: stress test explicitly fires many reconciler events.
     log::info!(target: "stall_probe::test", "storm fired {total_events} reconciler events");
 
     // ── Assertion: each listing must complete within the SLA ──────────
@@ -981,10 +982,10 @@ fn test_listings_complete_under_reconciler_load_and_rapid_navigation() {
             .collect::<Vec<_>>()
             .join("\n  ");
         panic!(
-            "{} exceeded the {SLA_MS}ms SLA under reconciler load (storm: {}):\n  {summary}\n\n\
+            // allowed-pluralize-noun: stress test explicitly fires many events.
+            "{} exceeded the {SLA_MS}ms SLA under reconciler load (storm: {total_events} events):\n  {summary}\n\n\
              See the captured `stall_probe::*` log lines above (run with --no-capture to see them on stderr).",
             pluralize(violators.len() as u64, "listing"),
-            pluralize(total_events, "event"),
         );
     }
 

apps/desktop/src-tauri/src/indexing/writer.rs

@@ -381,31 +381,36 @@ impl WriterStats {
             return;
         }
 
-        let deltas: &[(&str, u64)] = &[
-            ("inserts", self.current.insert_entries - self.previous.insert_entries),
-            ("upserts", self.current.upsert_entry - self.previous.upsert_entry),
-            ("moves", self.current.move_entry - self.previous.move_entry),
-            ("deletes", self.current.delete_entry - self.previous.delete_entry),
+        // (singular, plural, count). Pluralizing per row keeps the "+1 insert"
+        // / "+5 inserts" form natural; baking `+s` everywhere reads as "+1 inserts".
+        let deltas: &[(&str, &str, u64)] = &[
+            ("insert", "inserts", self.current.insert_entries - self.previous.insert_entries),
+            ("upsert", "upserts", self.current.upsert_entry - self.previous.upsert_entry),
+            ("move", "moves", self.current.move_entry - self.previous.move_entry),
+            ("delete", "deletes", self.current.delete_entry - self.previous.delete_entry),
             (
+                "delete_subtree",
                 "delete_subtrees",
                 self.current.delete_subtree - self.previous.delete_subtree,
             ),
             (
-                "propagate",
+                "propagation",
+                "propagations",
                 self.current.propagate_delta - self.previous.propagate_delta,
             ),
             (
+                "aggregate",
                 "aggregates",
                 self.current.compute_aggregates - self.previous.compute_aggregates,
             ),
-            ("flushes", self.current.flush - self.previous.flush),
-            ("other", self.current.other - self.previous.other),
+            ("flush", "flushes", self.current.flush - self.previous.flush),
+            ("other", "others", self.current.other - self.previous.other),
         ];
 
         let parts: Vec<String> = deltas
             .iter()
-            .filter(|(_, count)| *count > 0)
-            .map(|(name, count)| format!("{count} {name}"))
+            .filter(|(_, _, count)| *count > 0)
+            .map(|(singular, plural, count)| pluralize_with(*count, singular, plural))
             .collect();
 
         let breakdown = if parts.is_empty() {
@@ -1388,7 +1393,10 @@ fn handle_incremental_vacuum(conn: &rusqlite::Connection) {
             if let Err(e) = conn.execute_batch("PRAGMA incremental_vacuum(2000)") {
                 log::warn!("Writer: incremental_vacuum failed: {e}");
             } else {
-                log::debug!("Writer: incremental_vacuum reclaimed up to 2000 of {free} free pages");
+                log::debug!(
+                    "Writer: incremental_vacuum reclaimed up to 2000 of {}",
+                    pluralize(free as u64, "free page")
+                );
             }
         }
         Ok(_) => {} // No free pages, nothing to do

apps/desktop/src/lib/file-explorer/pane/DualPaneExplorer.svelte

@@ -1717,8 +1717,12 @@
             return
         }
         log.debug(
-            'openDeleteDialog: opening delete confirmation. {count} valid entries, sourceVolId={volId}',
-            { count: validEntries.length, volId: getPaneVolumeId(focusedPane) },
+            'openDeleteDialog: opening delete confirmation. {count} {entriesNoun}, sourceVolId={volId}',
+            {
+                count: validEntries.length,
+                entriesNoun: pluralize(validEntries.length, 'valid entry', 'valid entries'),
+                volId: getPaneVolumeId(focusedPane),
+            },
         )
 
         const sourceItems: DeleteSourceItem[] = validEntries.map((e) => ({

apps/desktop/src/lib/file-operations/transfer/TransferProgressDialog.svelte

@@ -447,7 +447,10 @@
     let unlisteners: UnlistenFn[] = []
 
     function cleanup() {
-        log.debug('Cleaning up {count} event listeners', { count: unlisteners.length })
+        log.debug('Cleaning up {count} {listenersNoun}', {
+            count: unlisteners.length,
+            listenersNoun: pluralize(unlisteners.length, 'event listener'),
+        })
         for (const unlisten of unlisteners) {
             unlisten()
         }