fix(pipeline): address review nits on related-legislation resolution

- Validate the single-hit SRU result as a BWB id before resolving, so a
  malformed SRU id can't slip into a harvest payload (paths a/b already validate).
- Read the .enrichment-result.yaml sidecar via tokio::fs (was blocking std::fs)
  for consistency with the rest of execute_enrich_with_runner.
- Clarify the depth-inherit comment: the field is the shared extref-recursion
  counter, so deep-via-extref laws skip related discovery (roots/shallow laws,
  the intended case, are unaffected).

Author: tdjager

packages/pipeline/src/enrich.rs

@@ -433,9 +433,9 @@ pub struct EnrichmentResultEnvelope {
 /// Never errors, so it can never fail an otherwise-successful enrichment:
 /// - absent file → empty list;
 /// - unparseable file → logged at `warn` and empty list.
-fn read_enrichment_result_envelope(yaml_abs: &Path) -> Vec<RelatedLegislation> {
+async fn read_enrichment_result_envelope(yaml_abs: &Path) -> Vec<RelatedLegislation> {
     let envelope_path = enrichment_result_path(yaml_abs);
-    let content = match std::fs::read_to_string(&envelope_path) {
+    let content = match tokio::fs::read_to_string(&envelope_path).await {
         Ok(c) => c,
         Err(_) => return Vec::new(),
     };
@@ -1162,7 +1162,7 @@ pub async fn execute_enrich_with_runner(
 
     // Read the related-legislation result envelope the agent may have written.
     // Never fails: absent/malformed → empty (see read_enrichment_result_envelope).
-    let related_legislation = read_enrichment_result_envelope(&yaml_abs);
+    let related_legislation = read_enrichment_result_envelope(&yaml_abs).await;
 
     // Collect written files for corpus staging
     let mut written_files = vec![yaml_abs.clone(), metadata_path];
@@ -1392,16 +1392,16 @@ related_legislation:
         assert!(entry.bwb_id.is_none());
     }
 
-    #[test]
-    fn test_read_envelope_absent_file_is_empty() {
+    #[tokio::test]
+    async fn test_read_envelope_absent_file_is_empty() {
         let dir = tempfile::tempdir().unwrap();
         let yaml_abs = dir.path().join("2025-01-01.yaml");
         // No sidecar exists next to it.
-        assert!(read_enrichment_result_envelope(&yaml_abs).is_empty());
+        assert!(read_enrichment_result_envelope(&yaml_abs).await.is_empty());
     }
 
-    #[test]
-    fn test_read_envelope_malformed_is_empty() {
+    #[tokio::test]
+    async fn test_read_envelope_malformed_is_empty() {
         let dir = tempfile::tempdir().unwrap();
         let yaml_abs = dir.path().join("2025-01-01.yaml");
         std::fs::write(
@@ -1410,19 +1410,19 @@ related_legislation:
         )
         .unwrap();
         // Malformed sidecar must never error — it degrades to empty.
-        assert!(read_enrichment_result_envelope(&yaml_abs).is_empty());
+        assert!(read_enrichment_result_envelope(&yaml_abs).await.is_empty());
     }
 
-    #[test]
-    fn test_read_envelope_present_parses() {
+    #[tokio::test]
+    async fn test_read_envelope_present_parses() {
         let dir = tempfile::tempdir().unwrap();
         let yaml_abs = dir.path().join("2025-01-01.yaml");
         std::fs::write(
             enrichment_result_path(&yaml_abs),
             "related_legislation:\n  - name: Delegated Regeling\n    bwb_id: BWBR0037841\n",
         )
         .unwrap();
-        let related = read_enrichment_result_envelope(&yaml_abs);
+        let related = read_enrichment_result_envelope(&yaml_abs).await;
         assert_eq!(related.len(), 1);
         assert_eq!(related[0].bwb_id.as_deref(), Some("BWBR0037841"));
     }

packages/pipeline/src/worker.rs

@@ -412,8 +412,12 @@ async fn process_next_job(
                         law_id: job.law_id.clone(),
                         yaml_path: result.file_path.clone(),
                         provider: Some((*provider_name).to_string()),
-                        // Inherit the just-completed harvest's depth so a
-                        // related-legislation harvest chain keeps counting.
+                        // Inherit the harvest's depth. NB: this is the shared
+                        // extref-recursion counter, so a law reached via
+                        // >= RELATED_HARVEST_MAX_DEPTH extref hops enriches at a
+                        // depth that skips related-legislation discovery. Roots and
+                        // shallow laws (the intended case) are unaffected; a
+                        // dedicated related-depth counter is the follow-up.
                         depth: payload.depth,
                     };
                     let payload_json = match serde_json::to_value(&enrich_payload) {
@@ -945,9 +949,13 @@ async fn resolve_related_bwb_id(
         }
     }
 
-    // (c) SRU search by name — accept only an unambiguous single hit
+    // (c) SRU search by name — accept only an unambiguous single hit, and only
+    // if it is a well-formed BWB id (paths a/b validate too; don't let a
+    // malformed SRU id slip into a harvest payload).
     match crate::api::bwb_search::search_bwb_by_name(http_client, &entry.name).await {
-        Ok(results) if results.len() == 1 => RelatedResolution::Resolved(results[0].bwb_id.clone()),
+        Ok(results) if results.len() == 1 && is_valid_bwb_id(&results[0].bwb_id) => {
+            RelatedResolution::Resolved(results[0].bwb_id.clone())
+        }
         Ok(results) if results.len() > 1 => RelatedResolution::NeedsConfirmation,
         Ok(_) => RelatedResolution::Unresolved,
         Err(e) => {