fix: review feedback — shared locale validation, tuner error reporting

- Extract extract_locale_from_filename() to util.rs with languages.json
  validation (prevents false positives like "foo.setup.md" → "setup")
- Remove duplicate implementations from corpus.rs and language.rs
- Add failure counter to parallel tuner — surfaces error count in summary
  instead of silently dropping failed ways

Author: aaronsb

tools/ways-cli/src/cmd/corpus.rs

@@ -188,7 +188,7 @@ fn scan_ways_dir(dir: &Path, id_prefix: &str, excluded: &[String], w: &mut impl
         }
 
         // Detect locale override files ({name}.{lang}.md)
-        if let Some(lang) = detect_locale_in_filename(fname) {
+        if let Some(lang) = crate::util::extract_locale_from_filename(fname) {
             if let Some(parent) = path.parent() {
                 locale_overrides.insert((parent.to_path_buf(), lang));
             }
@@ -271,25 +271,6 @@ fn scan_ways_dir(dir: &Path, id_prefix: &str, excluded: &[String], w: &mut impl
     Ok(count)
 }
 
-/// Detect a locale code in a filename like "security.ja.md" → Some("ja")
-fn detect_locale_in_filename(filename: &str) -> Option<String> {
-    if filename.contains(".check.") {
-        return None;
-    }
-    let stem = filename.strip_suffix(".md")?;
-    let parts: Vec<&str> = stem.split('.').collect();
-    if parts.len() >= 2 {
-        let candidate = parts[parts.len() - 1];
-        if candidate.len() >= 2
-            && candidate.len() <= 5
-            && candidate.chars().all(|c| c.is_ascii_lowercase() || c == '-')
-        {
-            return Some(candidate.to_string());
-        }
-    }
-    None
-}
-
 /// Find the BM25 threshold from the parent way's frontmatter.
 fn find_parent_threshold(dir: &Path) -> f64 {
     if let Ok(entries) = std::fs::read_dir(dir) {

tools/ways-cli/src/cmd/language.rs

@@ -210,7 +210,7 @@ fn scan_way_dirs(
                 }
 
                 // Check for locale override files: {name}.{lang}.md
-                if let Some(locale) = extract_locale(&fname) {
+                if let Some(locale) = crate::util::extract_locale_from_filename(&fname) {
                     locales.insert(locale.clone());
                     all_locales.insert(locale);
                     continue;
@@ -235,33 +235,6 @@ fn scan_way_dirs(
     Ok(())
 }
 
-/// Extract locale code from filename like "security.ja.md" → "ja"
-/// Validates against languages.json to avoid false matches like ".check.md"
-fn extract_locale(filename: &str) -> Option<String> {
-    // Skip check files explicitly
-    if filename.contains(".check.") {
-        return None;
-    }
-
-    let parts: Vec<&str> = filename.strip_suffix(".md")?.split('.').collect();
-    if parts.len() >= 2 {
-        let candidate = parts[parts.len() - 1];
-        // Validate it looks like a locale code (2-5 chars, lowercase/hyphen)
-        if candidate.len() >= 2
-            && candidate.len() <= 5
-            && candidate.chars().all(|c| c.is_ascii_lowercase() || c == '-')
-        {
-            // Verify against languages.json
-            let parsed: serde_json::Value =
-                serde_json::from_str(agents::LANGUAGES_JSON).ok()?;
-            if parsed.get("languages")?.as_object()?.contains_key(candidate) {
-                return Some(candidate.to_string());
-            }
-        }
-    }
-    None
-}
-
 /// Best-effort reverse lookup: language name → code
 fn resolve_to_code(lang: &str) -> String {
     let lower = lang.to_lowercase();

tools/ways-cli/src/cmd/tune.rs

@@ -133,6 +133,7 @@ pub fn run(
     // Shared state
     let work_queue: Arc<Mutex<Vec<(String, PathBuf)>>> = Arc::new(Mutex::new(locale_files));
     let completed: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));
+    let failed: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));
     let all_results: Arc<Mutex<Vec<WayTuneResult>>> = Arc::new(Mutex::new(Vec::new()));
 
     // Spawn workers
@@ -141,6 +142,7 @@ pub fn run(
         let queue = Arc::clone(&work_queue);
         let results = Arc::clone(&all_results);
         let completed = Arc::clone(&completed);
+        let failed = Arc::clone(&failed);
         let embed_bin = embed_bin.clone();
         let multi_corpus = multi_corpus.clone();
         let multi_model = multi_model.clone();
@@ -163,7 +165,9 @@ pub fn run(
                         r.push(result);
                     }
                     Err(e) => {
-                        eprintln!("ERROR tuning {}: {}", way_id, e);
+                        eprintln!("\nERROR tuning {}: {}", way_id, e);
+                        let mut f = failed.lock().unwrap();
+                        *f += 1;
                     }
                 }
 
@@ -183,6 +187,11 @@ pub fn run(
     }
     eprintln!();
 
+    let fail_count = *failed.lock().unwrap();
+    if fail_count > 0 {
+        eprintln!("WARNING: {} ways failed to tune", fail_count);
+    }
+
     // Collect and sort
     let mut way_results = Arc::try_unwrap(all_results)
         .map_err(|_| anyhow::anyhow!("failed to unwrap results"))

tools/ways-cli/src/util.rs

@@ -49,6 +49,31 @@ pub fn load_excluded_segments() -> Vec<String> {
         .unwrap_or_default()
 }
 
+/// Extract a locale code from a filename like "security.ja.md" → Some("ja").
+/// Validates against languages.json to avoid false matches (e.g., "foo.setup.md").
+pub fn extract_locale_from_filename(filename: &str) -> Option<String> {
+    if filename.contains(".check.") {
+        return None;
+    }
+    let stem = filename.strip_suffix(".md")?;
+    let parts: Vec<&str> = stem.split('.').collect();
+    if parts.len() >= 2 {
+        let candidate = parts[parts.len() - 1];
+        if candidate.len() >= 2
+            && candidate.len() <= 5
+            && candidate.chars().all(|c| c.is_ascii_lowercase() || c == '-')
+        {
+            // Validate against languages.json
+            let parsed: serde_json::Value =
+                serde_json::from_str(crate::agents::LANGUAGES_JSON).ok()?;
+            if parsed.get("languages")?.as_object()?.contains_key(candidate) {
+                return Some(candidate.to_string());
+            }
+        }
+    }
+    None
+}
+
 /// Check if a path should be excluded based on schema-defined segments.
 pub fn is_excluded_path(path: &Path, excluded_segments: &[String]) -> bool {
     let path_str = match path.to_str() {