Verify low-frequency DMHY generated output

tools/rust_dmhy_template_apply/README.md

@@ -43,6 +43,16 @@ cargo run --release --manifest-path tools\rust_dmhy_template_apply\Cargo.toml --
   --threads 24
 ```
 
+Verify the generated training output has no low-frequency blocking warnings:
+
+```powershell
+cargo run --release --manifest-path tools\rust_dmhy_template_apply\Cargo.toml -- `
+  --verify-generated-output `
+  --input reports\dmhy_weak.template_generated.top5000.rust.jsonl `
+  --recipes reports\dmhy_template_recipes.full_top5000.seed.jsonl `
+  --audit-max-count 50
+```
+
 Optional controls:
 
 ```powershell

tools/rust_dmhy_template_apply/src/main.rs

@@ -19,6 +19,8 @@ struct Args {
     cluster: bool,
     #[arg(long)]
     audit_low_frequency: bool,
+    #[arg(long)]
+    verify_generated_output: bool,
     #[arg(long, default_value = "datasets/AnimeName/dmhy_list.jsonl")]
     input: PathBuf,
     #[arg(long, default_value = "reports/dmhy_template_recipes.seed.jsonl")]
@@ -92,7 +94,7 @@ struct Recipe {
     count: Option<u64>,
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 struct Record {
     filename: String,
     tokens: Vec<String>,
@@ -237,6 +239,9 @@ fn main() -> Result<()> {
     if args.audit_low_frequency {
         return run_low_frequency_audit(&args);
     }
+    if args.verify_generated_output {
+        return run_verify_generated_output(&args);
+    }
     if args.expand != "all" && args.expand != "sample" {
         bail!("--expand must be all or sample");
     }
@@ -704,6 +709,77 @@ fn run_low_frequency_audit(args: &Args) -> Result<()> {
     Ok(())
 }
 
+fn run_verify_generated_output(args: &Args) -> Result<()> {
+    let file = File::open(&args.input)
+        .with_context(|| format!("generated JSONL not found: {}", args.input.display()))?;
+    let recipes_by_id: HashMap<String, u64> = load_recipes(args)?
+        .into_values()
+        .map(|recipe| (recipe.template_id, recipe.count.unwrap_or(0)))
+        .collect();
+    let mut rows = 0usize;
+    let mut low_frequency_rows = 0usize;
+    let mut warning_counts: HashMap<String, usize> = HashMap::new();
+    let mut examples: HashMap<String, Vec<Value>> = HashMap::new();
+
+    for (line_number, line) in BufReader::new(file).lines().enumerate() {
+        let line = line?;
+        if line.trim().is_empty() {
+            continue;
+        }
+        let record: Record = serde_json::from_str(&line).with_context(|| {
+            format!(
+                "invalid generated record at {}:{}",
+                args.input.display(),
+                line_number + 1
+            )
+        })?;
+        rows += 1;
+        let count = recipes_by_id
+            .get(&record.template_id)
+            .copied()
+            .unwrap_or(u64::MAX);
+        if count > args.audit_max_count {
+            continue;
+        }
+        low_frequency_rows += 1;
+        for warning in audit_warnings(&record) {
+            if !matches!(
+                warning.as_str(),
+                "hash_labeled" | "multiple_title_spans" | "no_title" | "path_retained"
+            ) {
+                continue;
+            }
+            *warning_counts.entry(warning.clone()).or_default() += 1;
+            let bucket = examples.entry(warning).or_default();
+            if bucket.len() < 5 {
+                bucket.push(json!({
+                    "template_id": record.template_id,
+                    "template_count": count,
+                    "filename": record.filename,
+                    "spans": entity_spans(&record.tokens, &record.labels),
+                }));
+            }
+        }
+    }
+
+    let manifest = json!({
+        "generated_at": Utc::now().to_rfc3339(),
+        "input": args.input.to_string_lossy(),
+        "recipes": args.recipes.to_string_lossy(),
+        "audit_max_count": args.audit_max_count,
+        "rows": rows,
+        "low_frequency_rows": low_frequency_rows,
+        "blocking_warning_counts": warning_counts,
+        "examples": examples,
+        "implementation": "rust_dmhy_generated_output_verify"
+    });
+    println!("{}", serde_json::to_string_pretty(&manifest)?);
+    if !warning_counts.is_empty() {
+        bail!("generated output still has low-frequency blocking warnings");
+    }
+    Ok(())
+}
+
 fn entity_spans(tokens: &[String], labels: &[String]) -> Vec<Value> {
     let mut spans = Vec::new();
     let mut current_label: Option<String> = None;